剑指offer

64题：1+2+…+n

思路一：
使用空间

> class Solution {
public:
    int sumNums(int n) {
        bool a[n][n+1];
        return sizeof(a)>>1;
    }
};

思路2：使用递归

10题：正则表达式匹配

思路一：使用动态规划，理解为搜索题，动态规划就是记录了搜索结果避免重复搜索

思路二：直接匹配

class Solution {
public:
    bool match(char* s, char* p) {
        if (!*p) return !*s;
        if (*(p + 1) != '*') 
            return (*s == *p || (*p == '.' && *s != '\0')) ? match(s + 1, p + 1) : false; 
        else 
            return *s == *p || (*p == '.' && *s != '\0') ? match(s, p + 2) || match(s + 1, p)||match(s+1,p+2) : match(s, p + 2);
           
    }
    bool isMatch(string s, string p) {
        return match(s.data(), p.data());

    }
};

分情况，下一个是否是*

29题：顺时针打印矩阵

固定上下左右四个点！！！使用while叠加for循环

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> result;
        if(matrix.size()==0||matrix[0].size()==0) return result;
        int m=matrix.size(),n=matrix[0].size();
        int left=0,right=n-1,top=0,bottom=m-1;
        while(left<=right&&top<=bottom){
            for(int i=left;i<=right;i++){
                result.push_back(matrix[top][i]);
            }
            for(int j=top+1;j<=bottom;j++){
                result.push_back(matrix[j][right]);
            }
            if(top<bottom&&left<right){
            for(int i=right-1;i>=left;i--){
                result.push_back(matrix[bottom][i]);
            }
            for(int j=bottom-1;j>top;j--){
                result.push_back(matrix[j][left]);
            }
            }
            left++;
            right--;
            top++;
            bottom--;
        }
        return result;

    }
};

40题：最小的K个数

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        sort(arr.begin(),arr.end());
        int m=arr.size();
        if(k>=m) return arr;
        vector<int> result;
        for(int i=0;i<k;i++){
            result.push_back(arr[i]);
        }
        return result;


    }
};

07：重建二叉树

注意下标，也可以使用map哈希表实现快速中序查找

/**
 * 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:
    TreeNode* build(vector<int>& preorder,int i,int j,vector<int>& inorder,int l,int r){
        if(preorder.size()==0||inorder.size()==0||i>j||l>r) return NULL;
        TreeNode* node=new TreeNode(0);
        node->val=preorder[i];
        int index=0;
        for(int k=l;k<=r;k++){
            if(inorder[k]==preorder[i])
            index=k;
        }
        node->left=build(preorder,i+1,index-l+i,inorder,l,index-1);
        node->right=build(preorder,index-l+i+1,j,inorder,index+1,r);
        return node;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size()==0||inorder.size()==0) return NULL;
        TreeNode* root=build(preorder,0,preorder.size()-1,inorder,0,inorder.size()-1);
        return root;
    }
};