全网最全二叉树遍历教程含代码实现_二叉树遍历代码

一、什么是树

树（tree）是一种经常用到的数据结构，用来模拟具有树状结构性质的数据集合。
树是n（n>=0）个结点和n-1条边的有限集。n=0时称为空树。在任意一棵非空树中：

• 有且仅有一个特定的称为根（root）的结点；
• 当n>1时，其余结点可分为m（m>0）个互不相交的有限集，其中每个集合本身又是一棵树，并且称为根的子树（subtree）。

二、什么是二叉树

二叉树（binary tree）是一种更为典型的树状结构。如它名字所描述的那样，二叉树是每个节点最多有两个子树的树结构，通常子树被称作“左子树”和“右子树”。

• 二叉树每个结点最多有两棵子树，没有子树或者有一棵子树都是可以的；
• 左子树和右子树是有顺序的，次序不能任意颠倒；
• 即使树中某个结点只有一棵子树，也要区分它是左子树还是右子树。

如下图就是一棵二叉树。

三、二叉树遍历

二叉树遍历（traversing binary tree）是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。
二叉树的遍历方式可以有很多种，如果限制了从左到右的遍历方式，则主要分为四种：

• 前序遍历
  首先访问根结点，然后遍历左子树，最后遍历右子树。如下图，遍历的顺序为：ABDGHCEIF
  

• 中序遍历
  先遍历左子树，然后访问根结点，最后遍历右子树。对于二叉搜索树，可以通过中序遍历得到一个递增的有序序列。如下图，遍历的顺序为：GDHBAEICF
  

• 后序遍历
  先遍历左子树，然后遍历右子树，最后访问树的根结点。当删除树中的节点时，删除过程将按照后序遍历的顺序进行。也就是说，当删除一个结点时，将首先删除它的左结点和它的右结点，然后再删除结点本身。如下图，遍历的顺序为：GHDBIEFCA
  

• 层序遍历
  从树的第一层，也就是根结点开始，从上而下逐层遍历，在同一层，按从左到右的顺序对结点逐个访问。如下图，遍历的顺序为：ABCDEFGHI
  

四、前序遍历

1、递归版本

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // 二叉树前序遍历递归实现：根结点->左子树->右子树
    vector<int> answer;
    void preorder(TreeNode *root) {
        if(root == nullptr){
            return;
        }
        answer.push_back(root -> val);
        preorder(root -> left);
        preorder(root -> right);
    }
    vector<int> preorderTraversal(TreeNode *root) {
        preorder(root);
        return answer;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

五、中序遍历

1、递归版本

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // 二叉树中序遍历递归实现：左子树->根结点->右子树
    vector<int> answer;
    void inorder(TreeNode* root) {
        if(root == nullptr) {
            return;
        }
        inorder(root -> left);
        answer.push_back(root -> val);
        inorder(root -> right);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        inorder(root);
        return answer;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

六、后序遍历

1、递归版本

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // 二叉树后序遍历递归实现：左子树->右子树->根结点
    vector<int> answer;
    void postorder(TreeNode* root) {
        if(root == nullptr) {
            return;
        }
        postorder(root -> left);
        postorder(root -> right);
        answer.push_back(root -> val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        postorder(root);
        return answer;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

七、层序遍历

1、广度优先搜索

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
	// 层序遍历
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> answer;
        if(root == nullptr) {
            return answer;
        }
        queue<TreeNode*> q;
        q.push(root);

        while(!q.empty()) {
            int size = q.size();
            TreeNode* current;
            vector<int> ans;
            for(int i = 0; i < size; i ++) {
                current = q.front();
                ans.push_back(current -> val);
                q.pop();
                if(current -> left)
                    q.push(current -> left);
                if(current -> right)
                    q.push(current -> right);
            }
            answer.push_back(ans);
        }
        return answer;

    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

后续将更新使用非递归方法实现遍历，请持续关注。