Java 實現深度遍歷和廣度遍歷數及其應用

一、深度遍歷和廣度遍歷原理及實現

1、深度優先

英文縮寫為DFS即Depth First Search.其過程簡要來說是對每一個可能的分支路徑深入到不能再深入為止，而且每個節點只能訪問一次。對於上面的例子來說深度優先遍歷的結果就是：A,B,D,E,I,C,F,G,H.(假設先走子節點的的左側)。

深度優先遍歷各個節點，需要使用到堆（Stack）這種數據結構。stack的特點是是先進后出。整個遍歷過程如下：

首先將A節點壓入堆中，stack（A）;

將A節點彈出，同時將A的子節點C，B壓入堆中，此時B在堆的頂部，stack(B,C)；

將B節點彈出，同時將B的子節點E，D壓入堆中，此時D在堆的頂部，stack（D,E,C）；

將D節點彈出，沒有子節點壓入,此時E在堆的頂部，stack（E，C）；

將E節點彈出，同時將E的子節點I壓入，stack（I,C）；

...依次往下，最終遍歷完成，Java代碼大概如下：

 

public void depthFirst() {

    Stack<Map<String, Object>> nodeStack = new Stack<Map<String, Object>>();

    Map<String, Object> node = new HashMap<String, Object>();

    nodeStack.add(node);

    while (!nodeStack.isEmpty()) {

        node = nodeStack.pop();

        System.out.println(node);

        //獲得節點的子節點，對於二叉樹就是獲得節點的左子結點和右子節點

        List<Map<String, Object>> children = getChildren(node);

        if (children != null && !children.isEmpty()) {

            for (Map child : children) {

                nodeStack.push(child);

            }

        }

    }

}

​//節點使用Map存放

2、廣度優先

        英文縮寫為BFS即Breadth FirstSearch。其過程檢驗來說是對每一層節點依次訪問，訪問完一層進入下一層，而且每個節點只能訪問一次。對於上面的例子來說，廣度優先遍歷的 結果是：A,B,C,D,E,F,G,H,I(假設每層節點從左到右訪問)。

       廣度優先遍歷各個節點，需要使用到隊列（Queue）這種數據結構，queue的特點是先進先出，其實也可以使用雙端隊列，區別就是雙端隊列首位都可以插入和彈出節點。整個遍歷過程如下：

      首先將A節點插入隊列中，queue（A）;

      將A節點彈出，同時將A的子節點B，C插入隊列中，此時B在隊列首，C在隊列尾部，queue（B，C）；

      將B節點彈出，同時將B的子節點D，E插入隊列中，此時C在隊列首，E在隊列尾部，queue（C，D，E）;

      將C節點彈出，同時將C的子節點F，G，H插入隊列中，此時D在隊列首，H在隊列尾部，queue（D，E，F，G，H）；

      將D節點彈出，D沒有子節點，此時E在隊列首，H在隊列尾部，queue（E，F，G，H）；

      ...依次往下，最終遍歷完成，Java代碼大概如下：

public void breadthFirst() {

    Deque<Map<String, Object>> nodeDeque = new ArrayDeque<Map<String, Object>>();

    Map<String, Object> node = new HashMap<String, Object>();

    nodeDeque.add(node);

    while (!nodeDeque.isEmpty()) {

        node = nodeDeque.peekFirst();

        System.out.println(node);

        //獲得節點的子節點，對於二叉樹就是獲得節點的左子結點和右子節點

        List<Map<String, Object>> children = getChildren(node);

        if (children != null && !children.isEmpty()) {

            for (Map child : children) {

                nodeDeque.add(child);

            }

        }

    }

}

//這里使用的是雙端隊列，和使用queue是一樣的

二、應用---用雙端隊列實現深度優先算法，遍歷樹，返回滿足某些要求的所有的路徑

1、將接口Filter類作為深度遍歷函數depthFirstStatePath的參數

    為了實現參數的多態，將接口類作為depthFirstStatePath函數的參數。因為Filter是接口，所以其中的函數都是多態的，這樣就實現了depthFirstStatePath的參數的多態。

接口類：Filter

public interface Filter<StateNode>{

boolean FilterofStatePath(List<StateNode> nodePath);

        }

 

深度遍歷類：depthFirst

 

public class depthFirst(){

//遍歷函數，接口作為參數

 

       public static List<List<StateNode>> depthFirstFilter(StateNode root,interface Filter<StateNode> filter){

 

       LinkedList<LinkedList<StateNode>>  node = new LinkedList<LinkedList<StateNode>>();

        LinkedList<LinkedList<StateNode>>  res = new LinkedList<LinkedList<StateNode>>();

      LinkedList<StateNode> inital = new LinkedList<StateNode>();

       inital.addLast(root);

       node.addLast(inital);

    

       while(!node.isEmpty){

               LinkedList<StateNode> curRevPath = node.removeFirst();

               if(filter.FilterofStatePath(curRevPath )

                        res.addLast(curRevPath);

               if (curRevPath.peekFirst().getSubStateNode() != null){

                       children = curRevPath.peekFirst().getSubStateNode();

            if (children != null)

 for (StateNode childNode : children) {
 LinkedList<StateNode> newPath = (LinkedList<StateNode>)curRevPath.clone();
 newPath.addFirst(childNode);
 q.addLast(newPath);
 }
 }

 

       }

 

        return res;

 

 

}

 

    

 

 

}