leetcode 91-120记录

91Decode ways （medium）

这道题将数字字符串解码成字母字符串
主要考虑大家的考虑是否全面。
（1）当s[i]==0
s[i-1]<3
s[i-1]>=3 返回0
(2)当s[i]==1 || (s[i]==2 && s[i-1]<=6)
(3)其他

92 reverse Linked List II（medium）

这道题比较简单

93restore IP address(medium)

转化为IP地址，也就是4个数。根据对每个数分配几个数进行遍历
当前第i个数取n个数，判断是否合理：4-i<=len-i<=3(4-i)
也需要判断截取得到的数字是否合理

94binary tree inorder traversal (medium)

（1）可以采用递归的方法
（2）也可以采用stack存储当前访问结点，继续左孩子遍历，直到NULL。弹出stack，访问其右孩子

95unique binary search tree II(medium)（看看）

思路：结点的值从start到end，当前根结点的值可以其中任意一个值，也就将这些数分为两类，一类为左子树上的值，一类为右子树上的值

 vector<TreeNode*> generateTrees(int n) {
        vector<TreeNode*> results=createTree(1,n);
        return results;
    }

    vector<TreeNode*> createTree(int start, int end)
    {
        vector<TreeNode*> results;
        if(start>end)
        {
            return results;
        }

        if(start==end)
        {
            TreeNode * root = new TreeNode(start);  
            results.push_back(root);
            return results;
        }
        for(int k=start;k<=end;++k)
        {
            vector<TreeNode *> lresult= createTree(start,k-1);  
            vector<TreeNode *> rresult= createTree(k+1,end);  
            if(lresult.size()==0)
            {
                for(int j=0;j<rresult.size();++j)
                {
                    TreeNode * root = new TreeNode(k);  
                    root->right = rresult[j];  
                    results.push_back(root); 
                }
            }
            else if(rresult.size()==0)
            {
                for(int i=0;i<lresult.size();++i)
                {
                    TreeNode * root = new TreeNode(k);  
                    root->left = lresult[i];  
                    results.push_back(root); 
                }
            }
            else
            {
                for(int i=0;i<lresult.size();i++)  
                {  
                    for(int j=0;j<rresult.size();j++)  
                    {  
                        TreeNode * root = new TreeNode(k);  
                        root->left = lresult[i];  
                        root->right = rresult[j];  
                        results.push_back(root);  
                    }  
                }
            }
        }
        return results;
    }

96unique binary search tree (medium)

int numTrees(int n) {

        if(n<0)
        return 0;
        if(n<=1)
            return 1;
         int dp[n+1];   
         dp[0]=1;
         dp[1]=1;
         for(int i=2;i<=n;++i)
         {
             dp[i]=0;
            for(int j=0;j<i;++j)
            {
                dp[i]+=dp[j]*dp[i-j-1];
            }
         }
         return dp[n];
    }

97 interleaving string (hard)

98 validate binary search tree (medium)

比较简单

bool check(TreeNode* node, long long minval, long long maxval)
    {
        if(node==NULL)
            return true;
        return node->val>minval && node->val<maxval && check(node->left,minval,node->val) && check(node->right,node->val,maxval);
    }
    bool isValidBST(TreeNode* root) {
        check(root,(long long)INT_MIN-1,(long long)INT_MAX+1);
    }

99 recover binary search tree （hard)

100 same tree (easy)

题意：判断两个二叉树是否相同
思路：采用递归判断，如果当前节点值相同，且左子树相同，右子树也相同，则两个树是same tree

101 symmetric tree (easy)

跟上一题类似，区别在于a的左子树和b的右子树要相同，a的右子树和b的左子树要相同

bool isSameTree(TreeNode *p, TreeNode *q) {  
        // Start typing your C/C++ solution below  
        // DO NOT write int main() function  
        if (p == NULL && q == NULL)  
            return true;  
        else if (p == NULL || q == NULL)  
            return false;  
        return p->val == q->val && isSameTree(p->left, q->right)  
            && isSameTree(p->right, q->left);  
    }  
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)
            return true;
        return isSameTree(root->left,root->right);
    }

102 binary tree level order traversal (easy)

题意：按层遍历
利用一个队列实现，将现在遍历的第i层的结点加入到vector中，将i+1层的结点加入到队列当中

103 binary tree zigzag level order traversal (medium)

easy

104 maximum depth of binary tree (easy)

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

105 construct binary tree from preorder and inorder traversal (medium)

思路：这道题可以自己先画一棵树，写出它的先序遍历和中序遍历，发现其规律，即：先序遍历第一个结点值是当前树的根节点值，可以相对应的将中序遍历分为左右两颗子树

