2. 程式人生 > 其它 >二叉樹之前序遍歷、中序遍歷、後續遍歷

二叉樹之前序遍歷、中序遍歷、後續遍歷

阿新 • • 發佈：2021-02-17

技術標籤：leetcode演算法leetcode樹遍歷

刷leetcode的時候，看到三道題：145. 二叉樹的後序遍歷、94. 二叉樹的中序遍歷、144. 二叉樹的前序遍歷。正好趁著這三道題，回顧一下二叉樹的遍歷演算法。

  • 二叉樹的前序遍歷：先遍歷根，再遍歷左子樹，再遍歷右子樹；
  • 二叉樹的中序遍歷：先遍歷左子樹，再遍歷根，再遍歷右子樹；
  • 二叉樹的後序遍歷：先遍歷左子樹，再遍歷右子樹，再遍歷根；

前中後遍歷是以根的順序區分的。
下面按照leetcode題目要求給出每個遍歷演算法的遞迴和非遞迴程式。
在這三個題目裡面，樹節點都是使用TreeNode表示的，程式碼如下：

public class
 
 TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {}
    TreeNode(int val) {
        this.val = val;
    }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

下面的程式碼假設輸入的為下圖的樹：
在這裡插入圖片描述

144. 二叉樹的前序遍歷


前序遍歷的遞迴程式。

public class PreorderTraversal {
    public static void main(String[] args)throws Exception {
        PreorderTraversal code=new PreorderTraversal();
        TreeNode right=new TreeNode(2,new TreeNode(3),null);
        TreeNode root=new TreeNode(1,null,right);
        System.out.println(
 
code.preorderTraversal(root));
    }
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        traverByRecursion(root,res);
        return res;
    }
    //遞迴遍歷
    private void traverByRecursion(TreeNode root,List<Integer> list) {
        if(root==null){
            return ;
        }
        list.add(root.val);//先遍歷根
        this.traverByRecursion(root.left,list);//遍歷左子樹
        this.traverByRecursion(root.right,list);//遍歷右子樹
    }
}

前序遍歷的非遞迴程式。

public class PreorderTraversal {
    public static void main(String[] args)throws Exception {
        PreorderTraversal code=new PreorderTraversal();
        TreeNode right=new TreeNode(2,new TreeNode(3),null);
        TreeNode root=new TreeNode(1,null,right);
        System.out.println(code.preorderTraversal(root));
    }
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        traverByNotRecursion(root,res);
        return res;
    }
    //非遞迴遍歷
    private void traverByNotRecursion(TreeNode root,List<Integer> list) {
        if(root==null){
            return ;
        }
        //使用stack模擬計算機棧
        List<TreeNode> stack=new ArrayList<>();
        stack.add(root);
        do{
            TreeNode node=stack.remove(stack.size()-1);
            list.add(node.val);//遍歷根
            if(node.right!=null){
                stack.add(node.right);//新增右子樹
            }
            if(node.left!=null){
                stack.add(node.left);//新增左子樹
            }
        }while(stack.size()!=0);
    }
}

94. 二叉樹的中序遍歷
中序遍歷的遞迴程式。

public class InorderTraversal {
    public static void main(String[] args)throws Exception {
        InorderTraversal code=new InorderTraversal();
        TreeNode right=new TreeNode(2,new TreeNode(3),null);
        TreeNode root=new TreeNode(1,null,right);
        System.out.println(code.inorderTraversal(root));
    }
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        traverByRecursion(root,res);
        return res;
    }
    //遞迴遍歷
    private void traverByRecursion(TreeNode root, List<Integer> list) {
        if(root==null) {
            return;
        }
        this.traverByRecursion(root.left,list);//遍歷左子樹
        list.add(root.val);//遍歷根
        this.traverByRecursion(root.right,list);//遍歷右子樹
    }
}

中序遍歷的非遞迴程式。

