代码随想录day14

        梳理关于二叉树的一些知识。

1.二叉树的种类

（1）满二叉树

        如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。

（2）完全二叉树

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

（3）搜索二叉树

        二叉搜索树是一个有序树。二叉搜索树的中序遍历是一个有序序列。

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

（4） 平衡二叉树

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

        判断是否是平衡二叉树：

class Solution {
public:
    int heigh(TreeNode* root){
        //求二叉树的树高
        if(root==nullptr) return 0;
        int lh=heigh(root->left)+1;
        int rh=heigh(root->right)+1;
        return max(lh,rh);
    }
    bool isBalanced(TreeNode* root) {
        if(root==nullptr) return true;
        int left=heigh(root->left);
        int right=heigh(root->right);
        //判断根节点与左右子树均满足平衡条件
        return abs(left-right)<=1&&isBalanced(root->left)&&isBalanced(root->right);
    }
};

2.二叉树的存储方式

（1）链式存储

        数据域中有：节点的值、指向左指针的指针、指向右孩子的指针

 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };

（2）顺序存储

        顺序存储其实就是用数组来存储二叉树，一个节点的左孩子下标为2*i+1，右孩子下标为2*i+2。

 3.二叉树的遍历方式

（1）中序

        递归法：

void inorder(struct TreeNode* root, int* res, int* resSize) {
    if (!root) {
        return;
    }
    inorder(root->left, res, resSize);
    res[(*resSize)++] = root->val;
    inorder(root->right, res, resSize);
}

int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    int* res = malloc(sizeof(int) * 501);
    *returnSize = 0;
    inorder(root, res, returnSize);
    return res;
}

        迭代法：利用一个栈暂存节点

         一路向左遍历，边走边入栈，根、左，当走到最左边时，开始出栈，每次访问栈顶元素，再把栈顶元素的右子树入栈

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        //一路向左走，边走边入栈，根、左，当走到最左边时，开始出栈，每次访问栈顶元素，再把栈顶元素的右子树入栈
        if(root==nullptr) return {};
        TreeNode* n=root;
        vector<int> ans;
        stack<TreeNode*> ss;
        ss.push(n);
        n=n->left;
        while(!ss.empty()||n!=nullptr){
            if(n!=nullptr){
                ss.push(n);
                n=n->left;
            }else{
                n=ss.top();
                ss.pop();
                ans.push_back(n->val);
                n=n->right;
            }
        }
        return ans;
    }
};

（2） 先序

        递归法：

void inorder(struct TreeNode* root, int* res, int* resSize) {
    if (!root) {
        return;
    }
    res[(*resSize)++] = root->val;
    inorder(root->left, res, resSize);
    inorder(root->right, res, resSize);
}

        迭代法： 

        先压入根节点，最先弹出的是根节点，然后先压入右孩子，再压入左孩子，这样出栈的时候左孩子先出栈，右孩子后出栈。

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ans;
        if(root==nullptr){
            return ans;
        }
        stack<TreeNode*> ss;
        TreeNode* n=root;
        ss.push(root);
        while(!ss.empty()||n!=nullptr){
            while(n!=nullptr){
                n=ss.top();
                ss.pop();
                ans.push_back(n->val);
            }
            //注意先压入右孩子，再压入左孩子，这样出栈的时候左孩子先出栈
            if(n->right!=nullptr){
                ss.push(n->right);
            }
            if(n->left!=nullptr){
                ss.push(n->left);
            }
        }
        return ans;
    }
};

（3）后序

        递归法：

void inorder(struct TreeNode* root, int* res, int* resSize) {
    if (!root) {
        return;
    }
    inorder(root->left, res, resSize);
    inorder(root->right, res, resSize);
    res[(*resSize)++] = root->val;
}

        迭代法：

         现将所有左孩子压入栈中，然后将右孩子也压入栈中，然后输出到数组中之前要先判断是否右孩子为空或者已经被遍历过了，用一个prev指针指向上一个被访问的节点。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        if(root==nullptr) return ans;
        stack<TreeNode*> stk;
        TreeNode* prev=nullptr;//指向前驱节点
        while(root!=nullptr||!stk.empty()){
            while(root!=nullptr){
                //将左孩子全部压入栈
                stk.push(root);
                root=root->left;
            }
            root=stk.top();//先出最左节点
            stk.pop();
            if(root->right==nullptr||root->right==prev){//若无右孩子或者右孩子已经遍历过了，才会将当前节点输出
                ans.push_back(root->val);
                prev=root;
                root=nullptr;//当前左右孩子以及根节点都已经访问完了，下一次循环要取栈中国其他的节点
            }else{
                //将右孩子全部压入栈
                stk.push(root);
                root=->right;
            }
        }
    }
};

（4）层序

        借助一个辅助队列进行遍历。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> ans;
        if(root==nullptr) return ans;
        que.push(root);
        while(!que.empty()){
            int cursize=que.size();//记录当前层有几个节点
            vector<int> temp;
            for(int i=0;i<cursize;++i){
                TreeNode* cur=que.front();
                que.pop();
                temp.push_back(cur->val);
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            ans.push_back(temp);
        }
        return ans;
    }
};