leetcode刷题笔记8-二叉树（未完待续）

最新推荐文章于 2024-07-22 17:06:26 发布

infinite.?

最新推荐文章于 2024-07-22 17:06:26 发布

阅读量136

点赞数

分类专栏：算法笔记 leetcode 文章标签：算法数据结构

本文链接：https://blog.csdn.net/infinite2020/article/details/129922019

版权

算法笔记同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

leetcode

9 篇文章 0 订阅

订阅专栏

二叉树

代码随想录刷题笔记

代码随想录 (programmercarl.com)

二叉树理论基础

二叉树的种类

在我们解题过程中二叉树有两种主要的形式：满二叉树和完全二叉树。

满二叉树

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

如图所示：

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

完全二叉树

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

满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。

我来举一个典型的例子如题：

之前我们刚刚讲过优先级队列其实是一个堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系。

二叉搜索树

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

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

下面这两棵树都是搜索树

二叉搜索树对节点的布局没有要求，但是对节点间的顺序有要求，必须有序

平衡二叉树

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

如图：

最后一棵不是平衡二叉树，因为它的左右两个子树的高度差的绝对值超过了1。

C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn且map中的key和set中的元素都是有序的，

注意这里没有说unordered_map、unordered_set，unordered_map、unordered_map底层实现是哈希表。

所以大家使用自己熟悉的编程语言写算法，一定要知道常用的容器底层都是如何实现的，最基本的就是map、set等等，否则自己写的代码，自己对其性能分析都分析不清楚

二叉树的存储方式

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

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

顾名思义就是顺序存储的元素在内存是连续分布的，而链式存储则是通过指针把分布在散落在各个地址的节点串联一起。

链式存储如图：

顺序存储如图：

用数组来存储二叉树如何遍历的呢？

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

但是用链式表示的二叉树，更有利于我们理解，所以一般我们都是用链式存储二叉树。（二叉树的本质就是链表。只不过每个节点是有两个指针，一个指向左孩子节点，一个指向右孩子节点，将头结点传入即可构造一个二叉树）

所以大家要了解，用数组依然可以表示二叉树。

二叉树的遍历方式

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

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

这两种遍历是图论中最基本的两种遍历方式，后面在介绍图论的时候还会介绍到。

那么从深度优先遍历和广度优先遍历进一步拓展，才有如下遍历方式：

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

在深度优先遍历中：有三个顺序，前中后序遍历，有同学总分不清这三个顺序，经常搞混，我这里教大家一个技巧。

这里前中后，其实指的就是中间节点的遍历顺序，只要大家记住前中后序指的就是中间节点的位置就可以了。

看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式

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

大家可以对着如下图，看看自己理解的前后中序有没有问题。

最后再说一说二叉树中深度优先和广度优先遍历实现方式，我们做二叉树相关题目，经常会使用递归的方式来实现深度优先遍历，也就是实现前中后序遍历，使用递归是比较方便的。

之前我们讲栈与队列的时候，就说过栈其实就是递归的一种是实现结构，也就说前中后序遍历的逻辑其实都是可以借助栈使用非递归的方式来实现的。

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

这里其实我们又了解了栈与队列的一个应用场景了。

具体的实现我们后面都会讲的，这里大家先要清楚这些理论基础。

二叉树的定义

因为我们在刷leetcode的时候，刷题模式是核心代码模式，节点的定义默认都定义好了，真到面试的时候，需要自己写节点定义的时候，有时候会一脸懵逼

刚刚我们说过了二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，这个定义没啥可说的，我们来看看链式存储的二叉树节点的定义方式。

C++代码如下：

struct TreeNode {
    int val;	//存储对应节点的数值
    TreeNode *left;	//定义左指针，指向左孩子
    TreeNode *right;//定义右指针，指向右孩子
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}	//构造函数，传入一个值对val进行赋值，默认左右指针为空
};

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

这里要提醒大家要注意二叉树节点定义的书写方式。

