二叉树理论基础

题目分类

二叉树的种类

无数值两种：满二叉树 和 完全二叉树

有数值：二叉搜索树
1.若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值;
2.若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值;
3.它的左、右子树也分别为二叉排序树
有数值：平衡二叉搜索树 AVL（Adelson-Velsky and Landis）它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是棵平衡二叉树。

二叉树的存储方式

链式存储 和顺序存储
链式存储：通过指针把分布在各个地址的节点串联一起。
顺序存储：如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。

二叉树的遍历方式

遍历方式：深度优先遍历 和广度优先遍历
深度优先遍历：先往深走，遇到叶子节点再往回走。前中后序遍历的逻辑其实都是可以借助栈使用递归的方式来实现的。
1.前序遍历（递归法，迭代法）
2.中序遍历（递归法，迭代法）
3.后序遍历（递归法，迭代法）
广度优先遍历：一层一层的去遍历。广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。
1.层次遍历（迭代法）

二叉树的定义

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

二叉树的递归遍历

递归三要素

1.确定递归函数的参数和返回值
2.确定终止条件
3.确定单层递归的逻辑

144.二叉树的前序遍历(opens new window)
145.二叉树的后序遍历(opens new window)
94.二叉树的中序遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> order;
        traversal(root, order);
        return order;
    }
    void traversal(TreeNode* root, vector<int>& order){
        if(root == nullptr)return ;
        order.push_back(root->val);
        traversal(root -> left,order);
        traversal(root -> right,order);
    }
};

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector <int> res;
        traversal(root,res);
        return res;
    }
    void traversal(TreeNode* root, vector<int> & res){
        if(root == nullptr) return ;
        traversal(root -> left, res);
        traversal(root -> right, res);
        res.push_back(root -> val);
    }
};

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        traversal(res, root);
        return res;
    }
    void traversal(vector<int> & res, TreeNode* root){
        if(root == nullptr)return ;
        traversal(res, root -> left);
        res.push_back(root -> val);
        traversal(res, root -> right);
    }
};

二叉树的迭代遍历

144.二叉树的前序遍历(opens new window)
145.二叉树的后序遍历(opens new window)
94.二叉树的中序遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> res;
        if(root == nullptr) return res;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            res.push_back(node -> val);
            if(node -> right)st.push(node -> right);
            if(node -> left)st.push(node -> left);
        }
        return res;
    }
};

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while(cur!= nullptr || !st.empty()){
            if(cur != nullptr){
                st.push(cur);
                cur = cur -> left;
            }else{
                cur = st.top();
                st.pop();
                res.push_back(cur -> val);
                cur = cur -> right;
            }
        }
        return res;
    }
};

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        if(root == nullptr) return res;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            res.push_back(node -> val);
            if(node -> left) st.push(node -> left);
            if(node -> right) st.push(node -> right);
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

统一迭代法

懒得看