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

李某今天洗头了吗

已于 2024-03-20 16:31:16 修改

阅读量980

点赞数 12

分类专栏：代码随想录训练营文章标签：算法数据结构 c++ leetcode

于 2024-03-20 16:02:45 首次发布

本文链接：https://blog.csdn.net/qq_64336203/article/details/136840191

版权

代码随想录训练营专栏收录该内容

47 篇文章 0 订阅

订阅专栏

本文详细介绍了二叉树的基础概念，包括定义、种类（满二叉树和完全二叉树）、二叉搜索树和平衡二叉搜索树的特点，以及深度优先遍历（前序、中序、后序）和广度优先遍历的实现。同时，还展示了如何通过递归和迭代方法进行二叉树的遍历。

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

一、理论基础

文章讲解：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

事先声明：这里介绍的二叉树基本都是解题用到的二叉树，并没有包含二叉树的所有知识。

1、二叉树的定义

二叉树是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。

2、二叉树的种类

解题过程中遇到的二叉树主要有两种，一种是完全二叉树，另一种是满二叉树。

（1）满二叉树

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

（2）完全二叉树

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含 1~ 2^(h-1) 个节点。一个小例子：

注意最后一个树根节点的右子树的倒数第二层的左节点没有左子树，而有右子树，因此不满足“最后一层的节点都集中在该层最左边的若干位置”，故不是完全二叉树。

上一道题学习的优先队列实则就是一棵完全二叉树。

3、二叉搜索树

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

（1）若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

（2）若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值

（3）它的左、右子树也分别为二叉排序树。

如图：

2. 平衡二叉搜索树

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

如图，最右边的一棵树不是平衡二叉搜索树，因为根节点的左子树和右子树高度之差大于1了。

平衡二叉搜索树的时间复杂度是O(logn)。

（注：map、set、multimap，multiset的底层结构都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn，unordered_map、unordered_set，unordered_map、unordered_set底层实现是哈希表。）

4、二叉树的存储方式

二叉树有两种存储方式：链式和顺序，对应链表和数组。

（1）链式：

比一般的链表多了一个指针，因此一个节点可以指向两个子节点。遍历已经按照链表的遍历方式即可。

（2）顺序存储：

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

推导过程如下：

5、二叉树的遍历方式

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

（1）深度优先遍历：先从根节点一直往下遍历（纵向），直到遇到叶子节点才往回走。

（2）广度优先遍历：一层一层去遍历（横向）。

因此，进一步拓展得到以下遍历方式：

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

怎么区分是前序遍历、中序遍历和后序遍历呢？其实遍历顺序的命名依据的是中间节点的遍历顺序（为什么呢？因为遍历路径上存的值都是中间节点的值，做了下面的题就理解了）：

前序遍历：中左右。

中序遍历：左中右。

后序遍历：左右中。

例：

深度优先一般是用递归实现的，广度优先一般是用队列实现的（先进先出的特性决定的）。

6、二叉树的定义【代码】

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

7、二叉树相关题目的类别

二、递归遍历

题目链接/文章讲解/视频讲解：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E9%80%92%E5%BD%92%E9%81%8D%E5%8E%86.html

解决：已解决

1.思路

递归很容易混淆，重点是掌握三个关键地方：

（1）确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

（2）确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

（3）确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

以前序遍历为例：

（1）确定递归函数的参数和返回值：因为要打印前序遍历途中节点的数值，因此需要在参数里面存放一个保存结果的容器的引用，这样就不需要再有返回值了，因此递归函数返回值为void。

void traversal(TreeNode* cur, vector<int>& vec)

（2）确定终止条件：如果能够确定递归结束了呢，当然是遍历的节点没有子节点了，即遍历完叶子节点，此时就需要回退了。

if (cur == NULL) return;

（3）确定单层递归的逻辑：前序遍历是中左右的顺序，也就是先保存中间节点的数值，然后再遍历左子树，最后遍历右子树。

vec.push_back(cur->val);//取中间节点数值
traversal(cur->left,vec);//遍历左子树
traversal(cur->right,vec);//遍历右子树

2.代码实现

（1）前序遍历

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

（2）中序遍历


class Solution {
public:
    void traversal(TreeNode* cur,vector<int>& result){
        if(cur == nullptr) return;
        traversal(cur->left,result);//先遍历左子树
        result.push_back(cur->val);//再存中间节点的值
        traversal(cur->right,result);//再遍历右子树
    } 
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
};

（3）后序遍历

class Solution {
public:
    void traversal(TreeNode* cur,vector<int>& result){
        if(cur == nullptr) return;
        traversal(cur->left,result);//先遍历左子树
        traversal(cur->right,result);//再遍历右子树
        result.push_back(cur->val);//再存中间结点的值
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
};

三、迭代遍历

题目链接/文章讲解/视频讲解：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E8%BF%AD%E4%BB%A3%E9%81%8D%E5%8E%86.html

解决：已解决

我们知道，一般递归都是用一个工作栈来实现的，因此上面用递归实现的遍历，也可以用栈来完成。介绍之前，先明确两个概念：

处理节点：将节点值放到result数组中。

访问节点：遍历节点。

1.前序遍历

（1）思路

前序遍历的顺序是中左右，也就是先处理了中间节点，然后再去遍历左子树和右子树。但是，栈的入栈顺序和出栈顺序是相反的，而决定处理顺序的是出栈顺序，比如我们按中左右的顺序将数据压栈，实则出栈保存节点值的顺序就是中右左了（为什么中间节点的顺序不变？因为一开始就处理了中间结点，而子节点是确认了从右往左入栈完从下一层循环再处理的），这也意味着我们实则要先把右子树入栈再入左子树，这样就可以在下一层循环弹出左子树的根节点然后继续将它的右子树和左子树弹入遍历下去了。

（2）代码实现

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

2. 后序遍历

（1）思路

后序遍历的顺序是左右中，前序遍历的顺序是中左右，那么将后序遍历反过来就是中右左，这个结果跟中序遍历就很像，只需要交换一下左子树和右子树的入栈顺序即可。

（2）代码实现

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

3.中序遍历

（1）思路

分析一下为什么刚刚写的前序遍历的代码，不能和中序遍历通用呢，因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，因为要访问的元素和要处理的元素顺序是一致的，都是中间节点。那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。

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

（2）代码实现

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode * cur = root;
        while(cur != NULL || !st.empty()){
            if(cur == NULL){
                cur = st.top();
                st.pop();
                result.push_back(cur->val);//中间节点值
                cur = cur->right;

            }else{
                st.push(cur);
                cur = cur->left;
            }
        }
        return result;
    }
};