【代码随想录】Day 14 二叉树基础（前中后序遍历）

二叉树基础：

满二叉树

满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。

完全二叉树

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

一个典型的例子：

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

二叉搜索树

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

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

平衡二叉搜索树

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

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

C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是log（n），注意我这里没有说unordered_map、unordered_set，unordered_map、unordered_set底层实现是哈希表。

 二叉树存储方式：

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

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

链式存储：

  顺序存储：

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

二叉树的遍历方式

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

这两种遍历是图论中最基本的两种遍历方式，细分为：

• 深度优先遍历（前中后，其实指的是中间节点的遍历顺序）
  • 前序遍历（递归法，迭代法）：中左右
  • 中序遍历（递归法，迭代法）：左中右
  • 后序遍历（递归法，迭代法）：左右中
• 广度优先遍历
  • 层次遍历（迭代法）

栈其实就是递归的一种实现结构，也就说深度优先遍历是可以借助栈使用非递归的方式来实现的。

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

二叉树定义：

链式存储的二叉树节点：

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

二叉树的递归遍历：

递归三要素：

1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

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

第一题

力扣

递归法：

确定参数和返回值：返回值为空，参数为每次递归都需要存的节点值vector，还有节点的地址；

确定终止条件：当节点地址为NULL时；

确定单层递归的逻辑：因为是全序遍历，顺序为中左右，因此单层递归需要将自身节点的值存入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 {
public:
    void preorder(TreeNode* root, vector<int> &res) {
        TreeNode* cur = root;        
        if (cur == nullptr) return;
        res.push_back(cur->val);
        preorder(cur->left, res);
        preorder(cur->right, res);
    }

    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        preorder(root, result);
        return result;
    }
};

迭代法（非递归）：

访问节点和处理节点可以同时进行：

想象成链表做，如果直接存que.top()，再pop掉，那么与二叉树其它节点的联系就断掉了，因此需要先定义一个临时节点存好que.top()：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> que;
        vector<int> result;
        if (root == nullptr) return result;
        que.push(root);
        //中左右
        while (!que.empty()) {
            TreeNode* node = que.top();
            que.pop();
            result.push_back(node->val);
            if (node->right) que.push(node->right); //右孩子节点不为空才入栈
            if (node->left) que.push(node->left); //左孩子节点不为空才入栈
        }
        return result;
    }
};

第二题：

力扣

 递归法：

        postorder(root->left, res);
        postorder(root->right, res);        
        res.push_back(root->val);

迭代法：

访问节点和处理节点可以同时进行： 

前序遍历调换一下入栈顺序后为栈内顺序为中左右，输出的时候翻转一下就行。注意vector的翻转函数：

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

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;        
        vector<int> 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;

    }
};

第三题：

力扣

 递归法：

        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);

迭代法：

访问节点和处理节点不可以同时进行：

思路：先一路往左走直到没有左孩子为止，然后再弹出栈看有没有右孩子，没有再接着弹出，看有没有右孩子，如果有就让右孩子入栈，再一路向左。也就是说左孩子为空弹出自己，右孩子为空继续弹出。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        TreeNode* cur = root;
        
        while (cur != nullptr || !st.empty()) {
            // 找到当前节点的最左节点，并把路径上的节点入栈
            while (cur != nullptr) {
                st.push(cur);
                cur = cur->left;
            }
            
            // 处理栈顶节点
            cur = st.top();
            st.pop();
            result.push_back(cur->val);
            
            // 准备处理右子树
            cur = cur->right;
        }     
        return result;
    }
};

代码中，使用一个 while 循环，确保所有节点都被处理。第一个内部 while 循环找到当前节点的最左节点，并将路径上的所有节点压入栈中。当不能再左下去时，处理栈顶节点，并准备处理它的右子树。因为右子树可能也有左子树，所以在处理完栈顶节点后，将当前节点设置为其右子节点，然后在下一次外部 while 循环中再将右子树的所有左子节点压入栈中。这样就可以保证在处理一个节点之前，其左子树已经完全处理完毕，而右子树则在之后处理。