剑指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[0].size();

        int row = 0;
        int col = n -1;

        while(row < m && col >= 0){
            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 = 0;
        for (int i = 0; i < length; i++) {
            if (str[i] == ' ') {
                spaceCount++;
            }
        }
        if (spaceCount == 0)
            return;
        int p = length - 1;
        int q = length + spaceCount * 2 - 1;

        while (p < q) {
            if (str[p] != ' ') {
                str[q--]=str[p--];
            }else{
                p--;
                str[q--] = '0';
                str[q--] = '2';
                str[q--] = '%';
            }
        }
        str[length+spaceCount*2] = '';
    }
};

 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[0]);
        vector<int> leftPre, leftVin;
        vector<int> rightPre, rightVin;

        for (int i = 0; i < vin.size(); i++) {
            if (vin[i] != pre[0]) {
                leftVin.push_back(vin[i]);
                leftPre.push_back(pre[i + 1]);
            }else{
                break;
            }
        }

        int leftSize = leftVin.size();
        for (int i = leftSize+1; 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 -1; // 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 == 0) return 0;
        if (n == 1) return rotateArray[0];

        int minVal = -1;
        for (int i = 1; i < n; i++) {
            if (rotateArray[i] < rotateArray[i - 1])
                minVal = rotateArray[i];
        }
        if (minVal == -1) {
            minVal = rotateArray[0];
        }
        return minVal;
    }
};

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

class Solution {
public:
    int Fibonacci(int n) {
        if(n == 0) return 0;
        if(n == 1) return 1;
        int fibnMinusOne = 1;
        int fibnMinusTwo = 0;
        int fibn;
        for(int i=2;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 == 1)
            return 1;
        if (number == 2)
            return 2;
        int fnMinusOne = 2;
        int fnMinusTwo = 1;
        int fn;
        for (int i = 3; 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(2,number-1);
    }
};

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

class Solution {
public:
    int rectCover(int number) {
        if(number <= 0) return 0; 
        if (number == 1)
            return 1;
        if (number == 2)
            return 2;

        int fnMinusOne = 2;
        int fnMinusTwo = 1;
        int fn;
        for (int i = 3; i <= number; i++) {
            fn = fnMinusOne + fnMinusTwo;
            fnMinusTwo = fnMinusOne;
            fnMinusOne = fn;
        }
        return fn;
    }
};