Java 获取特定树编码中从根到叶的路径

我有一个树，表示为一个

Set[]

以下

设置[]

：

[ { 1 }, { 2, 3 }, { 4 }, { 5, 6, 7 } ]

表示以下树：

      1
     / \
    /   \
   /     \
  2       3
  |       |
  4       4
 /|\     /|\
5 6 7   5 6 7

因此，树中的每个级别都编码为一个

集

。树中特定级别上的所有子级集都是相同的。第一个集合中可以有多个整数

我想从

集合[]

中获得从根到叶的所有路径的列表：

[ [ 1, 2, 4, 5 ], [ 1, 2, 4, 6 ], [ 1, 2, 4, 7 ], [ 1, 3, 4, 5 ], [ 1, 3, 4, 6 ], [ 1, 3, 4, 7 ] ]

---

我不打算编写代码，但最简单的方法是深度优先遍历，在每个级别，您都将每个条目附加到当前路径

此外，返回值将是列表的集合（或数组）（因为垂直路径不能是无序集）

在伪代码中：

def getPaths(levels) {
  return getPaths(levels, 0, new Set())
}

def getPaths(levels, currentIndex, paths) {

  if(currentIndex == levels.length)
    return paths

  def newPaths = new Set(paths)

  for(path : paths) {
    for(level : levels) {
      newPaths.add( path + level )
    }
  }

  return getPaths(levels, currentIndex + 1, newPaths)

}

---

试着这样做：

