代码随想录算法训练营
二叉树理论基础
二叉树的种类
1. 满二叉树
性质：深度为K ，节点数： 2^k-1
2. 完全二叉数
3. 二叉搜索树
二叉搜索树是有数值的，二叉搜索树是一个有序树。
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉排序树
3. 平衡二叉搜索树
又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
二叉树的存储方式
二叉树可以链式存储，也可以顺序存储。
那么链式存储方式就用指针， 顺序存储的方式就是用数组。
链式存储：
顺序存储：
二叉树遍历方式
二叉树主要有两种遍历方式：
- 深度优先遍历：先往深走，遇到叶子节点再往回走。（前中后序遍历）——递归、迭代法
- 广度优先遍历：一层一层的去遍历。(层序遍历）——迭代法
二叉树的定义
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x):val(x),left(NULL),right(NULL) {}
};
二叉树的递归遍历
144.前序遍历
//构造递归函数,确定传入的参数,前序遍历，顺序：中左右，传入节点，
void preorder(TreeNode* root, vector<int>& result)
{
if(root==nullptr) return;
//中
result.push_back(root->val);
//左
preorder(root->left,result);
//右
preorder(root->right, result);
}
vector<int> preorderTraversal(TreeNode* root) {
vector<int> result;
preorder(root, result);
return result;
}
145.后序遍历
//递归函数
void backorder(TreeNode* root, vector<int>& result)
{
//1. 定义递归终止条件
if(root==nullptr) return;
//左 右 中
backorder(root->left, result);
backorder(root->right, result);
result.push_back(root->val);
}
vector<int> postorderTraversal(TreeNode* root) {
//数组 ，存储结果
vector<int> result;
backorder(root, result);
return result;
}
94.中序遍历
//中序遍历
void midorder(TreeNode* cur, vector<int>& result)
{
//递归结束
if(cur==nullptr) return;
//左
midorder(cur->left,result);
//中
result.push_back(cur->val);
//右
midorder(cur->right, result);
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> result;
midorder(root, result);
return result;
}
二叉树迭代遍历
前序遍历（迭代法）
vector<int> preorderTraversal(TreeNode* root) {
//迭代法实现前序遍历
//数组 result存储 遍历结果
vector<int> result;
//栈模拟实现递归过程，栈的数据类型是二叉树节点（指针）
stack<TreeNode*> st;
if(root==nullptr) return result;
//root根节点入栈
st.push(root);
//中 左 右
while(!st.empty())
{
//取出栈中元素,将其放入到result数组中
TreeNode* cur = st.top();
st.pop();
result.push_back(cur->val);
//先右后左，出栈顺序为左、右，符合前序遍历逻辑
if(cur->right) st.push(cur->right);
if(cur->left) st.push(cur->left);
}
return result;
}
后序遍历（迭代法）
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
//前序遍历 中左右 -> 中右左-> 翻转reverse -> 左右中
vector<int> result;
stack<TreeNode*> st;
//root为nullptr 返回result
if(root==nullptr) 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 = 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;
}
};
二叉树层序遍历（广度优先搜索）
解题思路：
核心需要记录size，记录的是本层的需要弹出的节点数量
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*> que;
//存储二维数组，最终结果
vector<vector<int>> result;
//1 判断root不为空，将第一个节点加入到队列中
if(root!=nullptr) que.push(root);
//2 遍历终止条件，队列中没有元素，!que.empty();
while(!que.empty())
{
// 3 控制当前节点数量 size ,控制弹出元素的数量
int size = que.size();
// 4 定义一维数组，存放队列中元素,最终结果需要用二维数组显示
vector<int> vec;
//5 遍历队列
for(int i = 0; i<size;i++)
{
// 获取队列中的元素,弹出
TreeNode* node = que.front();
que.pop();
// 存储结果,记录完本层结果
vec.push_back(node->val);
//节点移到下一层
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
//一维数组保存后
result.push_back(vec);
}
return result;
}
};
