算法训练Day14|二叉树part01(二叉树的理论基础、二叉树的十种遍历方式——递归法，迭代法，统一迭代法、层序遍历)

二叉树理论基础

1.二叉树的种类

• 满二叉树

顾名思义：满，只有度为0和度为2的节点，且度为0的节点在同一层

深度为k的满二叉树有2^k-1个节点。
第h层有2^(h-1)个节点。

• 完全二叉树

除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。

上一篇的优先级队列底层实现就是堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系。

• 二叉搜索树

前面介绍的树，都没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。
若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉排序树

• 平衡二叉搜索树

它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
C++中map、set、multimap，multiset的底层实现都是红黑树，是一种平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn。
而unordered_map、unordered_set底层实现是哈希表。

2.二叉树的存储方式

二叉树可以链式存储，也可以顺序存储。一般都是用链式存储。

• 链式存储

链式存储方式就用指针。

• 顺序存储

顺序存储就是用数组。
如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。

3.二叉树的遍历方式

二叉树主要有两种遍历方式：

1. 深度优先遍历：先往深走，遇到叶子节点再往回走。
2. 广度优先遍历：一层一层的去遍历。
   这两种遍历是图论中最基本的两种遍历方式，。

从深度优先遍历和广度优先遍历进一步拓展，才有如下遍历方式：

1. 深度优先遍历

前序遍历（递归法，迭代法）
中序遍历（递归法，迭代法）
后序遍历（递归法，迭代法）

2. 广度优先遍历

层次遍历（迭代法）

在深度优先遍历中：有三个顺序，前中后序遍历。我之前一直想不明白，现在是记了一个技巧：
📎这里前中后，其实指的就是中间节点的遍历顺序，

• 前序遍历：中左右
• 中序遍历：左中右
• 后序遍历：左右中

之前学栈与队列的时候，就说过栈其实就是递归的一种实现结构，也就说前中后序遍历的逻辑其实都是可以借助栈来实现的。
而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。
这里其实我们又了解了栈与队列的一个应用场景了。

4.二叉树的定义

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

刷LeetCode可能用不到，但面试可能会要求手写代码。

学习时间⌛️：90min

---

二叉树的10种遍历方式

1. 递归遍历

前序、中序、后序，写法比较统一。

递归算法的三个要素：

1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

1. 前序遍历

LeetCode 144.二叉树的前序遍历
题目链接🔥

