二叉树操作

问题0:      二叉树的非递归遍历方法

问题1:　　判断一颗二叉树是否为二叉查找树.

问题2:　　判断两个二叉树是否相同

问题3:      判断一棵树是否为平衡树

问题4:      寻找二叉树的最大和最短简单路径长度

问题5:      二叉树上简单路径的长度问题

解答0:

　　[0.1]前序.使用栈,访问节点后先压入右儿子,再压入左儿子即可.

vector<int> preorderTraversal(TreeNode *root){
    stack<TreeNode*> st;
    st.push(root);
    vector<int> res;
    
    TreeNode *curr;
    while(!st.empty()){
        curr = st.top();
        st.pop();

        if(curr){
            res.push_back(curr->val);
            st.push(curr->right);
            st.push(curr->left);
        }
    }

    return res;
}

　　[0.2]中序遍历.使用一个栈,将访问过的节点压入栈中.

vector<int> inorderTraversal(TreeNode *root){
    stack<TreeNode*> st;
    vector<int> res;

    TreeNode *curr=root,*top;
    while(!st.empty() || curr){
        if(curr){
            st.push(curr);
            curr = curr->left;
        }else{
            curr = st.top();
            st.pop();
            res.push_back(curr->val);
            curr = curr->right;
        }
    }

    return res;
}

　　[0.3]

　　方法1.后序遍历.访问左儿子前记录本节点,当再次取出节点时,存在其右儿子有没有被访问过的问题.通过记录前驱节点来辅助判断(前驱节点只在特定地点才更新).

    vector<int> postorderTraversal(TreeNode *root) {
        stack<TreeNode*> st;
        vector<int> res;
    
        TreeNode *curr=root,*prev=root,*top;
        while(!st.empty() || curr){
            if(curr){
                st.push(curr);
                curr = curr->left;
            }else{
                curr = st.top();
    
                if(prev==curr->right || curr->right==NULL){
                    st.pop();
    
                    res.push_back(curr->val);
                    prev = curr;
                    curr = NULL;
                }else{
                    curr = curr->right;
                }
            }
        }
        return res;
    }

　　方法2:使用两个栈,一个记录TreeNode*,另一个记录这个节点所对应的剩余访问次数.

　　　　   当剩余访问次数为2时,将剩余次数减少为1,并访问其左儿子;

　　　　　当剩余访问次数为1时,将剩余次数减少为0,并访问其右儿子;

　　　　   当剩余访问次数为0时,访问本节点.

 　　[0.4]层次遍历. 使用队列.

解答1:

　　[1.1]首先中序遍历记录节点,然后判断整个记录是否递增.

    void inorder(TreeNode *root, vector<int>& v){
        if(root){
            inorder(root->left,v);
            v.push_back(root->val);
            inorder(root->right,v);
        }
    }
    
    bool isAscend(vector<int>& v){
        int len = v.size();
        int i=0;
        while(i<len-1){
            if(v[i] >= v[i+1])
                return false;
            i++;
        }
        return true;
    }

    bool isValidBST(TreeNode *root) {
        vector<int> v;
        inorder(root,v);
    
        return isAscend(v);
    }

　　　[1.2].通过观察可以发现, 方法[1.1]的比较过程就是将每个节点与其前驱节点的值作比较.那么这个比较操作能放在深搜的过程中完成吗? 

    bool isValidBST(TreeNode *root) {
        TreeNode *curr = root,*prev = NULL;
        stack<TreeNode*> st; 
    
        while(!st.empty() || curr){
            if(curr){
                st.push(curr);
                curr = curr->left;
            }else{
                curr = st.top();
                st.pop();
                if(prev){
                    if(prev->val >= curr->val)
                        return false;
                }
                prev = curr;
                curr = curr->right;
            }
        }
    
        return true;
    }

　　[1.3]使用子树中节点的左右边界来辅助进行判断.

    bool err;

    pair<int, int> dfs(TreeNode *t){
        pair<int, int> l, r;
        int lbound = t->val, rbound = t->val; // 节点t的子树中节点的左右权值边界
        if (t->left){
            l = dfs(t->left);
            if (l.second >= t->val) err = true;
            lbound = l.first;//左边界为左子树的左边界
        }
        if (t->right){
            r = dfs(t->right);
            if (r.first <= t->val) err = true;
            rbound = r.second;//右边界为右子树的右边界
        }
        return make_pair(lbound, rbound);
    }

    bool isValidBST(TreeNode *root) {
        if (root == NULL) return true;
        err = false;
        dfs(root);
        return !err;
    }

解答2:

　　[2.1]可通过同步的遍历来解决.

bool isSameTree(TreeNode *p,TreeNode *q){
    if(p==NULL && q==NULL)
        return true;
    return (p && q && p->val==q->val && isSameTree(p->left,q->left) && isSameTree(p->right,q->right));
}

解答3:

　　[3.1]递归方法

    int check(TreeNode *root,bool& flag){
        int l = 0,r = 0;
        if(flag && root && root->left)
            l = check(root->left,flag) + 1;
        if(flag && root && root->right)
            r = check(root->right,flag) + 1;
        if(flag)
            flag = (abs(l-r)<=1);
        return l>r?l:r;
    }

    bool isBalanced(TreeNode *root){
        bool flag = true;
        check(root,flag);
        return flag;
    }

　　[3.2]迭代方法

解答4:　

int maxDepth(TreeNode *root){
        if(root==NULL)
            return 0;
        return max(maxDepth(root->left),maxDepth(root->right)) + 1;
} 

int minDepth(TreeNode *root){
    if(root==NULL)
        return 0;
    if(root->left==NULL && root->right==NULL)
        return 1;
    if(root->left==NULL)
        return minDepth(root->right)+1;
    else if(root->right==NULL)
        return minDepth(root->left)+1;
    else
        return min(minDepth(root->left),minDepth(root->right))+1;
}

解答5:

　　检测特定长度的存在性.

bool hasPathSum(TreeNode *root,int sum){
    if(root==NULL)
        return false;
    if(root->left==NULL && root->right==NULL)
        return sum==root->val;
    if(root->left && hasPathSum(root->left,sum-root->val))
        return true;
    if(root->right && hasPathSum(root->right,sum-root->val))
        return true;
    return false;
}    

　　记录特定长度的路径

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

vector<vector<int> > pathSum(TreeNode *root, int sum) {
    vector<vector<int> > res;
    vector<int> path;
    dfs(root,sum,path,res);
    return res;
}

　　

参考

---

　　lycc的github代码