代码随想录【Day 14】 | 树的层次遍历 102.二叉树的层序遍历、226.翻转二叉树 （优先掌握递归）、101. 对称二叉树 （优先掌握递归）
二叉树的种类
卡尔文解
满二叉树
满二叉树：如果一棵二叉树只有度为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，注意我这里没有说unordered_map、unordered_set，unordered_map、unordered_map底层实现是哈希表。
所以大家使用自己熟悉的编程语言写算法，一定要知道常用的容器底层都是如何实现的，最基本的就是map、set等等，否则自己写的代码，自己对其性能分析都分析不清楚！
二叉树的存储方式
二叉树可以链式存储，也可以顺序存储。
那么链式存储方式就用指针， 顺序存储的方式就是用数组。
顾名思义就是顺序存储的元素在内存是连续分布的，而链式存储则是通过指针把分布在各个地址的节点串联一起。
链式存储如图：
链式存储是大家很熟悉的一种方式，那么我们来看看如何顺序存储呢？
其实就是用数组来存储二叉树，顺序存储的方式如图：
用数组来存储二叉树如何遍历的呢？
如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。
但是用链式表示的二叉树，更有利于我们理解，所以一般我们都是用链式存储二叉树。
所以大家要了解，用数组依然可以表示二叉树。
二叉树的遍历方式
关于二叉树的遍历方式，要知道二叉树遍历的基本方式都有哪些。
一些同学用做了很多二叉树的题目了，可能知道前中后序遍历，可能知道层序遍历，但是却没有框架。
我这里把二叉树的几种遍历方式列出来，大家就可以一一串起来了。
二叉树主要有两种遍历方式：
深度优先遍历：先往深走，遇到叶子节点再往回走。
广度优先遍历：一层一层的去遍历。
这两种遍历是图论中最基本的两种遍历方式，后面在介绍图论的时候 还会介绍到。
那么从深度优先遍历和广度优先遍历进一步拓展，才有如下遍历方式：
深度优先遍历
前序遍历（递归法，迭代法）
中序遍历（递归法，迭代法）
后序遍历（递归法，迭代法）
广度优先遍历
层次遍历（迭代法）
在深度优先遍历中：有三个顺序，前中后序遍历， 有同学总分不清这三个顺序，经常搞混，我这里教大家一个技巧。
这里前中后，其实指的就是中间节点的遍历顺序，只要大家记住 前中后序指的就是中间节点的位置就可以了。
看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式
前序遍历：中左右
中序遍历：左中右
后序遍历：左右中
大家可以对着如下图，看看自己理解的前后中序有没有问题。
最后再说一说二叉树中深度优先和广度优先遍历实现方式，我们做二叉树相关题目，经常会使用递归的方式来实现深度优先遍历，也就是实现前中后序遍历，使用递归是比较方便的。
之前我们讲栈与队列的时候，就说过栈其实就是递归的一种实现结构，也就说前中后序遍历的逻辑其实都是可以借助栈使用非递归的方式来实现的。
而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。
这里其实我们又了解了栈与队列的一个应用场景了。
具体的实现我们后面都会讲的，这里大家先要清楚这些理论基础。
二叉树的定义
刚刚我们说过了二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，这个定义没啥可说的，我们来看看链式存储的二叉树节点的定义方式。
C++代码如下：
大家会发现二叉树的定义 和链表是差不多的，相对于链表 ，二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。
这里要提醒大家要注意二叉树节点定义的书写方式。
在现场面试的时候 面试官可能要求手写代码，所以数据结构的定义以及简单逻辑的代码一定要锻炼白纸写出来。
因为我们在刷leetcode的时候，节点的定义默认都定义好了，真到面试的时候，需要自己写节点定义的时候，有时候会一脸懵逼！
总结
二叉树是一种基础数据结构，在算法面试中都是常客，也是众多数据结构的基石。
本篇我们介绍了二叉树的种类、存储方式、遍历方式以及定义，比较全面的介绍了二叉树各个方面的重点，帮助大家扫一遍基础。
说到二叉树，就不得不说递归，很多同学对递归都是又熟悉又陌生，递归的代码一般很简短，但每次都是一看就会，一写就废。
#其他语言版本
二叉树的递归遍历三要素：
- 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
- 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
- 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。
144.二叉树的前序遍历
题目链接：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 {
private:
vector<int> result;
void _preorderTraversal(TreeNode* root, vector<int> &ret){
if ( root == NULL ) return;
result.push_back( root->val );
preorderTraversal( root->left );
preorderTraversal( root->right );
}
public:
vector<int> preorderTraversal(TreeNode* root) {
_preorderTraversal( root, result );
return result;
}
};
145.二叉树的后序遍历
题目链接：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 {
private:
vector<int> result;
void _postorderTraversal(TreeNode* root, vector<int> &ret){
if ( root == NULL ) return;
_postorderTraversal( root->left, result );
_postorderTraversal( root->right, result );
result.push_back( root->val );
}
public:
vector<int> postorderTraversal(TreeNode* root) {
_postorderTraversal( root, result );
return result;
}
};
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 {
private:
vector<int> result;
void _inorderTraversal(TreeNode* root, vector<int> &ret){
if ( root == NULL ) return;
_inorderTraversal( root->left, result );
result.push_back( root->val );
_inorderTraversal( root->right, result );
}
public:
vector<int> inorderTraversal(TreeNode* root) {
_inorderTraversal( root, result );
return result;
}
};
二叉树层序遍历
卡尔文解
102.二叉树的层序遍历
题目链接：102.二叉树的层序遍历
解题思路重点：
- 层序遍历，用 queue 来记录访问的节点。
- 用 queue 的 size 来记录遍历的层数。
代码实现：
/**
* 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 {
private:
vector<vector<int>> result;
queue<TreeNode*> que;
public:
vector<vector<int>> levelOrder(TreeNode* root) {
TreeNode *node = root;
if ( root ) que.push( node );
while ( !que.empty() ){
int size = que.size();
vector<int> vec;
for ( int i = 0; i < size; i++ ){
TreeNode *cur = que.front();
que.pop();
if ( cur->left ) que.push( cur->left );
if ( cur->right ) que.push( cur->right );
vec.push_back( cur->val );
}
result.push_back( vec );
}
return result;
}
};
题目
107.二叉树的层次遍历II
题目链接：107.二叉树的层次遍历II
解题思路重点：
- 层序遍历，用 queue 来记录访问的节点。
- 用 queue 的 size 来记录遍历的层数。
- Reverse the final result vector.
代码实现：
/**
* 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 {
private:
queue<TreeNode*> que;
vector<vector<int>> result;
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
if ( root ) que.push( root );
while( !que.empty() ){
int size = que.size();
vector<int> vec;
for( int i = 0; i < size; i++ ){
// Pop a parent node to queue.
// And add it to a level vector.
TreeNode *cur = que.front();
que.pop();
vec.push_back( cur->val );
// Push child nodes to queue.
if ( cur->left ) que.push( cur->left );
if ( cur->right ) que.push( cur->right );
}
result.push_back( vec );
}
reverse(result.begin(), result.end());
return result;
}
};
199.二叉树的右视图
题目链接：199.二叉树的右视图
解题思路重点：
- 层序遍历，用 queue 来记录访问的节点。
- 用 queue 的 size 来记录遍历的层数。
- Reverse the final result vector.
代码实现：
/**
* 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 {
private:
queue<TreeNode*> que;
vector<int> result;
public:
vector<int> rightSideView(TreeNode* root) {
if ( root ) que.push( root );
while ( !que.empty() ){
int size = que.size();
for ( int i = 0; i < size; i++ ){
TreeNode *cur = que.front();
que.pop();
if ( cur->left ) que.push( cur->left );
if ( cur->right ) que.push( cur->right );
if (i == size - 1) { //将当前层的最后一个节点放入结果列表
result.push_back( cur->val );
}
}
}
return result;
}
};
637.二叉树的层平均值
题目链接：637.二叉树的层平均值
解题思路重点：
- 层序遍历，用 queue 来记录访问的节点。
- 用 queue 的 size 来记录遍历的层数。
- 再计算各个层的结点值的平均数。
代码实现：
/**
* 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 {
private:
queue<TreeNode*> que;
vector<double> result;
public:
vector<double> averageOfLevels(TreeNode* root) {
if ( root ) que.push( root );
while ( !que.empty() ){
int size = que.size();
double sum = 0;
for ( int i = 0; i < size; i++ ){
TreeNode *cur = que.front();
que.pop();
sum += cur->val;
if ( cur->left ) que.push( cur->left );
if ( cur->right ) que.push( cur->right );
}
result.push_back( sum / size );
}
return result;
}
};
429.N叉树的层序遍历
题目链接：429.N叉树的层序遍历
解题思路重点：
- 层序遍历，用 queue 来记录访问的节点。
- 用 queue 的 size 来记录遍历的层数。
- 再依次遍历各个层的结点。
代码实现：
/*
// 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 {
private:
queue<Node*> que;
vector<vector<int>> result;
public:
vector<vector<int>> levelOrder(Node* root) {
if ( root ) que.push( root );
while ( !que.empty() ){
int size = que.size();
vector<int> vec;
for ( int i = 0; i < size; i++ ){
Node *cur = que.front();
que.pop();
vec.push_back( cur->val );
for ( int idx = 0; idx < (cur->children).size(); idx++ ){
que.push( (cur->children)[ idx ] );
}
}
result.push_back( vec );
}
return result;
}
};
515.在每个树行中找最大值
515.在每个树行中找最大值
题目链接：515.在每个树行中找最大值
解题思路重点：
- 层序遍历，用 queue 来记录访问的节点。
- 用 queue 的 size 来记录遍历的层数。
- 再依次记录各个层的最大值。
代码实现：
/**
* 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 {
private:
queue<TreeNode*> que;
vector<int> result;
public:
vector<int> largestValues(TreeNode* root) {
if ( root ) que.push( root );
while ( !que.empty() ){
int size = que.size();
int max = INT_MIN;
for ( int i = 0; i < size; i++ ){
TreeNode *cur = que.front();
que.pop();
if ( cur->val > max ) max = cur->val;
if ( cur->left ) que.push( cur->left );
if ( cur->right ) que.push( cur->right );
}
result.push_back( max );
}
return result;
}
};
116.填充每个节点的下一个右侧节点指针
题目链接：116.填充每个节点的下一个右侧节点指针
解题思路重点：
- 层序遍历，用 queue 来记录访问的节点。
- 用 queue 的 size 来记录遍历的层数。
- 使用prev 还有 current 指针 ， 来调整指针的指向。
代码实现：
/*
// 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 {
//Node *result;
queue<Node*> dq;
// void display( deque<Node*>& dq ){
// std::cout << "All numbers:";
// for (auto i : dq) {
// std::cout << ' ' << i->val;
// }
// std::cout << '\n';
// }
public:
Node* connect(Node* root) {
if ( !root ) return NULL;
dq.push( root );
while ( !dq.empty() ){
int size = dq.size();
Node *prevNode;
Node *curNode;
for ( int i = 0; i < size; i++ ){
if ( i == 0 ){
prevNode = dq.front(); // 取出一层的头结点
dq.pop();
curNode = prevNode;
}
else{
curNode = dq.front();
dq.pop();
prevNode->next = curNode; // 本层前一个节点next指向本节点
prevNode = prevNode->next;
}
if ( curNode->left ) dq.push( curNode->left );
if ( curNode->right ) dq.push( curNode->right );
}
}
return root;
}
};
117.填充每个节点的下一个右侧节点指针II
题目链接：117.填充每个节点的下一个右侧节点指针II
解题思路重点：
- 层序遍历，用 queue 来记录访问的节点。
- 用 queue 的 size 来记录遍历的层数。
- 使用prev 还有 current 指针 ， 来调整指针的指向。
代码实现：
/*
// 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 {
//Node *result;
queue<Node*> dq;
// void display( deque<Node*>& dq ){
// std::cout << "All numbers:";
// for (auto i : dq) {
// std::cout << ' ' << i->val;
// }
// std::cout << '\n';
// }
public:
Node* connect(Node* root) {
if ( !root ) return NULL;
dq.push( root );
while ( !dq.empty() ){
int size = dq.size();
Node *prevNode;
Node *curNode;
for ( int i = 0; i < size; i++ ){
if ( i == 0 ){
prevNode = dq.front(); // 取出一层的头结点
dq.pop();
curNode = prevNode;
}
else{
curNode = dq.front();
dq.pop();
prevNode->next = curNode; // 本层前一个节点next指向本节点
prevNode = prevNode->next;
}
if ( curNode->left ) dq.push( curNode->left );
if ( curNode->right ) dq.push( curNode->right );
}
}
return root;
}
};
104.二叉树的最大深度
题目链接：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) {
if ( !root ) return 0;
int leftDepth = maxDepth( root->left );
int rightDepth = maxDepth( root->right );
int ret = 1 + max( leftDepth, rightDepth);
return ret;
}
};
111.二叉树的最小深度
题目链接：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) {
if ( !root ) return 0;
int leftDep = minDepth( root->left );
int rightDep = minDepth( root->right );
if ( !root->left && root->right )
return ( 1 + rightDep );
if ( !root->right && root->left )
return ( 1 + leftDep );
return (1 + min( leftDep, rightDep));
}
};
226.翻转二叉树 （优先掌握递归）
226.翻转二叉树 （优先掌握递归）
解题思路重点：
- 没啥说的
代码实现：
/**
* 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 ) return root;
//前序遍历方式
swap( root->left, root->right );
invertTree( root->left );
invertTree( root->right );
return root;
}
};
101. 对称二叉树 （优先掌握递归）
101. 对称二叉树 （优先掌握递归）
卡尔文解
解题思路重点：
首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！
对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。
那么如何比较呢？
比较的是两个子树的里侧和外侧的元素是否相等。如图所示：
那么遍历的顺序应该是什么样的呢？
本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。
正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。
但都可以理解算是后序遍历，尽管已经不是严格上在一个树上进行遍历的后序遍历了。
其实后序也可以理解为是一种回溯，当然这是题外话，讲回溯的时候会重点讲的。
说到这大家可能感觉我有点啰嗦，哪有这么多道理，上来就干就完事了。别急，我说的这些在下面的代码讲解中都有身影。
那么我们先来看看递归法的代码应该怎么写。
代码实现：
/**
* 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 {
private:
bool compare( TreeNode *left, TreeNode *right ){
// 后序遍历
// 左树 右树 结果
// 空 不 false
// 不 空 false
// 空 空 true
// 值不相等 false
if( !left && right ) return false;
else if( left && !right ) return false;
else if( !left && !right ) return true;
else if( left->val != right->val ) return false;
bool outside = compare( left->left, right->right );
bool inside = compare( left->right, right->left );
return ( outside && inside );
}
public:
bool isSymmetric(TreeNode* root) {
return compare( root->left, root->right );
}
};
677
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
