剑指 第2.3章 数据结构（数组、字符串、链表、树、栈和队列）

数组

二维数组中的查找

题目：
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
思路：
矩阵是有序的，从左下角来看，向上数字递减，向右数字递增，因此从左下角开始查找，当要查找数字比左下角数字大时，
右移；要查找数字比左下角数字小时，上移。（主要是要找到矩阵的一个顶点，从这个顶点出发，沿一个方向变小，沿另一个方向变大。对于此题，左下和右上都是可以的）

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

字符串

替换空格

题目：请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
思路：如果从前向后替换，则后面的部分要多次移动，不可取。因此，最好的做法是，先从前向后计算出有多少字符、字符中有多少空格，从而计算出替换后的长度，然后从后向前替换。而且，要考虑到结尾的‘\0’也需要复制。

class Solution {
public:
    void replaceSpace(char *str,int length) {
        if (str == NULL || length < 0) return;
        int oldLength = strlen(str);
        int newLength = oldLength;
        for (int i = 0; i < oldLength; i++)
            if (str[i] == ' ') newLength += 2;
        if (newLength + 1 > length) return;
        int pOld = oldLength, pNew = newLength;
        while (pOld >= 0 && pNew >= pOld){
            if (str[pOld] == ' '){
                str[pNew--] = '0';
                str[pNew--] = '2';
                str[pNew--] = '%';
            }
            else str[pNew--] = str[pOld];
            pOld--;
        }
        return;
    }
};

链表

从尾到头打印链表

题目：输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
思路：先把链表中的值依次存入vector，再将vector中的元素顺序反转。

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> res;
        ListNode* p = head;
        while(p != nullptr){
            res.push_back(p->val);
            p = p->next;
        }
        int n = res.size(), tmp = 0;
        for (int i = 0, j = n - 1; i < j; i++, j--){
            if (res[i] == res[n - 1 - i]) continue;
            tmp = res[i];
            res[i] = res[n - 1 - i];
            res[n - 1 - i] = tmp;
        }
        return res;
    }
};

也可以用反向迭代器：

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> res;
        ListNode* p = head;
        while(p != nullptr){
            res.push_back(p->val);
            p = p->next;
        }
        return vector<int>(res.rbegin(),res.rend());
    }
};

树

重建二叉树

题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{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 reconBT(pre,0,pre.size()-1,vin,0,vin.size()-1);
    }
private:
    TreeNode* reconBT(vector<int> pre,int startPre,int endPre,vector<int> vin,int startIn,int endIn){
        if (startPre > endPre || startIn > endIn) return nullptr;
        TreeNode* root = new TreeNode(pre[startPre]);
        for(int i = startIn; i <= endIn; i++){
            if (vin[i] == pre[startPre]){
                root->left = reconBT(pre,startPre+1,startPre+i-startIn,vin,startIn,i-1);
                root->right = reconBT(pre,i-startIn+startPre+1,endPre,vin,i+1,endIn);
            }
        }
        return root;
    }
};

栈和队列

用两个栈实现队列

题目：用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：经典的双栈队列问题。一个栈作为压入栈，一个栈作为弹出栈。注意从压入栈向弹出栈倒入元素时必须满足两个条件：第一，弹出栈在倒入元素前是空的，第二，压入栈在倒出元素时要一次性倒完。

class Solution
{
public:
    void push(int node) {
        stack1.push(node);
        return;
    }

    int pop() {
        if (!stack2.empty()){
            int res = stack2.top();
            stack2.pop();
            return res;
        }
        while(!stack1.empty()){
            stack2.push(stack1.top());
            stack1.pop();
        }
        int res = stack2.top();
        stack2.pop();
        return res;
    }

private:
    stack<int> stack1; //spush
    stack<int> stack2; //spop
};