二叉树相关题目

LeetCode 98. Validate Binary Search Tree(判断是否是二叉搜索树）

思路1：对树进行深度优先遍历，遍历到某个节点是判断该节点的左子树是否为二叉搜索树，右子树是否为二叉搜索树，左子树的最大值是否小于当前节点的值，右子树的最小值是否大于当前节点的值。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if(root == NULL) return true;
        int maxv, minv;
        return dfs(root, maxv, minv);
    }
    
    bool dfs(TreeNode* root, int &maxv, int &minv){
        maxv = minv = root->val;
        if(root->left){
            int nowMaxv, nowMinv;
            if(!dfs(root->left, nowMaxv, nowMinv)) 
                return false;
            if(nowMaxv >= root->val) 
                return false;
            maxv = max(maxv, nowMaxv);
            minv = min(minv, nowMinv);
        }
        if(root->right){
            int nowMaxv, nowMinv;
            if (!dfs(root->right, nowMaxv, nowMinv))
                return false;
            if (nowMinv <= root->val)
                return false;
            maxv = max(maxv, nowMaxv);
            minv = min(minv, nowMinv);
        }
        return true;
    }
};

思路2：对树进行中序遍历，遍历的过程中判断当前值是否大于前一个值。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> st;
        int pre_val;
        bool first_flag = true;
        while(!st.empty() || root!=NULL){
            while(root!=NULL){
                st.push(root);
                root = root->left;
            }
            root = st.top();
            st.pop();
            if(first_flag)
                first_flag = false;
            else if(root->val <= pre_val) 
                    return false;
            pre_val = root->val;
            root = root->right;
        }
        return true;
    }
};

2. LeetCode 101. Symmetric Tree(对称的二叉树）

递归实现

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        return judge(root->left, root->right);
    }
    
    bool judge(TreeNode* root1, TreeNode* root2){
        if(root1==NULL && root2==NULL) return true;
        if(root1==NULL || root2==NULL) return false;
        if(root1->val != root2->val) return false;
        return judge(root1->left, root2->right) &&
               judge(root1->right, root2->left);
     }
};

非递归实现

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root==NULL) return true;
        stack<TreeNode* > lstack, rstack;
        TreeNode* lt = root->left, *rt = root->right;
        while(lt || rt || lstack.size()){
            // 左右子树都不为空
            while(lt && rt){
                lstack.push(lt), rstack.push(rt);
                lt = lt->left, rt=rt->right;
            }
            // 一个为空，一个不为空
            if(lt || rt) return false;
            // 左右子树都为空
            lt = lstack.top(), rt = rstack.top();
            lstack.pop(), rstack.pop();
            if(lt->val != rt->val) return false;
            lt = lt->right, rt=rt->left;
        }
        return true;
    }
};

 3. LeetCode 297 Serialize and Deserialize Binary Tree(二叉树的序列化）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        string ans = "";
        pre_order(root, ans);
        return ans;
        
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        int cur=0;
        return decode(cur, data);
    }
    
    void pre_order(TreeNode* root, string& s){
        if(root == NULL){
            s += ",";
            return;
        }
        s += to_string(root->val) + ",";
        pre_order(root->left, s);
        pre_order(root->right, s);
    }
    
    TreeNode* decode(int &cur, string &data){
        if(data[cur] == ','){
            cur++;
            return NULL;
        }
        int next = data.find(',', cur);
        int val = stoi(data.substr(cur, next-cur));
        TreeNode* node = new TreeNode(val);
        cur = next + 1;
        node->left = decode(cur, data);
        node->right = decode(cur, data);
        return node;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.serialize(root));