在现场面试的时候面试官可能要求手写代码，所以数据结构的定义以及简单逻辑的代码一定要锻炼白纸写出来。

总结

二叉树是一种基础数据结构，在算法面试中都是常客，也是众多数据结构的基石。

本篇我们介绍了二叉树的种类、存储方式、遍历方式以及定义，比较全面的介绍了二叉树各个方面的重点，帮助大家扫一遍基础。

说到二叉树，就不得不说递归，很多同学对递归都是又熟悉又陌生，递归的代码一般很简短，但每次都是一看就会，一写就废

二叉树的递归遍历

递归算法的三个要素。每次写递归，都按照这三要素来写，可以保证写出正确的递归算法！

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

好了，我们确认了递归的三要素，接下来就来练练手：

以下以前序遍历为例：

确定递归函数的参数和返回值：

参数：1. 根节点cur 2.因为要打印出前序遍历节点的数值，所以参数里需要传入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); // 右

单层递归的逻辑就是按照中左右的顺序来处理的，这样二叉树的前序遍历，基本就写完了，再看一下完整代码：

前序遍历：

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        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;
    }
};

那么前序遍历写出来之后，中序和后序遍历就不难理解了，代码如下：

中序遍历：（左中右）

void traversal(TreeNode* cur, vector<int>& vec) {
    if (cur == NULL) return;
    traversal(cur->left, vec);  // 左
    vec.push_back(cur->val);    // 中
    traversal(cur->right, vec); // 右
}

后序遍历：（左右中）

void traversal(TreeNode* cur, vector<int>& vec) {
    if (cur == NULL) return;
    traversal(cur->left, vec);  // 左
    traversal(cur->right, vec); // 右
    vec.push_back(cur->val);    // 中
}

leetcode上三道题目，分别是：

144.二叉树的前序遍历(opens new window)

