LeetCode

LeetCode树模板

TreeNode

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

先序遍历

void visitALongLeftBranch(TreeNode* x, stack<TreeNode*> &s)
{
    while (x)
    {
        //x->visit();
        s.push(x->right);
        x = x->left;
    }
}

void travPre_3(TreeNode* x)
{
    stack<TreeNode*> s;
    while (true)
    {
        visitALongLeftBranch(x, s);
        if (s.empty()) break;
        x = s.top();
        s.pop();
    }
}

层序遍历

void travLevel()
{
    queue<TreeNode *> q;
    q.push(root);
    while (!q.empty())
    {
        TreeNode *x = q.front();
        q.pop();
        //x->visit();
        if (x->HasLChild()) q.push(x->left);
        if (x->HasRChild()) q.push(x->right);
    }
}

中序遍历

void goAlongLeftBranch(TreeNode *x, stack<TreeNode *> &s)
{
    while (x)
    {
        s.push(x);
        x = x->left;
    }
}

void travIn_2(TreeNode *x)
{
    stack<TreeNode *> s;
    while (true)
    {
        goAlongLeftBranch(x, s);
        if (s.empty()) break;
        x = s.top();
        s.pop();
        //x->visit();
        x = x->right;
    }
}

LeetCode 100 相同的树

 这种递归形式几乎算是树的基本模板，三条件并列的尾递归。

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(NULL==p&&NULL==q)
            return 1;
        if(NULL==p||NULL==q)
            return 0;
        return p->val==q->val && isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
    }
};

LeetCode 101 对称二叉树

先序遍历一次左子树，交换先序遍历的左右子节点顺序遍历一次右子树，比较两次遍历得到的序列。

用不可能值填补NULL在序列中的位置。意外地不慢。

class Solution {
public:
    vector<int> res1;
    vector<int> res2;
    bool isSymmetric(TreeNode* root) {
        if(NULL==root)
            return 1;
        else
        {
            if(NULL!=root->left||NULL!=root->right)
            {
                travPre_l(root->left);
                travPre_r(root->right);
                return equal(res1,res2);
            }
            else 
                return 1;
        }
    }
    void travPre_l(TreeNode* x)
    {
        
         stack<TreeNode*> s;
        while (true)
        {
            visitALongLeftBranch(x, s);
            if (s.empty()) break;
            x = s.top();
            s.pop();
        }
    }
    void travPre_r(TreeNode* x)
    {
         stack<TreeNode*> s;
        while (true)
        {
            visitALongRightBranch(x, s);
            if (s.empty()) break;
            x = s.top();
            s.pop();
        }
    }
    void visitALongLeftBranch(TreeNode* x, stack<TreeNode*> &s)
    {
        while (x)
        {
            res1.push_back(x->val);
            s.push(x->right);
            x = x->left;
        }
        res1.push_back(-10991);
    }
    void visitALongRightBranch(TreeNode* x, stack<TreeNode*> &s)
    {
        while (x)
        {
            res2.push_back(x->val);
            s.push(x->left);
            x = x->right;
        }
        res2.push_back(-10991);
    }
    bool equal(vector<int> &a,vector<int> &b)
    {
        if(a.size()!=b.size())
            return 0;
        for(int i=0;i<a.size();++i)
            if(a[i]!=b[i])
                return 0;
        return 1;
    }
};

更简洁的方法：

递归

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        return isMirror(root,root);
    }
    bool isMirror(TreeNode *t1,TreeNode *t2)
    {
        if (t1 == NULL && t2 == NULL) return 1;
        if (t1 == NULL || t2 == NULL) return 0;
        return (t1->val == t2->val)&& isMirror(t1->right, t2->left)&& isMirror(t1->left, t2->right);
    }
};

尾递归改写为迭代（辅助队列），略。

LeetCode 104 二叉树的最大深度

最僵硬的方法就是毫无意义地遍历一次，单纯为了数层数...慢得出奇...

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int depth=0;
        vector<vector<int>> res;
        vector<int> ans;
        queue<TreeNode*> q;
        q.push(root);
        q.push(NULL);
        while(!q.empty())
        {
            TreeNode* x=q.front();
            q.pop();
            if(x)
            {
                ans.push_back(x->val);
                if (NULL!=x->left) q.push(x->left);
                if (NULL!=x->right) q.push(x->right);
            }
            else
            {
                if(!ans.empty())
                {
                    q.push(NULL);
                    res.push_back(ans);
                    ans.clear();
                    depth++;
                }
            }
        }
        return depth;
    }
};

简洁的递归，BFS和DFS均能解

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

LeetCode 112 路径总和

DFS，简洁...

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

LeetCode 872 叶子相似的树

遍历到叶时加入序列

class Solution {
public:
    bool leafSimilar(TreeNode* root1, TreeNode* root2) {
        vector<int> res1;
        traverse(root1,res1);
        vector<int> res2;
        traverse(root2,res2);
        return res1==res2;
    }
    void traverse(TreeNode* x,vector<int>& res)
    {
        if (NULL == x) return;
        if(!x->left&&!x->right)
            res.push_back(x->val);
        traverse(x->left,res);
        traverse(x->right,res);
    }
};

总结

二叉树作为一种自带递归性质的数据结构，很多时候使用递归可以很让问题变得简单。

设置一个count逐个计数这种做法不仅代码冗长而且效率低下，可以说是非常缺乏递归的思想。

尾递归尽量改写为迭代形式，避免栈溢出。