代码随想录算法训练营第十四天| 二叉树的理论基础、递归遍历、迭代遍历、统一迭代

最新推荐文章于 2024-10-15 19:28:18 发布

CAriaTLOVER

最新推荐文章于 2024-10-15 19:28:18 发布

阅读量46

点赞数

文章标签：算法数据结构

本文链接：https://blog.csdn.net/m0_63521007/article/details/133032427

版权

二叉树理论基础

视频讲解：关于二叉树，你该了解这些！| 二叉树理论基础一网打尽，二叉树的种类、二叉树的存储方式、二叉树节点定义、二叉树的遍历顺序_哔哩哔哩_bilibili

二叉树的种类

满二叉树

这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。

完全二叉树

完全二叉树的底部一定是连续的

满二叉树一定是完全二叉树

二叉搜索树

二叉搜索树是一个有序树。

若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉排序树

下面这两棵树都是搜索树

平衡二叉搜索树

平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

如图：

最后一棵不是平衡二叉树，因为它的左右两个子树的高度差的绝对值超过了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(int x) : val(x), left(NULL), right(NULL) {}
};

二叉树的递归遍历

视频讲解：每次写递归都要靠直觉？这次带你学透二叉树的递归遍历！| LeetCode：144.前序遍历，145.后序遍历，94.中序遍历_哔哩哔哩_bilibili

文章讲解：代码随想录

递归算法的三个要素：

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

前序遍历

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

**
 * 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){  // 因为要打印出前序遍历节点的数值，所以参数里需要传入vector来放节点的数值
        if(cur==NULL){
            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;
    }
};

中序遍历

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

/**
 * 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==NULL){
            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;
    }
};

后序遍历

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

/**
 * 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==NULL){
            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;
    }
};

二叉树的迭代遍历

用栈模拟

前序遍历

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

/**
 * 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> function(TreeNode* root){
        stack<TreeNode*> st;  // 注意这里栈的类型是树节点
        vector<int> vec;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();  // 同理取出栈顶的树节点
            st.pop();
            if(node!=NULL){
                vec.push_back(node->val);  // 把节点值放入数组
            }
            else{
                continue;
            }
            // 先将右孩子入栈，再将左孩子入栈，这样出栈时才是先左后右
            st.push(node->right);
            st.push(node->left);
        }
        return vec;
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        result = function(root);
        return result;
    }
};

后序遍历

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

只需要把前序遍历进行一点修改：

前序：中->左->右改成中->右->左，然后调用reverse函数处理数组就实现了后序遍历

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

中序遍历

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

对节点的访问与处理顺序不同

一直访问左节点，直到当前节点的左子树为空，对该节点进行处理，把该节点弹出
接着访问1的右节点，还是空，那么弹出栈里访问过的元素，弹出4
接着访问4的右孩子，把2压入栈，然后继续访问2的左节点，为空，把2弹出，访问2的右节点，为空，弹出5
……

总结：访问左节点压入栈，左节点为空时对当前节点进行处理，先弹出，然后访问右节点压入栈；当右节点为空时，弹出栈里访问过的元素；总之是先左后右，左节点为空才访问右节点。

/**
 * 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> function(TreeNode* root){
        vector<int> vec;
        stack<TreeNode*> st;
        // 定义一个指针遍历二叉树
        TreeNode* cur = root;
        while(cur!=NULL || !st.empty()){
            if(cur!=NULL){
                st.push(cur);  // 栈用来记录指针访问过的元素
                cur = cur->left;
            }
            else{
                cur = st.top();
                st.pop();
                vec.push_back(cur->val);
                cur = cur->right;
            }
        }
        return vec;
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        result = function(root);
        return result;
    }
};

二叉树的统一迭代法

文章讲解：代码随想录

像之前的中序遍历迭代法中，使用栈的话，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。

那么就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。

如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。

中序遍历

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

将访问的节点直接加入到栈中，但如果是处理的节点则后面放入一个空节点，这样只有空节点弹出的时候，才将下一个节点放进结果集。

/**
 * 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> 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;
    }
};

前序遍历

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

/**
 * 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> preorderTraversal(TreeNode* root) {
        // 前序是中左右，入栈顺序是右左中
        vector<int> result;
        stack<TreeNode*> st;
        if(root!=NULL) st.push(root);  // 注意要加入判断根节点不为空时压入栈 
        TreeNode* cur;
        while(!st.empty()){
            cur = st.top();
            if(cur!=NULL){
                st.pop(); // 先把当前结点弹出，避免重复
                if(cur->right!=NULL) st.push(cur->right);
                if(cur->left!=NULL) st.push(cur->left);
                st.push(cur);
                st.push(NULL);
            }
            else{
                st.pop();  // 先把空结点弹出
                cur = st.top();
                result.push_back(cur->val);
                st.pop();
            }
        }
        return result;
    }
};

后序遍历

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

/**
 * 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> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur;
        if(root!=NULL) st.push(root);
        while(!st.empty()){
            cur = st.top();
            if(cur!=NULL){
                st.pop();
                // 后序遍历是左右中，入栈顺序是中右左
                st.push(cur);
                st.push(NULL);
                if(cur->right!=NULL) st.push(cur->right);
                if(cur->left!=NULL) st.push(cur->left);
            }
            else{
                st.pop();
                cur = st.top();
                result.push_back(cur->val);
                st.pop();
            }
        }
        return result;
    }
};