public class InorderTraversal {
    public static void main(String[] args)throws Exception {
        InorderTraversal code=new InorderTraversal();
        TreeNode right=new TreeNode(2,new TreeNode(3),null);
        TreeNode root=new TreeNode(1,null,right);
        System.out.println(code.inorderTraversal(root));
    }
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        traverByNotRecursion(root,res);
        return res;
    }
    //非遞迴遍歷
    private void traverByNotRecursion(TreeNode root, List<Integer> list) {
        if(root==null){
            return ;
        }
        //使用stack模擬計算機棧
        List<TreeNode> stack=new ArrayList<>();
        while(!stack.isEmpty()||root!=null){
            if(root!=null){
                stack.add(root);
                root=root.left;
            }else{
                root=stack.remove(stack.size()-1);
                list.add(root.val);
                root=root.right;
            }
        }
    }
}

145. 二叉樹的後序遍歷
後序遍歷的遞迴程式。

public class PostorderTraversal {
    public static void main(String[] args)throws Exception {
        PostorderTraversal code=new PostorderTraversal();
        TreeNode right=new TreeNode(2,new TreeNode(3),null);
        TreeNode root=new TreeNode(1,null,right);
        System.out.println(code.postorderTraversal(root));
    }
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        traverByRecursion(root,res);
        return res;
    }
    //遞迴遍歷
    private void traverByRecursion(TreeNode root, List<Integer> list) {
        if(root==null) {
            return;
        }
        this.traverByRecursion(root.left,list);//遍歷左子樹
        this.traverByRecursion(root.right,list);//遍歷右子樹
        list.add(root.val);//遍歷根
    }
}

後序遍歷的非遞迴程式。

public class PostorderTraversal {
    public static void main(String[] args)throws Exception {
        PostorderTraversal code=new PostorderTraversal();
        TreeNode right=new TreeNode(2,new TreeNode(3),null);
        TreeNode root=new TreeNode(1,null,right);
        System.out.println(code.postorderTraversal(root));
    }
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        traverByNotRecursion(root,res);
        return res;
    }
    //非遞迴遍歷
    private void traverByNotRecursion(TreeNode root, List<Integer> list) {
        if(root==null){
            return ;
        }
        //使用stack模擬計算機棧
        List<TreeNode> stack=new ArrayList<>();
        TreeNode lastNode=null;//記錄最後一次訪問的節點
        while(!stack.isEmpty()||root!=null){
            while(root!=null){
                stack.add(root);
                root=root.left;
            }
            root=stack.get(stack.size()-1);//取棧頂元素
            if(root.right==null||root.right==lastNode){
                stack.remove(stack.size()-1);
                list.add(root.val);
                lastNode=root;
                root=null;
            }else{
                root=root.right;
            }
        }
    }
}

相關推薦

二叉樹之前序遍歷、中序遍歷、後續遍歷

技術標籤：leetcode演算法leetcode樹遍歷 刷leetcode的時候，看到三道題：145. 二叉樹的後序遍歷、94. 二叉樹的中序遍歷、144. 二叉樹的前序遍歷。正好趁著這三道題，回顧一下二叉樹的遍歷演算法。

路徑總和、二叉樹的最小深度（力扣第112、111題）

題目： 　　給定一個二叉樹和一個目標和，判斷該樹中是否存在根節點到葉子節點的路徑，這條路徑上所有節點值相加等於目標和。

力扣刷題筆記：101、對稱二叉樹（佇列queue，很容易理解的程式碼、完整題解程式碼及註釋）

技術標籤：刷題筆記leetcodepython 題目： 101、對稱二叉樹 給定一個二叉樹，檢查它是否是映象對稱的。

Java二叉搜尋樹遍歷操作詳解【前序、中序、後序、層次、廣度優先遍歷】

本文例項講述了Java二叉搜尋樹遍歷操作。分享給大家供大家參考，具體如下：

二叉樹前序、中序、後序遍歷（非遞迴統一解法）

前言 昨天和今天覆習了二叉樹的前序遍歷、中序遍歷和後序遍歷，找到了一種統一的非遞迴的方法（即使用一個思路非遞迴實現二叉樹的前序、中序和後序遍歷）。

