【二叉树1】二叉树的递归遍历，迭代遍历，统一迭代遍历

最新推荐文章于 2024-05-13 16:13:43 发布

H1kemo

最新推荐文章于 2024-05-13 16:13:43 发布

阅读量1k

点赞数 27

分类专栏： leetcode刷题 # 二叉树文章标签：数据结构 leetcode c++ 算法

本文链接：https://blog.csdn.net/jimaplle/article/details/136804868

版权

leetcode刷题同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

二叉树

3 篇文章 0 订阅

订阅专栏

二叉树基础知识

二叉树的种类

满二叉树

如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。
深度为k，节点个数为2^k-1

完全二叉树

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含 1~ 2^(h-1) 个节点。
在这里插入图片描述
之前我们刚刚讲过优先级队列其实是一个堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系。

二叉搜索树

前面介绍的树，都没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。

若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉排序树
下面这两棵树都是搜索树：
在这里插入图片描述

平衡二叉搜索树

又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
在这里插入图片描述
C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn，unordered_map、unordered_set，unordered_map、unordered_set底层实现是哈希表。

二叉树的存储方式

二叉树可以链式存储，也可以顺序存储。

那么链式存储方式就用指针，顺序存储的方式就是用数组。

顾名思义就是顺序存储的元素在内存是连续分布的，而链式存储则是通过指针把分布在各个地址的节点串联一起。
在这里插入图片描述
顺序存储的方式：

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

二叉树的定义

 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) {} 
 };

二叉树的遍历方式

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

深度优先遍历：先往深走，遇到叶子节点再往回走。（栈实现）

前序遍历（递归法，迭代法）
中序遍历（递归法，迭代法）
后序遍历（递归法，迭代法）
广度优先遍历：一层一层的去遍历。
层次遍历（迭代法）（队列实现）
这里前中后，其实指的就是中间节点的遍历顺序，
看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式

前序遍历：中左右
中序遍历：左中右
后序遍历：左右中
在这里插入图片描述

递归遍历

文字讲解：https://programmercarl.com/二叉树的递归遍历.html#思路
写递归函数三部曲
1.确定参数和返回类型
我们只是想要遍历每个节点的值，所以返回值是void，参数是当前节点，以及记录每个节点值的向量result
2.确定终止条件
当遍历到空节点的时候，就要返回了（也就是叶子结点的下一层）
3.确定单层递归逻辑
前序遍历是中左右所以先把中间节点的val放进vector里面，然后依次遍历左节点和右节点
中序遍历、后序遍历不过是调换一下遍历顺序（代码顺序）

二叉树的前序遍历

题目链接：https://leetcode.cn/problems/binary-tree-preorder-traversal/description/

/**
 * 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) {}
 * };
 */
//  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 travelsal(TreeNode *cur, vector<int>& res){
        if(cur == nullptr) return;
        res.push_back(cur->val);
        travelsal(cur->left, res);
        travelsal(cur->right, res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        travelsal(root, res);
        return res;
    }
};

二叉树的中序遍历

https://leetcode.cn/problems/binary-tree-inorder-traversal/description/

/**
 * 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) {}
 * };
 */
//  struct TreeNode {
//     int val;
//     TreeNode *left;
//     TreeNode *right;
//     TreeNode(): val(), 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 travelsal(TreeNode* cur, vector<int>& res){
        if(cur == nullptr) return;
        travelsal(cur->left, res);
        res.push_back(cur->val);
        travelsal(cur->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        travelsal(root, res);
        return res;
    }
};

145.二叉树的后序遍历

https://leetcode.cn/problems/binary-tree-postorder-traversal/

/**
 * 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) {}
 * };
 */
// 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 travelsal(TreeNode* cur, vector<int>& res){
        if(cur == nullptr) return;
        travelsal(cur->left, res);
        travelsal(cur->right, res);
        res.push_back(cur->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        travelsal(root, res);
        return res;
    }
};

二叉树的迭代遍历

二叉树的前序遍历

算法

访问某个节点，和处理某个节点是不同的。
访问某个节点代表记录它的值，处理某个节点则是你决定怎么处理它的左右子树。
无论是什么遍历，比如前序遍历，对每一个节点，都要做这两个操作，即：访问某个节点，和处理某个节点。
前序遍历的顺序是中左右，对于每个节点，首先访问它，记录它的值到result中，然后处理它的左右子树，对于前序遍历，应该先把右子树压入栈，然后再把左子树压入栈。
因为栈是先进后出的，所以想要先访问左子树，要后压入栈才行。
可以看到，在前序遍历中，访问某个节点和处理某个节点是同时进行的。

代码

/**
 * 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) {}
 * };
 */
