劍指offer是比較經典的面試題目，我決定在牛客網上做一下，把沒做好的題記錄下來。

1.請實現一個函式，將一個字串中的空格替換成“%20”。例如，當字串為We Are Happy.則經過替換之後的字串為We%20Are%20Happy。

class Solution {
public:
    void replaceSpace(char *str,int length) {
        if(length<=0||str==NULL) return;
        char* temp=str;
        int lenori=0;int num=0;
        while
 
(*temp!='\0'){
            lenori++;
            if(*temp==' ') num++;
            temp++;
        }
        int lennew=num*2+lenori;
        if(lennew>length) return;
        int indexnew=lennew;
        int indexold=lenori;
        while(indexold>=0){
            if(str[indexold]==' '){
                str
 
[indexnew--]='0';
                str[indexnew--]='2';
                str[indexnew--]='%';
            }
            else {
                str[indexnew--]=str[indexold];
            }
            indexold--;
        }

    }
};

2.輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複的數字。例如輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列{4,7,2,1,5,3,8,6}，則重建二叉樹並返回。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        return buildtree(pre,vin,0,pre.size()-1);
    }
    TreeNode* buildtree(vector<int>& pre,vector<int>& vin,int first,int end){
        if(pre.empty()||first>end) return NULL;
        int val=pre.front();
        auto mid=pre.begin();
        pre.erase(mid);
        auto it=vin.begin()+first;
        for(;it!=vin.begin()+end+1;it++){
            if(*it==val) break;
        }        
        TreeNode* root=new TreeNode(val);
        root->left=buildtree(pre,vin,first,it-vin.begin()-1);
        root->right=buildtree(pre,vin,it-vin.begin()+1,end);
        return root;

    }
};

3.輸入一個整數，輸出該數二進位制表示中1的個數。其中負數用補碼錶示。

雖然這道題我ac了，但是還是值得分享一下，主要是竟然連負數也可以不斷地去掉最後一個1，這個演算法還是挺牛逼的。

class Solution {
public:
     int  NumberOf1(int n) {
         //if(n>0){
             int num=0;
             while(n){
                 n=n&(n-1);
                 num++;
             }
         //}
         return num;

     }
};

4.我們可以用2*1的小矩形橫著或者豎著去覆蓋更大的矩形。請問用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形，總共有多少種方法？

class Solution {
public:
    int rectCover(int number) {
        if(number<3) return number;
        int first=1,second=2,val=0;／／斐波那契數列
        for(int i=3;i<=number;i++){
            val=first+second;
            first=second;
            second=val;
        }        
        return val;




    }
};

4.輸入一個矩陣，按照從外向裡以順時針的順序依次打印出每一個數字，例如，如果輸入如下矩陣： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 則依次打印出數字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
發現這種題還是不怎麼會做

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {

        vector<int > res;
        if(matrix.empty()||matrix[0].empty()) return res;
        int m=matrix.size();
        int n=matrix[0].size();
        int c=m>n?(n+1)/2:(m+1)/2;
        int p=m,q=n;
        for(int i=0;i<c;i++,q-=2,p-=2)
        {
            for(int col=i;col<i+q;col++)
                res.push_back(matrix[i][col]);
            for(int row=i+1;row<i+p;row++)
                res.push_back(matrix[row][i+q-1]);
            if(p==1||q==1) break;
            for(int col=i+q-2;col>=i;col--)
                res.push_back(matrix[i+p-1][col]);
            for(int row=i+p-2;row>i;row--)
                res.push_back(matrix[row][i]);
        }
        return res;
    }
};

5.定義棧的資料結構，請在該型別中實現一個能夠得到棧最小元素的min函式。
第二個棧存當前最小值，再次壓進去

#include<algorithm>
class Solution {
public:
    void push(int value) {
        minvalue=std::min(value,minvalue);
        stack1.push(value);
        stack2.push(minvalue);
    }
    void pop() {
        stack1.pop();
        stack2.pop();        
    }
    int top() {
        return stack1.top();
    }
    int min() {
        return stack2.top();
    }
private:
    stack<int> stack1;
    stack<int> stack2;
    int minvalue=INT_MAX;
};

6.輸入一個複雜連結串列（每個節點中有節點值，以及兩個指標，一個指向下一個節點，另一個特殊指標指向任意一個節點），返回結果為複製後複雜連結串列的head。（注意，輸出結果中請不要返回引數中的節點引用，否則判題程式會直接返回空）

這道題的陷阱是 一定要把原來的連結串列恢復原狀，不能損壞原來的連結串列。

/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(!pHead) return pHead;        

        RandomListNode* step=pHead;
        while(step){
            RandomListNode* node=new RandomListNode(step->label);
            RandomListNode* nextnode=step->next;
            step->next=node;
            node->next=nextnode;
            step=nextnode;            
        }

        step=pHead;
        while(step){
            if(step->random)step->next->random=step->random->next;
            else step->next->random=NULL;
            step=step->next->next;

        }

        step=pHead;
        RandomListNode* newhead=new RandomListNode(0);
        RandomListNode* now=newhead;
        while(step){            
            now->next=step->next;
            if(now->next)step->next=now->next->next;//千萬注意，一定要把原來的連結串列恢復原狀，不能損壞原來的連結串列。
            now=now->next;
            step=step->next;
        }

        return newhead->next;




    }
};

7.輸入n個整數，找出其中最小的K個數。例如輸入4,5,1,6,2,7,3,8這8個數字，則最小的4個數字是1,2,3,4,。
這道題就是要調，維護一個vector 存最小的k個數，然後按照順序更新就行。

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        if(k>input.size()) return {};
        vector<int> res(k,0);
        int i=0;
        for(;i<k;i++){
            res[i]=input[i];
        }
        sort(res.begin(),res.end());
        for(;i<input.size();i++){
            int j=0;
            for(;j<k;j++){
                if(input[i]<=res[j])
                    break;
            }
            if(j<k){
                int m=0;
                for(m=k-1;m>j;m--){
                    res[m]=res[m-1];
                }
                res[j]=input[i];
            }
        }
        return res;



    }
};

8.請實現一個函式，用來判斷一顆二叉樹是不是對稱的。注意，如果一個二叉樹同此二叉樹的映象是同樣的，定義其為對稱的。

這道題不難，核心是遞迴函式的輸入時兩個，是左右。左的左，右的右。右的左，左的右。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(!pRoot) return true;
        return solve(pRoot->left,pRoot->right);

    }
    bool solve(TreeNode* left,TreeNode* right){
        if((!left)&&(!right)) return true;
        if((left==NULL)||(right==NULL)) return false;
        if(left->val!=right->val) return false;
        return solve(left->left,right->right)&&solve(left->right,right->left);
    }

};

9.在一個排序的連結串列中，存在重複的結點，請刪除該連結串列中重複的結點，重複的結點不保留，返回連結串列頭指標。 例如，連結串列1->2->3->3->4->4->5 處理後為 1->2->5

這道題最重要的是處理邊界條件，比較消耗時間。經驗就是凡是要考慮->next的屬性，如->next->next或者->next->val的，都要考慮->next存不存在。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        ListNode* newhead=new ListNode(0);
        ListNode* first=pHead;
        ListNode* now=newhead;
        while(first){
            while(first&&first->next&&first->next->val==first->val){
                int mid=first->val;
                while(first&&mid==first->val)
                    first=first->next;
            }
            now->next=first;
            if(first)first=first->next;
            now=now->next;
        }
        return newhead->next;


    }
};