1.二維陣列查詢

本題的關鍵就在於二維陣列具有一定的特性：
從左往右，從上往下呈遞增序列。

如果二次遍歷，就失去了這個題目的意義因為複雜度是O(n2)

對於這個矩陣來說，左上角的值a(0,0)一定為最小值，右下角的值a(m,n)一定是最大值，當與target比較完了之後，我們不知道該往哪邊走。因此，可以選取左下角a(m,0)或者右上角a(0,n)開始，這樣如果target比較大，一定往下(上)走，target比較小，一定往左(右)走。

class Solution {
public:
    bool Find(int target, vector<vector<int>
 
 > array) {
        int m = array.size();
        int n = array[0].size();
        if (m == 0 || n == 0)
            return false;
        int i = 0;
        int j = n - 1;
        while ((i < m)&&(j >= 0))
        {
            if (array[i][j] < target)
                ++i;
            else
 
 if (array[i][j] > target)
                --j;
            else
                return true;
        }
        return false;
    }
};

2.替換空格

這題主要是考察，對陣列擴容的時候可以先計算擴容後的大小，比如這題，先計算空格有多少個，然後加上原有字元的個數，就是擴容後的大小。最後插入的時候從後往前操作，可以保證演算法的原地的執行（in place）

此題的擴充套件就是，兩個排好序的數組合併成一個有序陣列，可以考慮先對其中一個數組進行擴容，之後再把另一個數組的值從後往前插入。

class Solution {
public:
    void replaceSpace(char *&str,int length) {
        if(NULL==str)
            return;
        char *p=str;
        int space=0;
        while(*p!='\0')
        {
            if(*p==' ')
                ++space;
            ++p;
        }
        char *copy= (char *)malloc((2*space+length+1)*sizeof(char));
        *(copy+2*space+length)='\0';
        int j=2*space+length-1;
        int i=length-1;
        while(i>=0)
        {
            if(*(str+i)==' ')
            {
                *(copy+j)='0';
                *(copy+j-1)='2';
                *(copy+j-2)='%';
                j-=3;
                --i;
            }
            else
            {
                *(copy+j)=*(str+i);
                --j;
                --i;
            }
        }
        char *tmp=copy;
        copy=str;
        str=tmp;
        cout<<str<<endl;
    }
};

3.從尾到頭列印連結串列

連結串列這個資料結構，如果指標域是單向的，那麼它的迭代也是單向的，也即不能向陣列那樣，隨機的訪問最後一個元素，再往前列印。

解決的方案有很多。最直觀的方法是，從前往後遍歷，然後將遍歷的value壓棧，這樣彈棧的時候就是原連結串列相反的順序。

遞迴是另一種形式，遞迴的呼叫函式使其以連結串列的下一個節點做當前節點，就達到了遍歷的效果，然後在遞迴返回之際列印相應值，就反序了。因為遞迴其實就是函式棧，所以思想跟上一個差不多

class Solution {
private:
    void help(ListNode * head,vector<int>&v)
    {
        if(head!=NULL)
        {
            if(head->next!=NULL)
            {
                help(head->next,v);
            }
            v.push_back(head->val);
        }
    }
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        if(NULL==head)
            return vector<int>();
        vector<int>tmp;
        help(head,tmp);
        return tmp;

    }
};

4.重建二叉樹

此題的擴充套件就是，假設我們現在要序列化一個二叉樹，那麼我們可以儲存其先序和中序的序列，資料到remote端以後，然後再rebuild一下。

先序遍歷序列找到根節點，中序遍歷序列將又通過根節點劃分兩個左右子樹。為了方便快捷的在中序遍歷的序列中找到根節點所在位置，可以用一個map記錄根節點值和索引的key-value對。

此外，在先序遍歷中，要找到子樹根的位置，還必須通過中序遍歷計算劃分之後，左子樹和右子樹的節點個數。因此，我用了4個引數來記錄：

preStart//子樹先序開始
preEnd//子樹先序結束
inStart//子樹中序開始
inEnd//子樹中序結束

遞迴的方式去構建二叉樹，每次都去更新這些數的值

class Solution {
private:
    TreeNode * help(vector<int>&pre,//pre seq
        vector<int>&vin,//in seq
        int preStart,   //pre start idx
        int preEnd,     //pre end idx
        int inStart,    //in start idx
        int inEnd,    //in end idx
        unordered_map<int, int>&index)// map find idx in vin
    {
        if (inStart > inEnd)//
        {
            return NULL;
        }
        //先拿到根節點的值
        int rootval = pre[preStart];//root val
        //建立根節點
        TreeNode * root = new TreeNode(rootval); //root node
        //找到中序遍歷中根節點的索引
        int idx = index[rootval];//root index in vin
        //split vin with idx
        //通過索引計算中序中對左右子數的劃分（計算節點的個數），以便在先序中找到子樹的根
        //遞迴左子樹
        root->left = help(pre, vin, preStart + 1, preStart + idx - inStart, inStart, idx - 1, index);
        //遞迴右子樹
        root->right = help(pre, vin, preStart + idx - inStart + 1, preEnd, idx + 1, inEnd, index);
        return root;
    }
public:
    TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin)
    {
        unordered_map<int, int>index;
        //計算中序遍歷序列中 值和索引的Key-value對
        for (int i = 0; i < vin.size(); ++i)
        {
            index[vin[i]] = i;
        }
        return help(pre, vin, 0, pre.size() - 1, 0, vin.size() - 1, index);

    }
};

5.兩個棧實現佇列

棧是後進先出，first-in-last-out
佇列是先進先出，first-in-first-out

現在由兩個棧，將元素插入到第一個棧中，再逐個彈出壓入第二個棧中，這樣在棧1中先入棧的元素，到了棧2中就越靠近棧頂，然後從棧2中彈棧，就達到了FIFO的效果。

這裡，不是每次彈棧都要講棧1的序列全部壓入棧2，只有當棧2為空的時候才這樣做。

class Solution
{
    public:
        void push(int node)
        {
            stack1.push(node);
        }
        int pop() 
        {
            if(!stack1.empty()||!stack2.empty())
            {
                if(stack2.empty())
                {
                    while(!stack1.empty())
                    {
                        stack2.push(stack1.top());
                        stack1.pop();
                    }
                }
                int t=stack2.top();
                stack2.pop();
                return t;
            }
            return -1;
        }
    private:
        stack<int> stack1;
        stack<int> stack2;
};