Bootstrap

Studying-代码随想录训练营day13| 二叉树理论基础、二叉树递归遍历、二叉树迭代遍历、二叉树层序遍历

第十三天，💪(ง •_•)ง💪，编程语言：C++

目录

二叉树理论基础

二叉树的种类：

二叉树的存储方式

二叉树的遍历方式 

二叉树的定义：

二叉树递归遍历

二叉树的迭代遍历 

二叉树的层次遍历

102.二叉树的层序遍历

层次遍历相关的力扣题 

107.二叉树的层次遍历 II

199.二叉树的右视图

637.二叉树的层平均值

429.N叉树的层序遍历 

515.在每个树行中找最大值

116.填充每个节点的下一个右侧节点指针

117.填充每个节点的下一个右侧节点指针II

104.二叉树的最大深度

111.二叉树的最小深度

总结 

二叉树理论基础

文档讲解：代码随想录二叉树理论基础

二叉树的种类：

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

2.完全二叉树： 完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。

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

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

注意：在c++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn。

二叉树的存储方式

二叉树可以链式存储（指针），也可以顺序存储（数组）。

1.链式存储：通过指针把分布在各个地址的节点串联。

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

二叉树的遍历方式 

二叉树的遍历方式分为：1.深度优先遍历：先往深走，遇到叶子节点再往回走；2.广度优先遍历：一层一层的去遍历。

1.深度优先遍历：前序遍历、中序遍历、后序遍历。

前序遍历：中左右；中序遍历：左中右；后续遍历：左右中

注：深度优先遍历代码实现一般会使用递归法来实现 前中后序遍历，同时栈其实也是递归的一种实现结构，因此前中后序遍历的逻辑其实也可以借助栈使用递归的方式来实现。

2.广度优先遍历：层次遍历。

注：广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。

这也是栈与队列的一个应用场景。

二叉树的定义：

二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，定义一个数组。

链式存储定义：

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

二叉树的定义和链表是差不多的，相对于链表 ，二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。

二叉树递归遍历

文档讲解：代码随想录二叉树递归遍历

视频讲解：手撕二叉树递归遍历

力扣题目：前序遍历、后续遍历、中序遍历

学习：

1.递归三要素：确定递归函数的参数和返回值；确定终止条件；确定单层递归的逻辑：

  • 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，明确每次递归的返回值是什么，进而确定递归函数的返回类型。

  • 确定终止条件： 明确终止条件，避免出现栈溢出的错误。操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

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

以前序遍历为例：

确定递归函数的参数和返回值：因为要打印出前序遍历节点的数值，所以参数里需要传入vector来放节点的数值，除了这一点就不需要再处理什么数据了也不需要有返回值，所以递归函数返回类型就是void。

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

确定终止条件：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要结束了，所以如果当前遍历的这个节点是空，就直接return。

if (cur == NULL) return;

确定单层递归的逻辑：前序遍历是中左右的顺序，所以在单层递归的逻辑，是要先取中节点的数值。

vec.push_back(cur->val);    // 中
traversal(cur->left, vec);  // 左
traversal(cur->right, vec); // 右

前序遍历（递归）：