public static List<Integer[]> getAllPaths(Set<Integer>[] tree){

    // Get the overall number of path
    int totalSize = 1;
    for(Set<Integer> line : tree){
        totalSize *= line.size();
    }

    // Create the empty paths
    List<Integer[]> allPaths = new ArrayList<Integer[]>(totalSize);
    for(int i = 0 ; i<totalSize ; ++i){
        Integer[] path = new Integer[tree.length];
        allPaths.add(path);
    }

    // Fill the paths
    int indexLine = 0;
    for (Set<Integer> line : tree) {
        Iterator<Integer[]> pathIterator = allPaths.iterator();
        Iterator<Integer> lineIterator = line.iterator();
        while(pathIterator.hasNext()){
            if(!lineIterator.hasNext()){
                lineIterator = line.iterator();
            }
            pathIterator.next()[indexLine] = lineIterator.next();
        }
        ++indexLine;
    }
    return allPaths;
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DFS {
  private List<Integer> currentPath = new ArrayList<Integer>();
  private List<Integer[]> paths = new ArrayList<Integer[]>();
  private ArrayList<Set<Integer>> tree;
  private Integer root;
  /**
   * constructor
   * @param tree
   */
  public DFS(ArrayList<Set<Integer>> tree) { 
    this.tree = tree;
  }

  public List<Integer[]> getPaths() {
    return paths;
  }
  public void setPaths(List<Integer[]> paths) {
    this.paths = paths;
  }
  public Integer getRoot() {
    return root;
  }
  public void setRoot(Integer root) {
    this.root = root;
  }

/**
 * initializes our search, sets the root and adds it to the path
 */
  public void initialize() {
    root = -1;
    for (Integer node : tree.get(0)) {
      root = node;
    }
    currentPath.add(root);
  }

  /**
   * This returns the adjacent nodes to an integer node in the tree
   * @param node
   * @return a set of adjacent nodes, and null otherwise
   */
  public Set<Integer> getAdjacentsToNode(Integer node) {

    for (int i = 0; i < tree.size(); i++) {
      Set<Integer> level = tree.get(i);
      if (level.contains(node) && i < tree.size() - 1) {
        return tree.get(i + 1);
      }
    }
    return null;
  }

  /**
   * runs a DFS on the tree to retrieve all paths
   * @param tree
   */
  public void runDFS(Integer node) {
    if (getAdjacentsToNode(node) != null) {
      for (Integer adjNode : getAdjacentsToNode(node)) {
        currentPath.add(adjNode);
        runDFS(adjNode);
      }
      currentPath.remove(currentPath.size() -1);
    } else {
      paths.add(currentPath.toArray(new Integer[0]));
      currentPath.remove(currentPath.size() -1);
    }
  }
}

公共静态列表getAllPath（Set[]树）{
//获取路径的总数
int totalSize=1；
用于（设置行：树）{
totalSize*=line.size（）；
}
//创建空路径
List allpath=new ArrayList（totalSize）；
对于（int i=0；i而言，在树中搜索的关键通常是实现一个良好的Ajacence函数，该函数为特定节点提供相邻节点

对于此树，邻接函数将查找节点所在的级别，然后将下一级别中的节点作为邻接返回。它将如下所示：

  /**
   * This returns the adjacent nodes to an integer node in the tree
   * @param node
   * @return a set of adjacent nodes, and null otherwise
   */
  public Set<Integer> getAdjacentsToNode(Integer node) {

    for (int i = 0; i < tree.size(); i++) {
      Set<Integer> level = tree.get(i);
      if (level.contains(node) && i < tree.size() - 1) {
        return tree.get(i + 1);
      }
    }
    return null;
  }

假设
currentPath
和
root
已定义为字段

然后，我们在树上运行DFS搜索，在遍历树时将每个节点附加到当前路径，然后将该路径添加到设置的路径中，并在到达死端时重置它（叶）：

因此，整个班级的情况如下：

public static List<Integer[]> getAllPaths(Set<Integer>[] tree){

    // Get the overall number of path
    int totalSize = 1;
    for(Set<Integer> line : tree){
        totalSize *= line.size();
    }

    // Create the empty paths
    List<Integer[]> allPaths = new ArrayList<Integer[]>(totalSize);
    for(int i = 0 ; i<totalSize ; ++i){
        Integer[] path = new Integer[tree.length];
        allPaths.add(path);
    }

    // Fill the paths
    int indexLine = 0;
    for (Set<Integer> line : tree) {
        Iterator<Integer[]> pathIterator = allPaths.iterator();
        Iterator<Integer> lineIterator = line.iterator();
        while(pathIterator.hasNext()){
            if(!lineIterator.hasNext()){
                lineIterator = line.iterator();
            }
            pathIterator.next()[indexLine] = lineIterator.next();
        }
        ++indexLine;
    }
    return allPaths;
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DFS {
  private List<Integer> currentPath = new ArrayList<Integer>();
  private List<Integer[]> paths = new ArrayList<Integer[]>();
  private ArrayList<Set<Integer>> tree;
  private Integer root;
  /**
   * constructor
   * @param tree
   */
  public DFS(ArrayList<Set<Integer>> tree) { 
    this.tree = tree;
  }

  public List<Integer[]> getPaths() {
    return paths;
  }
  public void setPaths(List<Integer[]> paths) {
    this.paths = paths;
  }
  public Integer getRoot() {
    return root;
  }
  public void setRoot(Integer root) {
    this.root = root;
  }

/**
 * initializes our search, sets the root and adds it to the path
 */
  public void initialize() {
    root = -1;
    for (Integer node : tree.get(0)) {
      root = node;
    }
    currentPath.add(root);
  }

  /**
   * This returns the adjacent nodes to an integer node in the tree
   * @param node
   * @return a set of adjacent nodes, and null otherwise
   */
  public Set<Integer> getAdjacentsToNode(Integer node) {

    for (int i = 0; i < tree.size(); i++) {
      Set<Integer> level = tree.get(i);
      if (level.contains(node) && i < tree.size() - 1) {
        return tree.get(i + 1);
      }
    }
    return null;
  }

  /**
   * runs a DFS on the tree to retrieve all paths
   * @param tree
   */
  public void runDFS(Integer node) {
    if (getAdjacentsToNode(node) != null) {
      for (Integer adjNode : getAdjacentsToNode(node)) {
        currentPath.add(adjNode);
        runDFS(adjNode);
      }
      currentPath.remove(currentPath.size() -1);
    } else {
      paths.add(currentPath.toArray(new Integer[0]));
      currentPath.remove(currentPath.size() -1);
    }
  }
}

只是想澄清一下，树是表示为一组数组还是一组集合的数组？我有点困惑。@Wesam：问题是：
set[]
，所以这是一个
set
的数组。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DFS {
  private List<Integer> currentPath = new ArrayList<Integer>();
  private List<Integer[]> paths = new ArrayList<Integer[]>();
  private ArrayList<Set<Integer>> tree;
  private Integer root;
  /**
   * constructor
   * @param tree
   */
  public DFS(ArrayList<Set<Integer>> tree) { 
    this.tree = tree;
  }

  public List<Integer[]> getPaths() {
    return paths;
  }
  public void setPaths(List<Integer[]> paths) {
    this.paths = paths;
  }
  public Integer getRoot() {
    return root;
  }
  public void setRoot(Integer root) {
    this.root = root;
  }

/**
 * initializes our search, sets the root and adds it to the path
 */
  public void initialize() {
    root = -1;
    for (Integer node : tree.get(0)) {
      root = node;
    }
    currentPath.add(root);
  }

  /**
   * This returns the adjacent nodes to an integer node in the tree
   * @param node
   * @return a set of adjacent nodes, and null otherwise
   */
  public Set<Integer> getAdjacentsToNode(Integer node) {

    for (int i = 0; i < tree.size(); i++) {
      Set<Integer> level = tree.get(i);
      if (level.contains(node) && i < tree.size() - 1) {
        return tree.get(i + 1);
      }
    }
    return null;
  }

  /**
   * runs a DFS on the tree to retrieve all paths
   * @param tree
   */
  public void runDFS(Integer node) {
    if (getAdjacentsToNode(node) != null) {
      for (Integer adjNode : getAdjacentsToNode(node)) {
        currentPath.add(adjNode);
        runDFS(adjNode);
      }
      currentPath.remove(currentPath.size() -1);
    } else {
      paths.add(currentPath.toArray(new Integer[0]));
      currentPath.remove(currentPath.size() -1);
    }
  }
}

public static void main(String[] args) { 
    ArrayList<Set<Integer>> tree = new ArrayList<Set<Integer>>();
    Set<Integer> level1 = new HashSet<Integer>();
    level1.add(new Integer(1));

    Set<Integer> level2 = new HashSet<Integer>();
    level2.add(new Integer(2));
    level2.add(new Integer(3));

    Set<Integer> level3 = new HashSet<Integer>();
    level3.add(new Integer(4));

    Set<Integer> level4 = new HashSet<Integer>();
    level4.add(new Integer(5));
    level4.add(new Integer(6));
    level4.add(new Integer(7));

    tree.add(level1);
    tree.add(level2);
    tree.add(level3);
    tree.add(level4);

    DFS dfsSearch = new DFS(tree); 
    dfsSearch.initialize();
    dfsSearch.runDFS(dfsSearch.getRoot());

    for (Integer[] path : dfsSearch.getPaths()) { 
      System.out.println(Arrays.toString(path));
    }

[1, 2, 4, 5]
[1, 2, 4, 6]
[1, 2, 4, 7]
[1, 3, 4, 5]
[1, 3, 4, 6]
[1, 3, 4, 7]