leetcode刷题之树（1）

提到树首先肯定是树的三个遍历即前中后 序遍历。树的遍历可以通过两种方式实现，一种是最常见的最简单递归，一种是借用栈来进行迭代。虽然两者实现的形式不一样，但是两者的思想是一样的。都是有点类似于回溯算法的思想，拿中序遍历来说，中序遍历的顺序是左根右，无论是栈还是递归我们都先遍历到左子树，当遍历完最深层的左子树之后，开始返回最近的父节点遍历右子树，只不过迭代利用了栈的后进先出的特性，对右子树进行了保存。贴代码

递归实现中序遍历

class Solution {
public:
    vector<int>res;
    vector<int> inorderTraversal(TreeNode* root) {
        if(root) {
            inorderTraversal(root->left);
            res.push_back(root->val);
            inorderTraversal(root->right);
        }
        return res;
    }
};

迭代实现中序遍历

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*>s;
        vector<int>res;
        while(root ||s.size())
        {
            while(root)
            {
                s.push(root);
                root=root->left;
            }
            root=s.top();
            s.pop();
            res.push_back(root->val);
            root=root->right;
        }
        return res;
    }
};

在刷二叉搜索树的时候遇到求不同的二叉搜索树的问题，此问题可以用动态规划解决，也可以利用卡塔兰树解决。

其实我们应该叫明安图数。更便于计算的公式定义如下：

递推公式如下：

1.括号化问题。2.出栈次序问题。3.将多边行划分为三角形问题。

2012腾讯实习招聘笔试题
在图书馆一共6个人在排队，3个还《面试宝典》一书，3个在借《面试宝典》一书，图书馆此时没有了面试宝典了，确保三个人都能借到书，求他们排队的总数？

阿里巴巴的笔试题目：说16个人按顺序去买烧饼，其中8个人每人身上只有一张5块钱，另外8个人每人身上只有一张10块钱。烧饼5块一个，开始时烧饼店老板身上没有钱。16个顾客互相不通气，每人只买一个。问这16个人共有多少种排列方法能避免找不开钱的情况出现。

 

 

 

 动态规划题解方法根据上边介绍的递推公式写出。

class Solution {
public:
    int numTrees(int n) {
        vector<int> g(n+1);
        g[1]=1;
        g[0]=1;
        for(int i=2;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
            g[i]+=g[j-1]*g[i-j];
        }
        return g[n];
    }
};

明安图解决

class Solution {
public:
    int numTrees(int n) {
        long c = 1;
        for(int i = 0; i < n; i++)
            c = c * 2 * (2 * i  + 1) /(i + 2);
        return c;
    }
};

知道了中序遍历这道题就可以直接利用迭代的方法秒杀。

 

这道题是让我们去验证父节点是否大于左子结点（a），且小于右子结点(b)。我们肯定是需要遍历这棵树的，中序遍历是先遍历到最深层的左叶子结点，然后就去遍历父节点，这个时候我们要 判断a只需将正在遍历的叶子结点用tmp保存，然后看是否大于等于父节点即可，大于就是返回错误，然后再返回去遍历最近的右子结点，注意这个时候tmp保存的是父节点，所以还是判断tmp是否大于等于右子节点（root->val）。就是tmp始终保存的是上一轮的值，然后拿着tmp和当前的root去比较。代码如下：

/**
 * 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) {
        long tmp=LONG_MIN;
        stack<TreeNode*>s;
        while(root ||s.size()!=0 )
        {
            while(root)
            {
                s.push(root);
                root=root->left;
            }
            root=s.top();
            s.pop();
            if(tmp>=root->val)
            return false;
            tmp=root->val;
            root=root->right;
        }
        return true;
    }
};

 

虽然标记的 这是一道简单的题目，但是我一开始也没有想出来，看是否对称只需要看左子树的左结点和右子树的右结点是否相等，左子树的右结点和右子树的左结点是否相等。

递归代码如下

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

其实通过队列或者栈去迭代思想是一样的

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root==NULL) return true;
        stack<TreeNode*> s;
        s.push(root->left);
        s.push(root->right);
        while(s.size())
        {
            TreeNode* t1=s.top();s.pop();
            TreeNode* t2=s.top();s.pop();
            if(!t1 && !t2) continue;
            if(!t1 || !t2) return false;
            if(t1->val!=t2->val) return false;
            s.push(t1->left);
            s.push(t2->right);
            s.push(t1->right);
            s.push(t2->left);
        }
        return true;
    }
};