leetcode 树

1.binary-tree-postorder-traversal

解答：输出树后序遍历的结果(非递归)。采用先序遍历（把根左右改为根右左），然后reverse一下。

//树的非递归前序遍历（入栈时先压入右子树再压入左子树）
class Solution {
public:
    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> res;
        if(!root)return res;
        stack<TreeNode *> st;
        st.push(root);
        while(st.size()){
            TreeNode *pNode = st.top();
            st.pop();
            res.push_back(pNode->val);
            if(pNode->right)st.push(pNode->right);
            if(pNode->left)st.push(pNode->left);
        }
        return res;
    }
};
//非递归的后序遍历（先压入左子树再压入右子树，最后reverse一下，中右左->左右中）
class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
        vector<int> res;
        if(!root)
            return res;
        stack<TreeNode *> st;
        st.push(root);
        while(st.size()){
            TreeNode *p = st.top();
            st.pop();
            res.push_back(p->val);
            if(p->left)
                st.push(p->left);
            if(p->right)
                st.push(p->right);
            
        }
        reverse(res.begin(),res.end());
        return res;
    }
};
//树的非递归中序遍历（不断把左孩子入栈，每次弹出时检测是否有右孩子有则入栈）
class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> res;
        if(!root)return res;
        stack<TreeNode *> st;
        TreeNode *pNode = root;
        while(st.size()||pNode){
            while(pNode){
                st.push(pNode);
                pNode = pNode->left;
            }
            pNode = st.top();
            st.pop();
            res.push_back(pNode->val);
            pNode = pNode->right;
            
        }
        return res;
    }
};

2. sum-root-to-leaf-numbers

解答：递归结合先序遍历

class Solution {
public:
    int sumNumbers(TreeNode *root) {
        if(!root)return 0;
        int sum=0;
        return preOrder(root,sum);
    }
    int preOrder(TreeNode *root, int sum){
        if(!root)return 0;
        sum = sum*10+root->val;
        if((!root->left)&&(!root->right))return sum;
        else return preOrder(root->left,sum)+preOrder(root->right,sum);
    }
};

 3. binary-tree-maximum-path-sum

依旧是递归的思想，这里加入一个全局变量。

class Solution {
public:
    int Max;
        int maxPathSum(TreeNode *root) {
            Max = INT_MIN;
            maxSum(root);
            return Max;
        }
        int maxSum(TreeNode *root) {
            if(root == NULL)
                return 0;
            int l_Max = max(0, maxSum(root->left));
            int r_Max = max(0, maxSum(root->right));
            Max = max(Max, l_Max + r_Max + root->val);
            return max(l_Max, r_Max) + root->val;
        }
};

4.populating-next-right-pointers-in-each-node

class Solution {
public:
    void connect(TreeLinkNode *root) {
        if(!root)return;
        if(root->left&&root->right)
            root->left->next = root->right;
        if(root->next&&root->right)
            root->right->next = root->next->left;
        connect(root->left);
        connect(root->right);
    }
};

5.populating-next-right-pointers-in-each-node-ii

解答：层次遍历，依次遍历每一层。

class Solution {
public:
    void connect(TreeLinkNode *root) {
        if(!root)return;
        queue<TreeLinkNode *> cur;
        cur.push(root);
        while(cur.size()){
            int len = cur.size();
            for(int i=0;i<len;i++){
                TreeLinkNode *p = cur.front();
                cur.pop();
                if(p->left)cur.push(p->left);
                if(p->right)cur.push(p->right);
                if(i==len-1)p->next=nullptr;
                else p->next=cur.front();
            }
        }
    }
};

 6.balanced-binary-tree

class Solution {
public:
    bool isBalanced(TreeNode *root) {
        if(!root)return 1;
        if(abs(maxDepth(root->left)-maxDepth(root->right))>1)return 0;
        if((!isBalanced(root->left))||(!isBalanced(root->right)))return 0;
        return 1;
    }
    int maxDepth(TreeNode *root){
        if(!root)return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

7. path-sum

class Solution {
public:
    bool hasPathSum(TreeNode *root, int sum) {
        if(!root)return 0;
        if(!root->left&&!root->right)return (root->val==sum)?1:0;
        return (hasPathSum(root->left,sum - root->val)||hasPathSum(root->right,sum - root->val));
    }
};

8. payh-sum-ii

解答：深度优先搜索

class Solution {
public:
    vector<vector<int> > pathSum(TreeNode *root, int sum) {
        vector<vector<int> > res;
        if(!root)return res;      
        vector<int> path;
        dfs(root, sum, res, path);
        return res;
    }
    void dfs(TreeNode *root, int sum, vector<vector<int> > &res, vector<int> &path){
        if(!root)return;
        path.push_back(root->val);
        if(root->val==sum&&!root->left&&!root->right)res.push_back(path);
        dfs(root->left, sum-root->val, res, path);
        dfs(root->right, sum-root->val, res, path);
        path.pop_back();
    }
};

 9. recover-binary-search-tree

思路：涉及二叉树就要想到它前序遍历是递增的。

class Solution {
public:
    TreeNode *pre, *a, *b;
    void swap(int &a, int &b){
        int temp = a;
        a = b;
        b = temp;
    }
    void recoverTreeCore(TreeNode *root) {
        if(root->left)recoverTreeCore(root->left);
        if(pre&&pre->val>root->val){
            if(!a)a = pre;
            b = root;
        }
        pre = root;
        if(root->right)recoverTreeCore(root->right);
    }
    void recoverTree(TreeNode *root) {
        pre = nullptr;
        a = nullptr;
        b = nullptr;
        if(!root)return;
        recoverTreeCore(root);
        if(a&&b)swap(a->val, b->val);
    }
};