//时间复杂度O(n)
//空间复杂度O(n) 递归过程中栈的开销
/**
 * 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 pretraversal(TreeNode* cur, vector<int>& res) {
        if (cur == nullptr) return;
        res.push_back(cur->val);
        pretraversal(cur->left, res); 
        pretraversal(cur->right, res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        pretraversal(root, result);
        return result;
    }
};

后序遍历（递归）：

//时间复杂度O(n)
//空间复杂度O(n) 递归过程中栈的开销
/**
 * 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 posttraversal(TreeNode* cur, vector<int>& res) {
        //后序遍历，左右中（左右根）
        if(cur == nullptr) return;
        posttraversal(cur->left, res);
        posttraversal(cur->right, res);
        res.push_back(cur->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        posttraversal(root, result);
        return result;
    }
};

中序遍历（递归）：

//时间复杂度O(n)
//空间复杂度O(n) 递归过程中栈的开销
/**
 * 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 intraversal(TreeNode* cur, vector<int>& res) {
        //中序遍历，左中右（左根右）
        if (cur == nullptr) return;
        intraversal(cur->left, res);
        res.push_back(cur->val);
        intraversal(cur->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        intraversal(root, result);
        return result;
    }
};

二叉树的迭代遍历 

文档讲解：代码随想录迭代遍历

视频讲解：手撕迭代遍历（前序、后序）、手撕迭代遍历（中序）

迭代遍历：不使用递归的方式，而是使用栈结构更加直观的表现遍历过程。

实现原理：递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，这就是递归为什么可以返回上一层位置的原因。

前序遍历（迭代法）：前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子。

注意：此处先加入右孩子，再假如左孩子的原因是因为，栈是先进后出的结构，左节点后进栈才会被先处理。

//时间复杂度O(n)
//空间复杂度O(n)，迭代过程中显式栈的开销，平均情况下为O(log⁡n)，最坏情况下树呈现链状，为O(n)。
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        //判断根节点是否为空，初始化栈
        if(root != nullptr) 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;
    }
};

后序遍历（迭代法）： 先序遍历是中左右，后序遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了。

 

//时间复杂度、空间复杂度同上
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;
    }
};

中序遍历（迭代法）：中序遍历存在不同之处，中序遍历需要一直遍历到左下角才开始处理元素，元素的遍历过程和处理过程存在分离。 

方法：将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。标记的方法为在处理的节点放入栈之后，紧接着放入一个空指针，以此作为标记。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        //用以指示当前需要处理的节点
        TreeNode* cur;

        if(root != nullptr) st.push(root);
        while(!st.empty()) {
            cur = st.top();
            //当前节点不为空时，意味着还需要搜寻左节点是否存在
            if(cur != nullptr) {
                st.pop();
                if(cur->right) st.push(cur->right);//空节点不入栈

                //加入一个nullptr指针，在返回到左中右的“中”节点时进行处理
                st.push(cur);
                st.push(nullptr);

                if(cur->left) st.push(cur->left);//空节点不入栈
            }
            //当遇到nullptr节点时，意味着可以处理当前节点了
            else {
                st.pop();
                result.push_back(st.top()->val);
                st.pop();
            }
        }
        return result;
    }
};

此方法也可以用于前序遍历和后序遍历之中。

二叉树的层次遍历

文档讲解：代码随想录层次遍历

视频讲解：手撕层次遍历

102.二叉树的层序遍历

学习：层序遍历一个二叉树，就是从左到右一层一层的去遍历二叉树。此时需要借助一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

代码：

//时间复杂度O(n)
//空间复杂度O(n)
/**
 * 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<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> result;
        //判断根节点是否为空，初始化队列
        if (root != nullptr) que.push(root);
        while(!que.empty()) {
            int size = que.size(); //确定每一层个数
            vector<int> vec; //初始化每一层数组
            while (size--) {
                TreeNode* node = que.front(); //将该层节点取出
                vec.push_back(node->val);
                que.pop();
                //将下一层节点导入，由于size是每一层的个数，所以不存在跨层导出的情况
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

层次遍历相关的力扣题 

107.二叉树的层次遍历 II

题目：自底向上得到的结果就是自上向下的反转

代码：

/**
 * 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<vector<int>> levelOrderBottom(TreeNode* root) {
        //自底向上得到的结果就是自上向下的反转
        queue<TreeNode*> que;
        vector<vector<int>> result;
        //判断根节点是否为空，初始化队列
        if (root != nullptr) que.push(root);
        while(!que.empty()) {
            int size = que.size(); //确定每一层个数
            vector<int> vec; //初始化每一层数组
            while (size--) {
                TreeNode* node = que.front(); //将该层节点取出
                vec.push_back(node->val);
                que.pop();
                //将下一层节点导入，由于size是每一层的个数，所以不存在跨层导出的情况
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);
        }

        reverse(result.begin(), result.end());
        return result;
    }
};

199.二叉树的右视图

题目：右视图对每一层的操作，查询每一层最右边的节点（最后一个节点）

代码：

/**
 * 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> rightSideView(TreeNode* root) {
        //右视图对每一层的操作：看到每一层最右边的节点（最后一个节点）
        queue<TreeNode*> que;
        vector<int> result;
        if (root != nullptr) que.push(root);
        while(!que.empty()) {
            int size = que.size(); 
            for(int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                //遍历到最右边的节点时导入数据
                if(i == size-1) result.push_back(node->val);
                //将下一层节点导入
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return result;
    }
};

637.二叉树的层平均值

题目：求平均值对每一层的操作：求和算平均。

代码：

/**
 * 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<double> averageOfLevels(TreeNode* root) {
        //求平均值对每一层的操作：求和算平均
        queue<TreeNode*> que;
        vector<double> result;
        if (root != nullptr) que.push(root);
        while(!que.empty()) {
            int size = que.size(); 
            double sum = 0;
            for(int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                //将下一层节点导入
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(sum/size);
        }
        return result;
    }
};

429.N叉树的层序遍历 

题目：N叉树层序遍历的不同在于，不再只是遍历左右根节点，而是要遍历该节点的所有子节点。

代码：

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        //N叉树层序遍历的不同在于，不再只是遍历左右根节点，而是要遍历该节点的所有子节点
        queue<Node*> que;
        vector<vector<int>> result;
        if (root != nullptr) que.push(root);
        while(!que.empty()) {
            int size = que.size(); 
            vector<int> vec;
            for(int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                //将下一层节点导入
                for(auto it = node->children.begin(); it != node->children.end(); it++) {
                    if(*it) que.push(*it);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

515.在每个树行中找最大值

题目：遍历每一层节点，找到最大值

代码：

/**
 * 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> largestValues(TreeNode* root) {
        //遍历每一层节点，找到最大值
        //层序遍历使用队列查找每一层节点
        queue<TreeNode*> que;
        vector<int> result;
        if(root != nullptr) que.push(root); 
        while(!que.empty()) {
            int size = que.size();
            int MAX =   INT_MIN; //int类型里面的最小值
            while (size--) {  //等于for(int i = 0; i < que.size(); i++)
                TreeNode* node = que.front();
                que.pop();
                MAX = max(MAX, node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);                
            }
            result.push_back(MAX);
        }
        return result;
    }
};

116.填充每个节点的下一个右侧节点指针

题目：遍历每一层节点，前面的节点都指向下一个节点，最后的节点指向nullptr

代码：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;
    Node() : val(0), left(NULL), right(NULL), next(NULL) {}
    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/
class Solution {
public:
    Node* connect(Node* root) {
        //遍历每一层节点，前面的节点都指向下一个节点，最后的节点指向nullptr
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for(int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                //遍历到最后一个节点的时候单独处理
                if (i == size-1) {
                    node->next = nullptr;
                }
                else {
                    node->next = que.front();
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }        
        return root;
    }
};

117.填充每个节点的下一个右侧节点指针II

题目：遍历每一层节点，前面的节点都指向下一个节点，最后的节点指向nullptr

代码： 

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;
    Node() : val(0), left(NULL), right(NULL), next(NULL) {}
    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/
class Solution {
public:
    Node* connect(Node* root) {
        //遍历每一层节点，前面的节点都指向下一个节点，最后的节点指向nullptr
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for(int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                //遍历到最后一个节点的时候单独处理
                if (i == size-1) {
                    node->next = nullptr;
                }
                else {
                    node->next = que.front();
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }        
        return root;
    }
};

104.二叉树的最大深度

题目：最大深度就是需要遍历的层数

代码：

/**
 * 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:
    int maxDepth(TreeNode* root) {
        //最大深度就是需要遍历的层数
        queue<TreeNode*> que;
        int depth = 0; //记入深度
        if (root != nullptr) que.push(root);

        while (!que.empty()) {
            int size = que.size();
            //每进行循环深度加1
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

111.二叉树的最小深度

题目：最小深度，就是在遍历每一层节点的时候，如果发现该节点没有子节点则停下循环。

/**
 * 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:
    int minDepth(TreeNode* root) {
        //最小深度，就是在遍历每一层节点的时候，如果发现该节点没有子节点则停下循环。
        queue<TreeNode*> que;
        int depth = 0; //记入深度
        if (root != nullptr) que.push(root);

        while (!que.empty()) {
            int size = que.size();
            //每进行循环深度加1
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (node->right == nullptr && node->left == nullptr) {
                    return depth;
                }
            }
        }
        return depth;
    }
};

总结 

学习有关树的基本知识，树的两大遍历方式，深度遍历和层次遍历。深度遍历可以使用递归也可以使用栈实现，层次遍历一般使用队列实现。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
《Windows API每日一练》9.3.1 快捷键
图算法（二十五）：子图匹配（Subgraph Matching）【基本的图查询操作，意在发掘图重要的子结构】【适用场景：社交网络分析、群体发现、异常检测】【在一个给定的大图里找到与给定小图同构的子图】
c1-03Web基础与布局
vue表格复制
Android中WebView输入框不弹起软盘问题记录
MySQL学习日志(一)
css横向滚动条支持鼠标滚轮
泊松分布的分布函数_常见概率分布汇总
【OJ01】顺序表-将顺序表中前 m 个元素和后 n 个元素进行互换(ADT+模板)
jsp宠物医院管理系统5rv74
;