/**
 * 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:
    //确定递归函数的参数和返回值
    void traversal(TreeNode *cur,vector<int> &vec){
        //确定终止递归的条件
        if(cur==nullptr) return;
        //确定单层递归的条件
        vec.push_back(cur->val);
        traversal(cur->left,vec);
        traversal(cur->right,vec);     
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
};

2. 中序遍历

LeetCode 94.二叉树的中序遍历
题目链接🔥

class Solution {
public:
    void traversal(TreeNode*cur,vector<int> &vec){
        if(cur==nullptr) return;
        traversal(cur->left,vec);
        vec.push_back(cur->val);
        traversal(cur->right,vec);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
};

3.后序遍历

LeetCode 145.二叉树的后序遍历
题目链接🔥

class Solution {
public:
    void traversal(TreeNode* cur,vector<int> &vec){
        if(cur==nullptr) return;
        traversal(cur->left,vec);
        traversal(cur->right,vec);
        vec.push_back(cur->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
};

学习时间⌛️：1h

---

2.迭代遍历

在栈与队列匹配问题中提到了，递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数。
编程语言中是用栈这种数据结构来实现递归的，所以我们用栈，迭代遍历（非递归的方式）也可以是实现二叉树的前后中序遍历了。

1.前序遍历

LeetCode 144.二叉树的前序遍历
题目链接🔥

1. 使用栈来进行处理，首先压入root。
2. 每当栈不为空时，弹出当前元素并放入放入结果集，然后当前元素的右节点和左节点分别入栈。
3. 注意这里，前序遍历顺序应当是【中左右】，为什么要右节点先入栈？因为栈是后进先出的，所以实际取值的时候，才能先取到左节点，然后才是右节点。

📎为了方便理解，举个例子：

压入root：

栈不为空，弹出root放入result，并压入右左节点3和2

栈不为空，弹出top2放入result，并压入右左节点5和4
栈不为空，弹出top4放入result，4右左节点为空

栈不为空，弹出top5放入result，5右左节点为空

栈不为空，弹出top3放入result，并压入3右节点，3左节点为空

栈不为空，弹出top6放入result，6右左节点为空

栈为空，结束循环，返回result。

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        //要考虑空节点情况
        if(root==nullptr) return result;
        st.push(root);
        while(!st.empty()){
            TreeNode * cur=st.top();
            result.push_back(cur->val);
            st.pop();
            if(cur->right!=nullptr) st.push(cur->right);
            if(cur->left!=nullptr) st.push(cur->left);
        }
        return result;
    }
};

2.后序遍历

LeetCode 145.二叉树的后序遍历
题目链接🔥
这里取了一个巧，前序是中左右，调换一下左右节点的入栈顺序，就会变成中右左，再把最后的result反转一下，就可以变成后续的左右中了。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        //要考虑空节点情况
        if(root==nullptr) return result;
        st.push(root);
        while(!st.empty()){
            TreeNode * cur=st.top();
            result.push_back(cur->val);
            st.pop();
            if(cur->left!=nullptr) st.push(cur->left);
            if(cur->right!=nullptr) st.push(cur->right);
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

3.中序遍历

LeetCode 94.二叉树的中序遍历
题目链接🔥
刚刚在迭代的过程中，其实我们有两个操作：

1. 处理：将元素放进result数组中
2. 访问：遍历节点

为什么刚刚写的前序遍历的代码，不能和中序遍历通用呢

因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，因为要访问的元素和要处理的元素顺序是一致的，都是中间节点。

那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。

那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。

cur不为空时，一直压入左节点，cur = cur->left，直到左下子节点，4的左为空，栈不为空

cur=top4，弹出top4并放入result，cur = cur->right，4的右为空

cur=top2，弹出top2并放入result，cur = cur->right，2的右为5，压入5
cur不为空时，一直压入左节点，cur = cur->left，但5的左为空

cur=top5，弹出top5并放入result，cur = cur->right，5的右为空

cur=top1，弹出top1并放入result，cur = cur->right，1的右为3，压入3
cur不为空时，一直压入左节点，cur = cur->left，但3的左为空

cur=top3，弹出top3并放入result，cur = cur->right，3的右为6，压入6
cur不为空时，一直压入左节点，cur = cur->left，但6的左为空

cur=top6，弹出top6并放入result，cur = cur->right，6的右为空，且栈为空，结束

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode *> st;
        TreeNode* cur =root;
        //cur!=nullptr要加，否则st为空，进不去循环
        while(cur!=nullptr||!st.empty()){
            while(cur!=nullptr){
                st.push(cur);
                cur=cur->left;
            }
            if(!st.empty()){
                cur=st.top();
                result.push_back(cur->val);
                st.pop();
                cur=cur->right;
            }
        }
        return result;
    }
};

学习时间⌛️：4.5h

---

3.统一迭代遍历

迭代法实现的先中后序，其实风格也不是那么统一，其实针对三种遍历方式，使用迭代法是可以写出统一风格的代码！
统一写法：
我们以中序遍历为例，使用栈的话，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。
那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。
如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。
只有空节点弹出的时候，才将下一个节点放进结果集。
如果栈顶节点不为None，按照遍历顺序的逆序，依次向栈里加入左中右三个节点，即node.left，node，node.right。加入中节点时后面加一个None。

1.中序遍历

LeetCode 94.二叉树的中序遍历
题目链接🔥
只有空节点弹出的时候，才将下一个节点放进结果集。
如果栈顶节点不为None，按照遍历顺序的逆序，依次向栈里加入右中左三个节点，加入中节点时后面加一个None。
📎
📎为了方便理解，举个例子：

cur=1，不为空，弹出1，加入右3，cur1，null，左2

cur=top2，不为空，弹出2，加入右5，cur2，null，左4

cur=top4，不为空，弹出4，右空跳过，cur4，null，左空跳过

cur是空，弹出null，弹出4并放入result

cur是空，弹出null，弹出2并放入result

cur=top5，不为空，弹出5，右空跳过，cur5，null，左空跳过

cur是空，弹出null，弹出5并放入result

cur是空，弹出null，弹出1并放入result

cur=top3，不为空，弹出3，加入右6，cur5，null，左空跳过

cur是空，弹出null，弹出3并放入result

cur=top6，不为空，弹出6，右空跳过，cur6，null，左空跳过

cur是空，弹出null，弹出6并放入result

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root==nullptr) return result;
        st.push(root);
        TreeNode* cur;
        while(!st.empty()){
            cur=st.top();
            if(cur!=nullptr){
                st.pop();
                if(cur->right) st.push(cur->right);
                st.push(cur);
                st.push(nullptr);
                if(cur->left) st.push(cur->left);
            }
            if(cur==nullptr){
                st.pop();
                result.push_back(st.top()->val);
                st.pop();
            }
        }
        return result;
    }
};

2.前序遍历

LeetCode 144.二叉树的前序遍历
题目链接🔥

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root==nullptr) return result;
        st.push(root);
        TreeNode* cur;
        while(!st.empty()){
            cur=st.top();
            if(cur!=nullptr){
                st.pop();     
                if(cur->right) st.push(cur->right);         
                if(cur->left) st.push(cur->left);
                st.push(cur);
                st.push(nullptr);
            }
            if(cur==nullptr){
                st.pop();
                result.push_back(st.top()->val);
                st.pop();
            }
        }
        return result;
    }
};

3.后序遍历

LeetCode 145.二叉树的后序遍历
题目链接🔥

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root==nullptr) return result;
        st.push(root);
        TreeNode* cur;
        while(!st.empty()){
            cur=st.top();
            if(cur!=nullptr){
                st.pop();
                st.push(cur);
                st.push(nullptr);
                if(cur->right) st.push(cur->right);         
                if(cur->left) st.push(cur->left);
            }
            if(cur==nullptr){
                st.pop();
                result.push_back(st.top()->val);
                st.pop();
            }
        }
        return result;
    }
};

复杂度分析

• 时间复杂度为O(N)

其中N是二叉树的节点数量，因为需要访问每个节点恰好一次。

• 空间复杂度

主要包括递归调用栈的空间和用于存储后序遍历结果的空间。
递归调用栈空间：平均情况下O(logn)，最坏情况二叉树是单链的，递归调用栈的最大深度将达到N（节点数），导致空间复杂度为O(N)。
结果result 向量用于存储后序遍历的结果，其中包含N个元素（所有节点都被访问并添加到向量中），因此空间复杂度为O(N)。

思考

统一风格的迭代法，不用在纠结于前序写出来了，中序写不出来的情况了。但是统一风格的迭代法并不好理解，而且想在面试直接写出来还有难度的。主要是理解这里空指针的作用，根据是不是空指针判断是不是当前正在操作的节点。

学习时间⌛️：1h30min

---

4.层序遍历

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。

需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的广度优先遍历，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

📎学会二叉树的层序遍历，可以一口气打完以下十题：

102.二叉树的层序遍历
107.二叉树的层次遍历II
199.二叉树的右视图
637.二叉树的层平均值
429.N叉树的层序遍历
515.在每个树行中找最大值
116.填充每个节点的下一个右侧节点指针
117.填充每个节点的下一个右侧节点指针II
104.二叉树的最大深度
111.二叉树的最小深度

由于篇幅原因，层序遍历放在下一篇算法训练Day15|二叉树part02(层序遍历)展开。

学习时间⌛️：20min

---