// 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> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == nullptr) return result;
        st.push(root);
        while(!st.empty()){
            TreeNode *tmp = st.top();
            result.push_back(tmp->val);
            st.pop();
            if(tmp->right) st.push(tmp->right);
            if(tmp->left) st.push(tmp->left);
        }
        return result;
    }
};

二叉树的后序遍历

算法

后续遍历的顺序是左右中。后续遍历其实就已经不是访问和处理节点同时进行了。假设只是想先把前序的代码顺序变一下，那肯定是不行的，因为就算先执行右左节点入栈的操作，在处理当前节点的时候（中节点），你是已经先访问过了（res记录了当前节点的值），这个顺序就不对了，中节点在最后才对。
所以得另想办法。前序的顺序是中左右，如果调整代码顺序可以得到中右左，然后翻转一下result，就可以得到左右中，恰好就是后序遍历的顺序。
在这里插入图片描述

代码

/**
 * 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) {}
 * };
 */
// 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> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root == NULL) return result;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            result.push_back(node->val);
            if (node->left) st.push(node->left);
            if (node->right) st.push(node->right);
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

二叉树的中序遍历

算法

中序遍历其实也和后序遍历一样，访问和处理是不同步的，左中右，而且我们都没办法通过变换顺序和反转得到这样的遍历顺序。所以得另想办法。
为了分开访问和处理，我们需要引入一个指针变量指向当前访问的节点，cur，然后需要一个栈st去存储已经访问但是还没有处理的节点。
1.开始遍历，一直往左子树走，并且把沿途的所有非空节点压入栈等待处理
2.一旦发现cur指向null，说明左子树这里到头了，左这里我们遍历完了，开始处理中节点，这里的中节点就是我们现在的栈顶元素。
3.pop出栈顶元素，记录他的值，开始处理右节点。
4.右节点也是重复上面的流程，先探索左边，处理到底部，再处理中间，最后右边。

总而言之，就是，cur非空，说明左边还有路走，没到底，那就一直到底，压栈；cur空了，说明到底了，弹栈处理最近的中节点，然后走右边。

代码

/**
 * 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) {}
 * };
 */
// 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> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode *cur = root;
        while(cur != nullptr || !st.empty()){
            if(cur != nullptr){
                st.push(cur);
                cur = cur->left;
            }else{
                cur = st.top();
                st.pop();
                result.push_back(cur->val);
                cur = cur->right;
            }
        }
        return result;
    }
};

二叉树的统一迭代遍历

上面讲到，后序遍历和中序遍历为什么不能和前序遍历一样写，就是因为前序遍历是访问和处理同时进行，而后序和中序都是不同步的。那么怎么样才能够把这三个遍历统一起来呢？
那就让三种遍历方法的访问和处理都不同步，其实最难的就是当前节点的问题，因为当前节点要么立马读取值（前序遍历），要么压入栈中等待一个契机再读区（中序遍历，等到一直向左到底才开始处理中节点）。我们当然是选择都压入栈，然后再读取。但是之前的中序遍历，因为顺序是左中右，所以可以以到达左叶子结点为标志，那么有什么办法能让三个遍历方法都作为标志呢？
那就是给本来要访问，但是没有读取值的节点后，加一个标志，代表这个节点已经访问过，但是没有读值，为了保持遍历顺序先处理了它。
所以就产生了下面的写法：
1.开始从root遍历。检查栈顶元素，但是不读值，按照遍历顺序，将自己，左右孩子都压入栈，自己的后面加一个NULL标志。
2.每次都读取栈顶的节点，如果非空就重复上面的操作，如果空那就说明这个节点的左右子树都处理了，轮到这个节点读值了，那么读取它到result数组。

中序遍历

/**
 * 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) {}
 * };
 */
// 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> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while(!st.empty()){
            TreeNode *node = st.top();
            if(node!=NULL){
                st.pop();
                if(node->right) st.push(node->right);
                st.push(node);
                st.push(NULL);
                if(node->left) st.push(node->left);
            }else{
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

前序遍历

/**
 * 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) {}
 * };
 */
// 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> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if(root == NULL) return result;
        st.push(root);
        while(!st.empty()){
            TreeNode *node = st.top();
            if(node != NULL){
                st.pop();
                if(node->right) st.push(node->right);
                if(node->left) st.push(node->left);
                st.push(node);
                st.push(NULL);
            }else{
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

后序遍历

/**
 * 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) {}
 * };
 */
// 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> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root == NULL) return result;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            if(node != NULL){
                st.push(NULL);
                if(node->right) st.push(node->right);
                if(node->left) st.push(node->left);
            }else{
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};