代码随想录算法训练营D14

D13: 终于可以出去玩了

二叉树:

满二叉树：深度为k，有2^k-1个节点的二叉树

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

二叉搜索树：

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

平衡二叉搜索树：又称为AVL，它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是log(n)

二叉树的定义

链表存储二叉树

struct TreeNode {
    int value;          // 节点存储的数据
    TreeNode* left;     // 指向左子节点的指针
    TreeNode* right;    // 指向右子节点的指针

    // 构造函数初始化节点
    TreeNode(int val) : value(val), left(nullptr), right(nullptr) {}
};

数组存储二叉树

#include <vector>

class BinaryTree {
private:
    std::vector<int> tree;
public:
    BinaryTree(int size) {
        tree.resize(size, -1); // 假设-1表示空节点
    }

    void insert(int index, int value) {
        if (index < tree.size()) {
            tree[index] = value;
        }
    }
};

二叉树的遍历

广度优先（bfs）：逐层遍历

深度优先（dfs）：

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

递归遍历：

递归三部曲：

确定参数：当前节点，存储结果的数组

确定终止条件：当前节点为空时终止

确定递归操作：先存储当前结果，然后递归左孩子，最后递归右孩子

代码如下：

// 前序遍历，中序和后序只需更改操作顺序
void preordertTraversal(TreeNode* cur, vector<int>& vec){
        if(cur==NULL) return;
        vec.push_back(cur->value);
        preordertTraversal(cur->left, vec);
        preordertTraversal(cur->right, vec);
    }

迭代遍历：

前序：

使用一个栈来存储，入栈顺序右左中，这样才能出栈后是中左右。

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

后序：

后序就是在前序的基础上，先入左孩子，再入右孩子，这样出栈是中右左，然后反转结果即可。

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

中序：

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

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(); // 如果当前节点为空，表示左子树已经遍历完成，回到上一个节点
                st.pop(); // 从栈中弹出节点，表示该节点即将被处理
                result.push_back(cur->val); // 将节点值加入结果数组，此时为“中”——中序遍历
                cur = cur->right; // 移动到右子节点，开始遍历右子树
            }
        }
        return result; // 返回中序遍历的结果
    }
};

统一迭代法：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）

                st.push(node);                          // 添加中节点
                st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。

                if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.top();    // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
};

将访问的节点直接加入到栈中，但如果是处理的节点则后面放入一个空节点， 这样只有空节点弹出的时候，才将下一个节点放进结果集。

对于统一迭代法，只需要更改右，左，中的处理顺序，即可实现不同的遍历方式