JZ1-JZ5

JZ1 二维数组中的查找

//本题暴力，时间复杂度O(mn), 根据题中给的规律：
//每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。
//考虑从数组矩阵右上方切入，如果target小于当前位置左边的数字，左移，否则下移
//那么时间复杂度就到了O(m+n)
class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        if(array.empty()) return false;
        int m = array.size(), n = array[0].size()-1;
        int index = 0;
        while(index < m && n >= 0){
            if(array[index][n] > target){
                n--;
            }
            else if(array[index][n] < target){
                index++;
            }
            else return true;
        }
        return false;
    }
};

JZ2 替换空格

//替换空格，char和string的用法，for(auto& c: s)
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param s string字符串 
     * @return string字符串
     */
    string replaceSpace(string s) {
        // write code here
        string ans;
        for(auto& c: s){
            if(c == ' ') ans+="%20";
            else ans+=c;
        }
        return ans;
    }
};

JZ3 从尾到头打印链表

//返回的是vector<int>,注意是从尾到头，那么反转反转链表和反转数组都行
//为了节省空间，这里选择反转数组，reverse(ret.begin(),ret.end());
/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
         vector<int> ret;
         while (head) {
             ret.push_back(head->val);
             head = head->next;
         }       
         std::reverse(ret.begin(), ret.end());
         return ret;
    }
};

JZ4 重建二叉树

//给出两种不同的遍历顺序vector<int>，然后还原出原数组，注意前、中、后序的区别；
//中序遍历序列的特点是，根节点把数组分成左右两部分，分别属于根节点的左右子树的部分
//用dfs，递归出结果。
//利用中序特性，不断递归划分左右子树，直到nullptr
/**
 * 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* rebuild(vector<int>& pre,int pre_left,int pre_right,vector<int>& vin,int vin_left,int vin_right){
        if(pre_left > pre_right) return nullptr;
        TreeNode* root = new TreeNode(pre[pre_left]);
        int root_index = vin_left;
        while(root_index < vin_right && vin[root_index] != pre[pre_left]){
            root_index++;
        }
        root->left = rebuild(pre,pre_left+1,pre_left+root_index-vin_left,vin,vin_left,root_index-1);
        root->right = rebuild(pre,pre_left+root_index-vin_left+1,pre_right,vin,root_index+1,vin_right);
        return root;
    }
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        return rebuild(pre,0,pre.size()-1,vin,0,vin.size()-1);
    }
};

JZ5 用两个栈实现队列

//FILO  -> FIFO
//不需要将两个栈内的元素倒来倒去，只需要保证在出队列的时候，stack2有元素并且其中的顺序是FIFO即可
class Solution
{
public:
    void push(int node) {
        stack1.push(node);
    }

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

private:
    stack<int> stack1;
    stack<int> stack2;
};