用遞迴的思想實現二叉樹前、中、後序迭代遍歷

先複習一下前、中、後遍歷的順序： 前序遍歷順序：中-左-右 中序遍歷順序：左-中-右

Python改變一行程式碼實現二叉樹前序、中序、後序的迭代遍歷

Python改變一行程式碼實現二叉樹前序、中序、後序的迭代遍歷 遞迴 今天在做LeetCode的二叉樹前序遍歷題的時候，我看到題目是這樣的：

LeetCode 144 94 590 二叉樹的前序、中序、後序遍歷

1. 總覽 2. 題目 2.1二叉樹的前序遍歷 給定一個二叉樹，返回它的 前序 遍歷。 示例:

二叉樹先序、後序、中序遍歷

一、二叉樹基本知識 二、二叉樹先序遍歷 題目： 輸入一個整數n，表示二叉樹中結點個數，編號為1~n。1號結點為二叉樹的根節點。然後輸入n行，每行包括兩個整數，第i行表示編號為i的結點的左、右子節點的編號。如果某

二叉樹的前、中、後序遞迴和非遞迴遍歷（力扣第144、145、94題）

　　二叉樹的遍歷分為三種，即先序、中序、後序，這裡的先中後都以根節點的訪問順序為基準，根據二叉樹的結構特點，進行這三種遍歷的方式可以採用遞迴的方式，也可以採用非遞迴的方式，採用遞迴的方式時三種遍歷的程

二叉樹的前序、中序、後序遍歷

二叉樹的遍歷 樹的遍歷是樹的一種重要的運算。所謂遍歷是指對樹中所有結點的資訊的訪問，即依次對樹中每個結點訪問一次且僅訪問一次，我們把這種對所有節點的訪問稱為遍歷（traversal）。那麼樹的兩種重要的遍歷模式

前序、中序、後序遍歷二叉樹遞迴與非遞迴實現

前序、中序、後序遞迴 非常簡單，調整訪問根節點的時機即可 void traverse(TreeNode* root){

【演算法】二叉樹、N叉樹先序、中序、後序、BFS、DFS遍歷的遞迴和迭代實現記錄（Java版）

本文總結了刷LeetCode過程中，有關樹的遍歷的相關程式碼實現，包括了二叉樹、N叉樹先序、中序、後序、BFS、DFS遍歷的遞迴和迭代實現。這也是解決樹的遍歷問題的固定套路。

排序二叉樹刪除節點、二叉樹後序、先序非遞迴遍歷

1 #include <bits/stdc++.h> 2 using namespace std; 3 typedef char ElemType; 4 5 typedef struct BiNode{

二叉樹——前序遍歷、中序遍歷、後序遍歷、層序遍歷詳解(遞迴非遞迴)

前言 前面介紹了二叉排序樹的構造和基本方法的實現。但是排序遍歷也是比較重要的一環。所以筆者將前中後序.和層序遍歷梳理一遍。

C語言實現二叉樹的各種遞迴非遞迴遍歷（前序、後序、中序、層級遍歷）

技術標籤：演算法題 二叉樹遍歷 #include <stdio.h> #include <stdlib.h> #define NULL 0

python程式碼實現二叉樹的廣度優先遍歷，前序、中序、後序遍歷

技術標籤：python演算法二叉樹 from collections import deque class BinaryTree: def __init__(self, data=None, left=None, right=None):

C語言使用遞迴以及非遞迴對二叉樹的先、中和後序遍歷以及層次遍歷

技術標籤：資料結構二叉樹資料結構 C語言通過遞迴和非遞迴 對二叉樹的先序、中序、後序以及層次遍歷

迭代法 二叉樹前序、中序、後序 遍歷

前序 class Solution { public: vector<int> preorderTraversal(TreeNode* root) { vector<int> res;

leetcode第144、94、145——二叉樹的前序遍歷、中序遍歷、後序遍歷

技術標籤：資料結構和演算法leetcode二叉樹演算法 1.前序遍歷 給你二叉樹的根節點 root ，返回它節點值的 前序 遍歷。