二叉树学习与风格不统一的遍历

满二叉树 ：深度为n，节点数为2^n-1；
完全二叉树：除了最底层没填满，其余每层节点数都达到最大值，最下面一层节点都集中在该层左边若干位置；
二叉搜索树：若左子树不空，则左子树上所有节点的值均小于它的根节点的值；若右子树不空，右子树上所有节点的值均大于它的根节点的值；右子树 、左子树均为二叉排序树；
平衡二叉树搜索树：AVL树，它是一颗空树或者左右子树的高度差不多于1；并且左右两个子树都是一颗二叉平衡树；
二叉树存储方式：二叉树可以顺序存储也可以链式存储；顺序存储：父节点为i，左右孩子分别为2i+1,2i+2;
二叉树遍历方式：深度遍历：前序、中序、后序遍历；广度遍历；
二叉树定义：

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

144.二叉树的前序遍历
看了代码随想录上的讲解，如何使用迭代法，首先是使用栈，其实是入栈顺序，那个图一下子解惑了，为什么要右节点先入栈，左节点后入栈，编码如下：

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

94.二叉树 的中序遍历
看了代码随想录，思路就是不断压入左节点，一旦找不到左节点，就是找到对应第一个了，这个时候才开始找右节点，就是左中右的顺序，这个不太好想，与前序遍历还是不太一样；

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

145.二叉树的后序遍历
前序遍历顺序：中 左 右，可以衍生顺序 ：中 右 左；
那么将这个顺序反过来就是 左 右 中；
也是再看代码随想录的时候想起应该怎么做；

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

总结一下，总体都是用栈来做，但是怎么入栈要想一下；
学习了一下加入空节点的解法–统一解法的遍历方法
144.二叉树的前序遍历

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

94.二叉树的中序遍历

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

145.二叉树的后序遍历

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

总结一下：就是每个当前node之后都要加nullptr，看入栈顺序就跟遍历顺序相反。