【劍指offer]1-4

題目一

二維數組查找

在一個二維數組中（每個一維數組的長度相同），每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函數，輸入這樣的一個二維數組和一個整數，判斷數組中是否含有該整數。

class Solution //二維數組查找
{
public:
    bool Find(int target, vector<vector<int> > array)
    {
        int rows = array.size();//行
        int cols= array[0].size();//列
        int i = rows - 1;
        int j = 0;
        while (i >= 0 && j < cols)
        {
            if (array[i][j] > target)
            {
                i--;
            }
            else if (array[i][j] < target)
            {
                j++;
            }
            else
                return true;
        }
        return false;

    }
};

題目二

空格替換

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

void replaceSpace(char *str, int length) {//空格替換
    int count = 0;
    for (int i = 0; i<length; i++){
        if (str[i] == ' ')
            count++;
    }
    for (int i = length - 1; i >= 0; i--){
        if (str[i] != ' '){
            str[i + 2 * count] = str[i];
        }
        else{
            count--;
            str[i + 2 * count] = '%';
            str[i + 2 * count + 1] = '2';
            str[i + 2 * count + 2] = '0';
        }
    }
}

題目三

從頭到尾打印鏈表

輸入一個鏈表，按鏈表值從尾到頭的順序返回一個ArrayList。

struct ListNode { //鏈表數據結構
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {

        }   
};

vector<int> printListFromTailToHead(ListNode* head)//反向輸出鏈表數據
    {
        stack<int> s;
        while (head!=NULL)
        {
            s.push(head->val);
            head = head->next;
        }
        vector<int> array;
        while(!s.empty())
        {
            array.push_back(s.top());
            s.pop();
        }
        return array;
    }

題目四

二叉樹的恢復

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

struct TreeNode {//二叉樹數據結構
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin)// 復原二叉樹
    {
        int inlen = vin.size();
        if (inlen == 0)
        {
            return NULL;
        }
            vector<int> left_pre, right_pre, left_vin, right_vin;     
            //創建根節點，根節點肯定是前序遍歷的第一個數
            TreeNode* head = new TreeNode(pre[0]);
            int gen = 0;//找到中序遍歷根節點所在位置,存放於變量gen中
            for (int i = 0; i < inlen; i++)
            {
                if (vin[i] == pre[0])
                {
                    gen = i;
                    break;
                }
            }       
            //對於中序遍歷，根節點左邊的節點位於二叉樹的左邊，根節點右邊的節點位於二叉樹的右邊
            for (int i = 0; i < gen; i++)//利用上述這點，對二叉樹節點進行歸併
            {
                left_vin.push_back(vin[i]);
                left_pre.push_back(pre[i + 1]);//前序第一個爲根節點
            }
            for (int i = gen + 1; i < inlen; i++)
            {
                right_vin.push_back(vin[i]);
                right_pre.push_back(pre[i]);
            }
            head->left = reConstructBinaryTree(left_pre, left_vin);//遞歸，再對其進行上述所有步驟，即再區分子樹的左、右子樹，直到葉節點
            head->right = reConstructBinaryTree(right_pre, right_vin);
            return head;    
    }