利用这种规律，通过递归的方法就可以实现代码了

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {

       if(preorder.size()==0)
                return NULL;
            if(preorder.size()==1)
            {
                TreeNode *root=new TreeNode(preorder[0]);
                return root;
            }
        TreeNode *result=BuildSubtree(preorder,0,preorder.size()-1,inorder,0,inorder.size()-1);
        return result;
    }

    TreeNode* BuildSubtree(vector<int> &preorder,int pbegin,int pend,vector<int> &inorder,int ibegin,int iend)
    {
        if(pbegin>pend)
            return NULL;
        if(pbegin==pend)
            return new TreeNode(preorder[pbegin]);

        int i=ibegin;
        while(preorder[pbegin]!=inorder[i])
        {
            i++;
        }
        i=i-ibegin;
        TreeNode *lefttree=BuildSubtree(preorder,pbegin+1,pbegin+i,inorder,ibegin,ibegin+i-1);
        TreeNode *righttree=BuildSubtree(preorder,pbegin+1+i,pend,inorder,ibegin+i+1,iend);
        TreeNode *root=new TreeNode(preorder[pbegin]);
        root->left=lefttree;
        root->right=righttree;
        return root;

    }
};

106 construct binary tree from inorder and postorder traversal (medium)

思路：这道题可以自己先画一棵树，写出它的后序遍历和中序遍历，发现其规律，即：后序遍历中最后一个结点是当前树的根节点，可以相对应的将中序遍历分为左右两颗子树

107 binary tree level order traversal II (easy)

按层遍历，将所有的结点按层放入到vector中，同时也记录下来每一层的最后一个结点的下标。 对vector遍历，根据记录的下标

108 convert sorted array to binary search tree (medium)

题意：将一个排序的数组转化为一个平衡二叉搜索树
采用递归的方法，取中间元素作为子树的根节点，数组左边元素建立成左子树，数组右边元素建立成右子树

109 convert sorted list to binary search tree (medium)

题意：将排序的链表转化为平衡二叉搜索树
与上一题的方法类似

110 balanced binary tree (easy)

通过求出左子树和右子树的高度，如果两者差值大于1，返回false。高度差小于等于1，返回true

111 minmum depth of binary tree (easy)

求出从根节点到叶节点的最短深度

int minDepth(TreeNode* root) {
        if(root==NULL)
            return 0;
        int l=minDepth(root->left);
        int r=minDepth(root->right);
        if(l==r)
            return l+1;
        if(l==0)
            l=INT_MAX;
        if(r==0)
            r=INT_MAX;

        return min(r,l)+1;
    }

112 path sum (easy)

题意：给定一棵二叉树和一个和，判断是否有从根节点到叶结点的路径和等于给定的和

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

       sum=sum-root->val;
        return(hasPathSum(root->left,sum) || hasPathSum(root->right,sum));
    }

113 path sum II (medium)

跟上一题类似，区别在于要记录遍历的结点值

114 flatten binary tree to linked list (medium)

思路：将二叉树变成一个链表状的结构
解题思路：这道题中要用到stack数据结构，遍历过程中，将结点的右孩子入栈，遍历左孩子，直到遍历的结点没有左孩子，将这个结点的右孩子入栈。修改指针，将遍历的树变成一棵只有左孩子的树。一直持续这个过程，直到栈为空。然后将左侧树变成一棵右侧树

void flatten(TreeNode* root) {
        if(!root)
            return;
        stack<TreeNode*> treestack;
        TreeNode *node;
        node=root;
        TreeNode *head=new TreeNode(0);
        TreeNode *p;
        p=head;
        treestack.push(root);
        while(!treestack.empty())
        {
            node=treestack.top();
            treestack.pop();
            p->left=node;
            while(node->left)
            {
                if(node->right)
                    treestack.push(node->right);
                node=node->left;

            }
            if(node->right)
                treestack.push(node->right);
            p=node;//将这棵二叉树变成左侧树
        }

        p=root;
        while(p->left)
        {
            p->right=p->left;
            p->left=NULL;
            p=p->right;
        }
        p->right=NULL;
    }
};

115 distinct subsequences (hard)

116 populating next right pointers in each node (mdeium)

题意：将同一层的结点进行处理，即可对每层进行顺序遍历，加入一个新的指针项

解题思路：就是用一个队列存储每层遍历的结点，并对指针进行修改即可

117 populating next right pointers in each node II (hard)

118 pascal’s triangle (easy)

题意：给定行数，输出杨辉三角
arr[i][j]=arr[i-1][j-1]+arr[i-1][j]

119 pascal’s triangle II (easy)

题意：求出指定行的杨辉三角
思路一：可以采用118题的思路，逐行求解出结果
思路二：思想是一样的，但是占用的空间为n+1.

vector<int> getRow(int rowIndex) {
        vector<int> result(1,1);
            result.resize(rowIndex+1);
            for(int i=0;i<rowIndex;++i)
            {
                result[i+1]=1;
                for(int j=i;j>0;j--)
                {
                    result[j]=result[j]+result[j-1];
                }
            }
            return result;
    }

120 triangle (medium)

求路径和最小，采用动态规划的方法
triangle[i][j]=triangle[i][j]+min(triangle[i-1][j-1]+triangle[i-1][j])
这个公式适用一般情况，当j==0 || j==triangle[i].size()-1 不存在两种情况