剑指offer(1-10)编程题

1. 二维数组中的查找
2. 替换空格
3. 从尾到头打印链表
4. 重建二叉树
5. 用两个栈实现队列
6. 旋转数组的最小数字
7. 斐波那契数列
8. 跳台阶
9. 变态跳台阶
10. 矩形覆盖

1 .在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

class Solution{
public:
    bool Find(int target,vector<vector<int>>& matrix){
        if(matrix.empty()) return false;
        bool found = false;
        int m = matrix.size();
        int n = matrix[].size();
 
        int row = ;
        int col = n -;
 
        while(row < m && col >= ){
            if(matrix[row][col] == target){
                found = true;
                break;
            }else if (target > matrix[row][col]){
                row++;
            }else {
                col--;
            }
        }
        return found;
    }
};

2.请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

class Solution {
public:
    void replaceSpace(char *str, int length) {
        int spaceCount = ;
        for (int i = ; i < length; i++) {
            if (str[i] == ' ') {
                spaceCount++;
            }
        }
        if (spaceCount == )
            return;
        int p = length - ;
        int q = length + spaceCount *  - ;
 
        while (p < q) {
            if (str[p] != ' ') {
                str[q--]=str[p--];
            }else{
                p--;
                str[q--] = '';
                str[q--] = '';
                str[q--] = '%';
            }
        }
        str[length+spaceCount*] = '\0';
    }
};

3.输入一个链表，从尾到头打印链表每个节点的值。

class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> res;
        stack<int> stack;
        ListNode* p = head;
        while(p != nullptr){
            stack.push(p->val);
            p = p->next;
        }
        while(!stack.empty()){
            res.push_back(stack.top());
            stack.pop();
        }
        return res;
    }
};

4.输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{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) {
        if (pre.empty()) return nullptr;
        TreeNode* root = new TreeNode(pre[]);
        vector<int> leftPre, leftVin;
        vector<int> rightPre, rightVin;
 
        for (int i = ; i < vin.size(); i++) {
            if (vin[i] != pre[]) {
                leftVin.push_back(vin[i]);
                leftPre.push_back(pre[i + ]);
            }else{
                break;
            }
        }
 
        int leftSize = leftVin.size();
        for (int i = leftSize+; i < vin.size(); i++) {
            rightVin.push_back(vin[i]);
            rightPre.push_back(pre[i]);
        }
 
        root->left = reConstructBinaryTree(leftPre, leftVin);
        root->right = reConstructBinaryTree(rightPre, rightVin);
 
        return root;
    }
};

5.用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

class Solution {
public:
    void push(int node) {
        stack1.push(node);
    }
 
    int pop() {
        int res;
        if (stack2.empty()) {
            while (!stack1.empty()) {
                stack2.push(stack1.top());
                stack1.pop();
            }
        }
        if (stack2.empty()) {
            return -; // no data
        } else {
            res = stack2.top();
            stack2.pop();
        }
        return res;
    }
 
private:
    stack<int> stack1;
    stack<int> stack2;
};

6.把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
    输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
    例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
    NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int n = rotateArray.size();
        if (n == ) return ;
        if (n == ) return rotateArray[];
 
        int minVal = -;
        for (int i = ; i < n; i++) {
            if (rotateArray[i] < rotateArray[i - ])
                minVal = rotateArray[i];
        }
        if (minVal == -) {
            minVal = rotateArray[];
        }
        return minVal;
    }
};

7.大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。n<=39

class Solution {
public:
    int Fibonacci(int n) {
        if(n == ) return ;
        if(n == ) return ;
        int fibnMinusOne = ;
        int fibnMinusTwo = ;
        int fibn;
        for(int i=;i<=n;i++){
            fibn = fibnMinusOne  + fibnMinusTwo;
            fibnMinusTwo = fibnMinusOne;
            fibnMinusOne = fibn;
        }
        return fibn;
    }
};

8.一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

class Solution {
public:
    int jumpFloor(int number) {
        if (number == )
            return ;
        if (number == )
            return ;
        int fnMinusOne = ;
        int fnMinusTwo = ;
        int fn;
        for (int i = ; i <= number; i++) {
            fn = fnMinusOne + fnMinusTwo;
            fnMinusTwo = fnMinusOne;
            fnMinusOne = fn;
        }
        return fn;
    }
};

9.一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

class Solution {
public:
    int jumpFloorII(int number) {
        return pow(,number-);
    }
};

10.我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

class Solution {
public:
    int rectCover(int number) {
        if(number <= ) return ;
        if (number == )
            return ;
        if (number == )
            return ;
 
        int fnMinusOne = ;
        int fnMinusTwo = ;
        int fn;
        for (int i = ; i <= number; i++) {
            fn = fnMinusOne + fnMinusTwo;
            fnMinusTwo = fnMinusOne;
            fnMinusOne = fn;
        }
        return fn;
    }
};