樹的廣度優先遍歷和深度優先遍歷（遞歸非遞歸、Java實現）

 

在編程生活中，我們總會遇見樹性結構，這幾天剛好需要對樹形結構操作，就記錄下自己的操作方式以及過程。現在假設有一顆這樣樹，（是不是二叉樹都沒關系，原理都是一樣的）

1.廣度優先遍歷

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

先往隊列中插入左節點，再插右節點，這樣出隊就是先左節點后右節點了。

　　廣度優先遍歷樹，需要用到隊列（Queue）來存儲節點對象,隊列的特點就是先進先出。例如，上面這顆樹的訪問如下：

　　首先將A節點插入隊列中，隊列中有元素（A）;

　　將A節點彈出，同時將A節點的左、右節點依次插入隊列，B在隊首，C在隊尾，（B，C），此時得到A節點；

　　繼續彈出隊首元素，即彈出B，並將B的左、右節點插入隊列，C在隊首，E在隊尾（C,D，E），此時得到B節點；

　　繼續彈出，即彈出C，並將C節點的左、中、右節點依次插入隊列，（D,E,F,G,H），此時得到C節點；

　　將D彈出，此時D沒有子節點，隊列中元素為（E,F,G,H），得到D節點；

　　。。。以此類推。。

代碼：這里以二叉樹為例，遍歷所有節點的值

　　

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/

public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> lists=new ArrayList<Integer>();
        if(root==null)
            return lists;
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode tree=queue.poll();
            if(tree.left!=null)
                queue.offer(tree.left);
            if(tree.right!=null)
                queue.offer(tree.right);
            lists.add(tree.val);
        }
        return lists;
    }
}

 

 

2、深度優先

英文縮寫為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）；

...依次往下，最終遍歷完成。

代碼：也是以二叉樹為例。非遞歸

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/

public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> lists=new ArrayList<Integer>();
        if(root==null)
            return lists;
        Stack<TreeNode> stack=new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode tree=stack.pop();
　　　　　　//先往棧中壓入右節點，再壓左節點，這樣出棧就是先左節點后右節點了。
            if(tree.right!=null)
                stack.push(tree.right);
            if(tree.left!=null)
                stack.push(tree.left);
            lists.add(tree.val);
        }
        return lists;
    }
}

 

深度優先的遞歸實現：

 
public void depthOrderTraversalWithRecursive()  
    {  
        depthTraversal(root);  
    }  
      
    private void depthTraversal(TreeNode tn)  
    {  
        if (tn!=null)   
        {  
            System.out.print(tn.value+"  ");  
            depthTraversal(tn.left);  
            depthTraversal(tn.right);  
        }         
    }  

 

 本文大量引用自：http://www.cnblogs.com/toSeeMyDream/p/5816682.html