代码随想录第14天|二叉树理论，递归遍历，迭代遍历，同意迭代

yec10

已于 2023-06-30 16:01:11 修改

阅读量1.1k

点赞数

分类专栏：代码随想录文章标签：数据结构算法

于 2023-06-07 12:46:31 首次发布

本文链接：https://blog.csdn.net/yec10/article/details/131074621

版权

代码随想录专栏收录该内容

52 篇文章 1 订阅

订阅专栏

文章详细介绍了二叉树的各种类型，包括满二叉树、完全二叉树和平衡二叉搜索树（AVL树）。讨论了C++中map和set等数据结构的底层实现，并阐述了二叉树的链式存储和数组存储方式。重点讲解了二叉树的深度优先遍历（前序、中序、后序）和广度优先遍历，以及递归和迭代的实现方法，提供了LeetCode相关问题的解题思路。

摘要由CSDN通过智能技术生成

二叉树理论：

二叉树的种类：

满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 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。

但是用链式表示的二叉树，更有利于我们理解，所以一般我们都是用链式存储二叉树。

二叉树的遍历方式：

深度优先遍历：先往深走，遇到叶子节点再往回走。
广度优先遍历：一层一层的去遍历。

这两种遍历是图论中最基本的两种遍历方式。

深度优先遍历
- 前序遍历（递归法，迭代法）
- 中序遍历（递归法，迭代法）
- 后序遍历（递归法，迭代法）
广度优先遍历
- 层次遍历（迭代法）

递归遍历：

每次写递归，都按照这三要素来写！

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

LeetCode144.二叉树的前序遍历

题目链接：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 Tree(TreeNode* cur,vector<int>& vec) {
        if(cur == NULL) return;
        vec.push_back(cur->val);
        Tree(cur->left,vec);
        Tree(cur->right,vec);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> vec;
        Tree(root,vec);
        return vec;
    }
};

迭代：

前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子。前序要访问的元素和要处理的元素顺序是一致的，都是中间节点。

/**
 * 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) {
        stack<TreeNode*> st;
        vector<int> result;
        if(root == NULL) return result;
        st.push(root);
        while(!st.empty()) {
            TreeNode* node = st.top();//中间节点
            st.pop();
            result.push_back(node->val);
            if(node->right) st.push(node->right);//右节点（栈出栈顺序相反）
            if(node->left) st.push(node->left);//左节点
        }
        return result;
    }
};

LeetCode 94.二叉树的中序遍历

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

思路：

递归：

/**
 * 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 Tree(TreeNode* cur,vector<int>& vec) {
        if(cur == NULL) return;
        Tree(cur->left,vec);
        vec.push_back(cur->val);
        Tree(cur->right,vec);
    }

    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> vec;
        Tree(root,vec);
        return vec;
    }
};

迭代：

中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进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) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        TreeNode* cur = root;
        while(cur != NULL || !st.empty()) {
            if(cur != NULL) {
                st.push(cur);//将访问到的节点放入栈
                cur = cur->left;//一直访问到最底层的左节点
            }
            else {
                cur = st.top();//如果没找到左边的就代表中序遍历已到左边最底层，使得cur等于最后入栈的节点
                st.pop()//弹出
                result.push_back(cur->val);//中
                cur = cur->right;//按中序遍历最后右
            }
        }
        return result;
    }
};

LeetCode145.二叉树的后序遍历

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

思路：

递归：

/**
 * 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 Tree(TreeNode* cur,vector<int>& vec) {
        if(cur == NULL) return;
        Tree(cur->left,vec);
        Tree(cur->right,vec);
        vec.push_back(cur->val);
    }

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> vec;
        Tree(root,vec);
        return vec;
    }
};

迭代：

/**
 * 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) {
        stack<TreeNode*> st;
        vector<int> result;
        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;
    }
};

二叉树的统一迭代法

以中序遍历为例，在上面提到说使用栈的话，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。

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

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

前序，后序，中序将访问左右节点顺序换掉即可

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