/**
 * 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; //终止条件
        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;
    }
};

145.二叉树的后序遍历(opens new window)

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

94.二叉树的中序遍历(opens new window)

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

二叉树的迭代遍历

为什么可以用迭代法（非递归的方式）来实现二叉树的前后中序遍历呢？

我们在栈与队列：匹配问题都是栈的强项 (opens new window)中提到了，

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

此时大家应该知道我们用栈也可以是实现二叉树的前后中序遍历了。

前序遍历（迭代法）

前序遍历：中左右，每次先处理中间节点，那么想将根节点放入栈中，然后将右孩子加入栈，再加入左孩子。

为什么先加入右孩子，再加入左孩子呢？因为栈是先进后出的数据结构，所以先加入右孩子，但后弹出右孩子。

代码细节：

（1）初始化定义一个栈st和数组vec（stack<TreeNode> st; vector vec*）

（2）首先需要判断这个树是否为空，若为空，则直接返回。（if(root == NULL) return result;）若不为空，则执行以下操作：

（3）向栈中放入根节点（st.push(root)），开始循环处理栈

（4）只要栈不为空，一直循环以下遍历二叉树操作：（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);）

重复以上操作，直到栈为空，那么前序遍历完成，最终遍历结果放入了vec数组中，最终返回vec即可（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> preorderTraversal(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->right)  st.push(node->right);//右：继续向下遍历该节点右孩子（空节点不入栈）！注意先遍历右孩子，因为栈是先进后出，先放入右孩子，最后后弹出右孩子
            if(node->left)  st.push(node->left);//左
        }
        return result;
    }
};

后序遍历（迭代法）

后序遍历：左右中，而先序遍历顺序是中左右，那么是否可以换一种思路，调整前序遍历的代码顺序，变为中右左的遍历顺序，放入数组中，最后反转数组（reverse(result.begin(), result.end()); ），输出的结果就是左右中了。

前序到后序

参考代码：

/**
 * 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> vec;
        stack<TreeNode*> st;
        if(root == NULL)    return vec;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();//中
            st.pop();
            vec.push_back(node->val);
            if(node->left)  st.push(node->left);// 左：相对于前序遍历，这更改一下入栈顺序 （空节点不入栈）
            if(node->right) st.push(node->right);// 右：空节点不入栈
        }
        reverse(vec.begin(), vec.end());    //将结果反转之后就是左右中的顺序了
        return vec;
    }
};

中序遍历（迭代法）

用迭代法写中序遍历的时候，会发现套路又不一样了，目前的前序遍历的逻辑无法直接应用到中序遍历上。

中序遍历：左中右，

前序和后序遍历中分为两步：访问+处理；

访问就是遍历访问二叉树节点，而处理就是将元素放入result数组中。

而前序和后序遍历中，访问和处理的是同一个节点（先访问中节点，要处理的也是中节点），

但是中序遍历则不是，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左边的最底部，才开始处理节点（将节点的数值放入result数组中）。

这样就造成了处理顺序和访问顺序是不一致。

所以在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素（记录遍历过的节点，并按照顺序弹出）

代码细节：

（1）初始化定义一个栈st和数组result（stack<TreeNode> st; vector result*）

（2）定义一个指针cur用于遍历二叉树（TreeNode* cur = root）

（3）只要cur指针不为空，或者栈中的元素不为空时，循环执行以下操作：

如果当前指针所指节点不为空，那么将当前指针遍历的节点的值加入到栈中，指针继续向左遍历二叉树（先一路向左）

如果当前指针所指节点为空，那么就该从栈顶（最近访问过的元素）弹出元素并且将该元素加入result数组中，接着遍历当前指针的右孩子；

（4）循环结束后，返回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;    //定义栈，用于处理遍历过的节点
        TreeNode* cur = root;   //定义指针，用于遍历二叉树root
        while(cur != NULL || !st.empty()){
            if(cur != NULL){// 指针来访问节点，访问到最底层
                st.push(cur);   //将访问过的节点放入栈中
                cur = cur->left;    //左：只要指针指向的节点不为空，那么一直向左访问节点
            } else {    //当前指针所指节点为空，
                cur = st.top();    // 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
                st.pop();       //删除栈顶元素
                result.push_back(cur->val) ;  //中
                cur = cur->right;   //右
            }
        }
        return result;
    }
};

二叉树的层序遍历

学会二叉树的层序遍历，可以一口气打完以下十题：

102.二叉树的层序遍历
107.二叉树的层次遍历II
199.二叉树的右视图
637.二叉树的层平均值
429.N叉树的层序遍历
515.在每个树行中找最大值
116.填充每个节点的下一个右侧节点指针
117.填充每个节点的下一个右侧节点指针II
104.二叉树的最大深度
111.二叉树的最小深度

102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的层序遍历。（即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

解题思路：

二叉树的递归以及迭代遍历，全是有关二叉树的深度优先遍历。其实对应图论里的深度优先遍历

此题，介绍二叉树的另一种遍历方式：层序遍历。其实也就是对应图论里的广度优先遍历

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。

如何一层一层保存二叉树中的节点？二叉树本身的数据结构无法实现，所以需要借助一个辅助数据结构即队列来实现。

队列先进先出，符合一层一层遍历的逻辑，而使用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

遍历二叉树节点加入队列时需要记录队列中本层的元素个数（可以利用公式：第n层节点数 = 2^（n - 1）计算出当前访问二叉树中的第几层），一层一层加入，一层一层弹出（弹出时将弹出节点的左右孩子加入到队列）

代码细节：

（1）初始化定义一个队列（queue<TreeNode> que*），以及一个二维数组（vector(vector) result），存放层序遍历结果result

（2）首先判断二叉树是否为空，不为空（if(root != NULL）则将第一个根节点加入到que队列中（que.push(root)）

（3）遍历整个二叉树（终止条件：队列不为空也就是没有元素再加入到队列中）执行以下循环（while(!que.empty())）：

记录当前层节点的个数（循环控制队列中弹出的节点数量）（int size = que.size()）

定义一维数组（vector vec），存放同一层的节点

遍历当前层（队列中）所有元素（while(size–)），获取队列中各个节点（node = que.front(); que.pop()），将节点的值放入到一维数组vec中（vec.push_back(node->val)）。并将该节点的左右孩子加入到队列中（注意判断左右孩子是否为空）（if(node->left) que.push(node-left)）。。。

遍历（一层一层）完成后，将记录的vec一维数组数组（result.push_back(vec)），加入到result中组成二维数组

（4）最终返回result二维数组（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<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL)   que.push(root); //将根节点加入到队列中
        vector<vector<int>> result; //二维数组存放结果
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            while(size--){
                TreeNode* node = que.front();   //将队列中节点取出
                que.pop();
                vec.push_back(node->val);   //加入到数组中
                //弹出节点时，将其左右孩子加入到队列中，所以que的大小不断变化
                if(node->left)  que.push(node->left);  
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

此时我们就掌握了二叉树的层序遍历了，那么如下九道力扣上的题目，只需要修改模板的两三行代码（不能再多了），便可打倒!

107. 二叉树的层序遍历 II

给你二叉树的根节点 root ，返回其节点值自底向上的层序遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

解题思路：

自底向上层序遍历，其实就是将自顶向下遍历后的结果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<vector<int>> levelOrderBottom(TreeNode* root) {
        //自底向上层序遍历，其实就是将自顶向下遍历后的结果result数组反转一下就可以
        queue<TreeNode*> que;
        if(root != NULL)   que.push(root); //将根节点加入到队列中
        vector<vector<int>> result; //二维数组存放结果
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            while(size--){
                TreeNode* node = que.front();   //将队列中节点取出
                que.pop();
                vec.push_back(node->val);   //加入到数组中
                //弹出节点时，将其左右孩子加入到队列中，所以que的大小不断变化
                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. 二叉树的右视图

给定一个二叉树的根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

解题思路：

层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回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> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL)   que.push(root); //将根节点加入到队列中
        vector<int> result; //二维数组存放结果
        while(!que.empty()){
            int size = que.size();
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            while(size--){
                TreeNode* node = que.front();   //将队列中节点取出
                que.pop();
                // 判断是否为每一层最后一个元素，如果是，将其放入result数组中
                if(size == 0)   result.push_back(node->val);   //加入到数组中
                //弹出节点时，将其左右孩子加入到队列中，所以que的大小不断变化
                if(node->left)  que.push(node->left);  
                if(node->right) que.push(node->right);
            }
        }
        return result;
    }
};

637. 二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10^-5 以内的答案可以被接受。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]

解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。
示例 2:

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

解题思路：

层序遍历的时候把一层求个总和在取一个均值。

参考代码：

/**
 * 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) {
        vector<double> result;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            double sum = 0;
            int size = que.size();
            int n = size;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            sum /= n;
            result.push_back(sum);
        }
        return result;
    }
};

429. N 叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

参考代码：

/*
// 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) {
        vector<vector<int>> result;
        queue<Node*> que;
        if(root != NULL)    que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            while(size--){
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                // 遍历所有孩子节点，将节点孩子加入队列
                for(int i = 0; i < node->children.size(); i++){
                    if(node->children[i])   que.push(node->children[i]);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

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

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

示例2：

输入: root = [1,2,3]
输出: [1,3]

解题思路：

有一个小细节：如何

c++中表示最大最小整数

INT_MIN在标准头文件limits.h中定义。

#include<limits.h>
C/C++中常量INT_MAX和INT_MIN分别表示最大、最小整数，头文件是limits.h。

INT_MAX = 2^31-1=2147483647；

INT_MIN= -2^31=-2147483648；

在C/C++语言中，不能够直接使用-2147483648来代替最小负数，因为这不是一个数字，而是一个表达式。表达式的意思是对整数21473648取负，但是2147483648已经溢出了int的上限。

参考代码：

/**
 * 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) {
        vector<int> result;
        queue<TreeNode*> que;
        if(root != NULL)    que.push(root);
        while(!que.empty()){
            int size = que.size();
            int max = INT_MIN; // 取每一层的最大值
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                if(node->val > 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. 填充每个节点的下一个右侧节点指针

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

示例 1：

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。

示例 2:

输入：root = []
输出：[]

提示：

树中节点的数量在 [0, 212 - 1] 范围内
-1000 <= node.val <= 1000

进阶：

你只能使用常量级额外空间。
使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

解题思路：

在遍历二叉树的同时，如果设定的size为0，那么代表本层结束，将该节点的next指针指向null。如果不是0，那么next指针指向队列的头结点

参考代码：

/*
// 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) {
        queue<Node*> que;
        if(root != NULL)    que.push(root);
        while(!que.empty()){
            int size = que.size();
            while(size--){
                Node* node = que.front();
                que.pop();
                if(size == 0)   node->next = NULL;
                else {
                    node->next = que.front();
                }
                if(node->left)  que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

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

给定一个二叉树

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

进阶：

你只能使用常量级额外空间。
使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

示例：

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），‘#’ 表示每层的末尾。

解题思路：

这道题和116题其实没有差别，这道题说的是二叉树，而116题说的是完整二叉树，一样的代码一样的逻辑

参考代码：

/*
// 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) {
        queue<Node*> que;
        if(root != NULL)    que.push(root);
        while(!que.empty()){
            int size = que.size();
            while(size--){
                Node* node = que.front();
                que.pop();
                if(size == 0)   node->next = NULL;
                else {
                    node->next = que.front();
                }
                if(node->left)  que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

解题思路：

所以这道题的迭代法就是一道模板题，可以使用二叉树层序遍历的模板来解决的。

使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。

参考代码：

/**
 * 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) {
        int depth = 0;
        queue<TreeNode*> que;
        if(root != NULL)    que.push(root);
        while(!que.empty()){
            int size = que.size();
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                if(node->left)  que.push(node->left);
                if(node->right) que.push(node->right);
            }
            depth++;
        }
        return depth;
    }
};

111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

解题思路：

相对于 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 minDepth(TreeNode* root) {
        if(root == NULL)  return 0;  
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            depth++;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                //注意只有左右孩子均为空时，才能返回最小深度否则需要继续遍历，将节点加入到队列中去！
                if(node->left)  que.push(node->left);
                if(node->right) que.push(node->right);
                if(!node->left && !node->right){
                    return depth;
                }  
            }
        }
        return depth;
    }
};

二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用，需要借助队列来实现（此时又发现队列的一个应用了）。

翻转二叉树

226. 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：

输入：root = [2,1,3]
输出：[2,3,1]

示例 3：

输入：root = []
输出：[]

解题思路：

翻转二叉树，其实就是将整个树以中轴线进行翻转，注意交换的是指针（该节点的左右孩子也跟着交换），而不是数值。

首先思考：这种题目应该使用哪种遍历方式？递归（前中后序？）？迭代？

这道题，

如果使用递归的方式：使用前序和后序递归遍历最合适，（中序比较麻烦）为什么？因为中序遍历会把某些节点的左右孩子翻转两次

如果使用层序遍历的方式：把每一个节点的左右孩子翻转一下也是可以的

递归法（前、后序遍历）：

递归三部曲：

确定递归函数的参数和返回值

返回值：新的二叉树的根节点（TreeNode*型）

参数：传入的原二叉树根节点root
```
TreeNode* invertTree(TreeNode* root)
```
确定终止条件

遇到空节点时，即可终止，返回新二叉树的根节点
```
if(root == NULL)	return root;
```
确定单层递归的逻辑

前序遍历（中左右）：

因为是先遍历中，所以先交换左右孩子节点，然后反转左子树，反转右子树。
```
swap(root->left, root->right);//中
invertTree(root->left);//左
invertTree(root->right);//右
```
后序遍历（左右中）：

因为是最后遍历中，所以先遍历左右孩子，将交换左右孩子节点的逻辑放到最后，交换左右即可。
```
invertTree(root->left);//左
invertTree(root->right);//右
swap(root->left, root->right);//中
```
那么可不可以将swap放到中间呢？答案是不可以的。**因为使用递归的中序遍历，某些节点的左右孩子会翻转两次。**递归返回处理中时，会把某些节点左右孩子翻转两次，某些节点不进行反转，最后结果错误。

如果非要使用递归中序的方式写，也可以，如下代码就可以避免节点左右孩子翻转两次的情况：因为交换后，此时的右子树是原来的左子树
```
invertTree(root->left);//左
swap(root->left, root->right);//中
invertTree(root->left);// 注意 这里依然要遍历左孩子，因为中间节点已经翻转了
```
代码虽然可以，但这毕竟不是真正的递归中序遍历了。

参考代码：

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {//递归法（前序遍历）
        if(root == NULL)    return root;    //终止条件，当遍历到的节点为空时，返回
        swap(root->left, root->right);  //中
        invertTree(root->left);//左
        invertTree(root->right);//右
        return root;
    }
};

迭代法：（深度、广度优先遍历）

深度优先遍历

在迭代遍历中，给出了用栈模拟前中后序迭代方式的写法，所以参考代码如下：

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {  //迭代法-深度优先遍历（先序遍历）
        if(root == NULL)    return root;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();  //中
            st.pop();
            swap(node->left, node->right);
            if(node->right) st.push(node->right);   //右,注意需要判断右子树是否为空
            if(node->left)  st.push(node->left);    //左,注意需要判断左子树是否为空
        }
        return root;
    }
};

广度优先遍历

也就是层序遍历，层数遍历也是可以翻转这棵树的，因为层序遍历也可以把每个节点的左右孩子都翻转一遍，代码如下：

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {  //迭代法-广度优先遍历（层序遍历）
        queue<TreeNode*> que;
        if(root==NULL)  return root;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right);  //处理节点
                if(node->left)  que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

针对二叉树的问题，解题之前一定要想清楚究竟是前中后序遍历，还是层序遍历。

二叉树解题的大忌就是自己稀里糊涂的过了（因为这道题相对简单），但是也不知道自己是怎么遍历的。

针对翻转二叉树，我给出了一种递归，两种迭代（深度优先遍历，层序遍历）的写法，都是之前我们讲过的写法，融汇贯通一下而已。

总结：

二叉树的遍历一般分为两大种方法：

递归遍历（前中后序）和迭代遍历（深度优先，广度优先）。

在递归遍历中，要注意递归算法的三个要素—确定递归函数的参数和返回值、确定终止条件、确定单层递归的逻辑

在迭代遍历中，

深度优先：用栈也实现二叉树的前后中序遍历（注意栈先进后出，所以前序遍历应该是中右左，弹出栈顶元素才能使中左右顺序）

广度优先：用队列实现二叉树的层序遍历（使用size记录每层节点个数）

对称二叉树

101. 对称二叉树

给你一个二叉树的根节点 root ，检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

解题思路：

判断一棵二叉树是否对称，本质上判断根节点的左子树和右子树是否可以相互翻转。

如何比较呢？判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！，**比较的是两个子树的里侧和外侧的元素是否相等。**若以同一根节点（对称节点）的内外侧元素对应相等，则说明该根节点的左右孩子是可以相互翻转的。

如何遍历呢？

这道题只能使用后序遍历（左右中），因为我们要通过递归函数的返回值（相同位置内外节点是否相等的信息）来判断两个子树的内侧节点和外侧节点是否相等。而使用前序和中序，均是还没有处理完孩子节点是否相等，就返回给中节点，判断不了是否可以翻转。

所以，当题目中需要收集孩子的信息 向上一层返回的题目，均需要使用后序遍历！

代码细节：

递归法：

递归三部曲

确定递归函数的参数和返回值

因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，

**参数：**左子树节点和右子树节点。

**返回值：**bool类型。
确定终止条件

要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！（否则后面比较数值的时候就会操作空指针了。出现空指针异常）

为空的条件有：
- 左节点为空，右节点不为空，不对称，return false
- 左不为空，右为空，不对称 return false
- 左右都为空，对称，return true
此时已经排除掉了节点为空的情况，那么剩下的就是左右节点不为空：
- 左右都不为空，比较节点数值，不相同就return false
- 左右都不为空，且数值相同的情况。（最后一种else,则到达单层递归的逻辑）
确定单层递归的逻辑

单层递归的逻辑就是处理 左右节点都不为空，且数值相同的情况。
- 左：比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
- 右：比较二叉树内侧是否对称：传入的是左节点的右孩子，右节点的左孩子。
- 中：如果左右都对称就返回true ，有一侧不对称就返回false 。
正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

参考代码：

/**
 * 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:
    bool compare(TreeNode* left, TreeNode* right){  //比较左右字数是否可以翻转（是否轴对称相等）
        // 首先排除空节点情况，避免空指针异常
        if(left == NULL && right != NULL)   return false;
        else if(left != NULL && right == NULL)  return false;
        else if(left == NULL && right == NULL)  return true;
        // 排除数值不相等的情况
        else if(left->val != right->val)    return false;
        // 左右节点都不为空，且数值相等的情况，才做递归
        bool outside = compare(left->left, right->right);   //比较外侧节点：左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    //比较内侧节点：左子树：右、 右子树：左
        bool isSame = outside && inside;                    //左子树：中、 右子树：中 （逻辑处理）
        return isSame;
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL)    return true;
        return compare(root->left, root->right);
    }
};

简洁版：

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        else if (left->val != right->val) return false;
        else return compare(left->left, right->right) && compare(left->right, right->left);

    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};

迭代法：

使用队列

因为本题的本质是判断两个树是否是相互翻转的，其实已经不是所谓二叉树遍历的前中后序的关系了。

这里我们可以使用队列来比较两个树（根节点的左右子树）是否相互翻转，（注意这不是层序遍历）

二叉树的最大深度

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

解题思路：

首先需要区分深度和高度（二叉树中）

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始，一般从1开始）
二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始，一般从1开始）

如何求高度和深度呢？

深度—>从上向下遍历—>前序遍历（中左右）首先执行中的处理过程，向下遍历一层深度+1

高度—>从下向上遍历—>后序遍历（左右中）将中的处理过程返回给父节点，父节点高度+1

所以关键所在：

而根节点的高度就是二叉树的最大深度，所以本题中我们通过后序求的根节点高度来求的二叉树最大深度。

代码细节：

1 递归法—后序遍历

确定递归函数的参数和返回值：

参数就是传入树的根节点，

返回就返回这棵树的深度，所以返回值为int类型。

int getdepth(treenode* node)	//求二叉树最大深度

确定终止条件：

遍历的节点，如果为空节点的话，就返回0，表示高度为0。

if (node == NULL) return 0;

确定单层递归的逻辑：

后序遍历：左右中（中处理）

先求它的左子树的深度，再求的右子树的深度，最后取左右深度最大的数值 再+1 （加1是因为算上当前中间节点）就是目前节点为根节点的树的深度。

int leftdepth = getdepth(node->left);       // 左
int rightdepth = getdepth(node->right);     // 右
int depth = 1 + max(leftdepth, rightdepth); // 中，处理逻辑
return depth;//将当前父节点高度返回给上一层，从而实现从下向上计算根节点到叶子结点的高度

可以精简为：

return 1 + max(getdepth(node->left), getdepth(node->right));

参考代码：

/**
 * 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 getDepth(TreeNode* node) {
        if(node == NULL)    return 0;
        int leftDepth = getDepth(node->left);//左
        int rightDepth = getDepth(node->right);//右
        int depth = 1 + max(leftDepth, rightDepth);//中-处理
        return depth;
    }
    int maxDepth(TreeNode* root) {
        return getDepth(root);
    }
};

精简版参考代码：

/**
 * 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) {
        if(root == NULL)    return 0;
        return 1 + max(maxDepth(root->left), maxDepth(root->right));
    }
};

2 递归法-前序遍历

本题当然也可以使用前序，代码如下：(充分表现出求深度回溯的过程)

class solution {
public:
    int result;
    void getdepth(treenode* node, int depth) {
        result = depth > result ? depth : result; // 中

        if (node->left == NULL && node->right == NULL) return ;

        if (node->left) { // 左
            depth++;    // 深度+1
            getdepth(node->left, depth);
            depth--;    // 回溯，深度-1
        }
        if (node->right) { // 右
            depth++;    // 深度+1
            getdepth(node->right, depth);
            depth--;    // 回溯，深度-1
        }
        return ;
    }
    int maxdepth(treenode* root) {
        result = 0;
        if (root == NULL) return result;
        getdepth(root, 1);
        return result;
    }
};

可以看出使用了前序（中左右）的遍历顺序，这才是真正求深度的逻辑！

注意以上代码是为了把细节体现出来，简化一下代码如下：

class solution {
public:
    int result;
    void getdepth(treenode* node, int depth) {
        result = depth > result ? depth : result; // 中
        if (node->left == NULL && node->right == NULL) return ;
        if (node->left) { // 左
            getdepth(node->left, depth + 1);
        }
        if (node->right) { // 右
            getdepth(node->right, depth + 1);
        }
        return ;
    }
    int maxdepth(treenode* root) {
        result = 0;
        if (root == 0) return result;
        getdepth(root, 1);
        return result;
    }
};

3 迭代法-层序遍历

使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。

在二叉树中，一层一层的来遍历二叉树，记录一下遍历的层数就是二叉树的深度，如图所示：

层序遍历

所以这道题的迭代法就是一道模板题，可以使用二叉树层序遍历的模板来解决的。

如果对层序遍历还不清楚的话，可以看这篇：二叉树：层序遍历登场！(opens new window)

c++代码如下：

class solution {
public:
    int maxdepth(treenode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<treenode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            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. 二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

未完待续…
}
};


**可以看出使用了前序（中左右）的遍历顺序，这才是真正求深度的逻辑！**

注意以上代码是为了把细节体现出来，简化一下代码如下：

```cpp
class solution {
public:
    int result;
    void getdepth(treenode* node, int depth) {
        result = depth > result ? depth : result; // 中
        if (node->left == NULL && node->right == NULL) return ;
        if (node->left) { // 左
            getdepth(node->left, depth + 1);
        }
        if (node->right) { // 右
            getdepth(node->right, depth + 1);
        }
        return ;
    }
    int maxdepth(treenode* root) {
        result = 0;
        if (root == 0) return result;
        getdepth(root, 1);
        return result;
    }
};

3 迭代法-层序遍历

使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。

在二叉树中，一层一层的来遍历二叉树，记录一下遍历的层数就是二叉树的深度，如图所示：

层序遍历

所以这道题的迭代法就是一道模板题，可以使用二叉树层序遍历的模板来解决的。

如果对层序遍历还不清楚的话，可以看这篇：二叉树：层序遍历登场！(opens new window)

c++代码如下：

class solution {
public:
    int maxdepth(treenode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<treenode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            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. 二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

示例 1：

[外链图片转存中…(img-TOCZvMze-1680485266170)]

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

未完待续…

infinite.?

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode刷题笔记8-二叉树（未完待续）

因为我们在刷leetcode的时候，刷题模式是核心代码模式，节点的定义默认都定义好了，真到面试的时候，需要自己写节点定义的时候，有时候会一脸懵逼刚刚我们说过了二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，这个定义没啥可说的，我们来看看链式存储的二叉树节点的定义方式。int val;//存储对应节点的数值 TreeNode * left;//定义左指针，指向左孩子 TreeNode * right;
复制链接

扫一扫