二叉樹遍歷——深度優先遍歷、廣度優先遍歷0000

二叉樹遍歷簡介
【備註】：二叉樹的深度優先遍歷的非遞歸的通用做法是採用棧，廣度優先遍歷的非遞歸的通用做法是採用隊列。

深度優先遍歷：
對每一個可能的分支路徑深入到不能再深入爲止，而且每個結點只能訪問一次。對每一個可能的分支路徑深入到不能再深入爲止，而且每個結點只能訪問一次。
要特別注意的是，二叉樹的深度優先遍歷比較特殊，可以細分爲先序遍歷、中序遍歷、後序遍歷。具體說明如下：

先序遍歷：對任一子樹，先訪問根，然後遍歷其左子樹，最後遍歷其右子樹。
中序遍歷：對任一子樹，先遍歷其左子樹，然後訪問根，最後遍歷其右子樹。
後序遍歷：對任一子樹，先遍歷其左子樹，然後遍歷其右子樹，最後訪問根。

廣度優先遍歷：
又叫層次遍歷，從上往下對每一層依次訪問，在每一層中，從左往右（也可以從右往左）訪問結點，訪問完一層就進入下一層，直到沒有結點可以訪問爲止。又叫層次遍歷，從上往下對每一層依次訪問，在每一層中，從左往右（也可以從右往左）訪問結點，訪問完一層就進入下一層，直到沒有結點可以訪問爲止。

深度優先搜素算法：
不全部保留結點，佔用空間少；有回溯操作(即有入棧、出棧操作)，運行速度慢。
通常深度優先搜索法不全部保留結點，擴展完的結點從數據庫中彈出刪去，這樣，一般在數據庫中存儲的結點數就是深度值，因此它佔用空間較少。所以，當搜索樹的結點較多，用其它方法易產生內存溢出時，深度優先搜索不失爲一種有效的求解方法。

廣度優先搜索算法：
保留全部結點，佔用空間大； 無回溯操作(即無入棧、出棧操作)，運行速度快。
廣度優先搜索算法，一般需存儲產生的所有結點，佔用的存儲空間要比深度優先搜索大得多，因此，程序設計中，必須考慮溢出和節省內存空間的問題。但廣度優先搜索法一般無回溯操作，即入棧和出棧的操作，所以運行速度比深度優先搜索要快些。

案例

先序遍歷（遞歸）：35 20 15 16 29 28 30 40 50 45 55
中序遍歷（遞歸）：15 16 20 28 29 30 35 40 45 50 55
後序遍歷（遞歸）：16 15 28 30 29 20 45 55 50 40 35
先序遍歷（非遞歸）：35 20 15 16 29 28 30 40 50 45 55
中序遍歷（非遞歸）：15 16 20 28 29 30 35 40 45 50 55
後序遍歷（非遞歸）：16 15 28 30 29 20 45 55 50 40 35
廣度優先遍歷：35 20 40 15 29 50 16 28 30 45 55

深度優先遍歷
對每一個可能的分支路徑深入到不能再深入爲止，而且每個節點只能訪問一次。
對於上面的例子來說深度優先遍歷的結果就是：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 class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;
    }
}
public class Solution {
    public ArrayList<Integer> deep(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 node=stack.pop();
　　　　　　//先往棧中壓入右節點，再壓左節點，這樣出棧就是先左節點後右節點了。
            if(node.right!=null)
                stack.push(tree.right);
            if(node.left!=null)
                stack.push(tree.left);
            lists.add(node.val);
        }
        return lists;
    }
}

廣度優先遍歷
其過程檢驗來說是對每一層節點依次訪問，訪問完一層進入下一層，而且每個節點只能訪問一次。對於上面的例子來說，廣度優先遍歷的 結果是：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 class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;
    }
}
public class Solution {
    public ArrayList<Integer> wide(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 node = queue.poll();
            if(node.left!=null){
                queue.offer(node.left);
            }
            if(node.right!=null){
                queue.offer(node.right);
            }
            lists.add(node.val);
        }
        return lists;
    }
}

————————————————
版權聲明：本文爲CSDN博主「霧幻」的原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/lb812913059/article/details/83313360