剑指offer(1~10)题解

Posted 2020-10-24 amoy-zhp

剑指offer(1~10)

二维数组中的查找

源代码

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

解析

因为数组从左到右递增，从上到下递增，于是从矩阵右上角开始找。如果比行最后一个值大，则直接到下一行找。若比一行找，这需要找的值要么再这一行要么不在矩阵中。

替换空格

源代码

class Solution {
public:
    void replaceSpace(char *str,int length) {
        int cntlength = 0;
        do{
            cntlength++;
        }while( str[cntlength] != ‘\0‘);
        
        for(int i = 0 ; str[i] != ‘\0‘ ;){
            if( str[i] == ‘ ‘){
                cntlength += 2;
                for(int j = cntlength + 2 ; j > i + 2 ; j--){
                    str[j] = str[j - 2];
                }
                str[i] = ‘%‘;
                str[i + 1] = ‘2‘;
                str[i + 2] = ‘0‘;
                i = i + 3;
            } else {
                i++;
            }
        }
    }
};

解析

题中给的length是字符串开辟空间的长度，不是字符串长度，需要注意一下。替换的换先计算出字符串的长度，然后找到空格后，就将相应位置的字符串后移，然后把空出来的位置替换成题目要求的字符。

从头到尾打印链表

源代码

class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> list;
        if( head != NULL){
            while( head -> next != NULL){
            list.push_back(head -> val);
            head = head -> next;
            }
            list.push_back(head -> val);
            reverse(list.begin() , list.end());
        }
        return list;
    }
};

解析

因为返回的vector，用了vector的逆序函数完成了逆序。

重建二叉树

源代码

class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        if( pre.size() == 0){
            return NULL;
        }
        TreeNode* root = new TreeNode(pre[0]);
        root -> left = NULL;
        root -> right = NULL;
        if( pre.size() == 1){
            return root;
        }
        vector<int> leftpre;
        vector<int> rightpre;
        vector<int> leftvin;
        vector<int> rightvin;
        for(int i = 0 ; i < vin.size() ; i ++){
            if( pre[0] == vin[i]){

                leftpre.assign(pre.begin() + 1, pre.begin() + i + 1);
                leftvin.assign(vin.begin(), vin.begin() + i);

                rightpre.assign(pre.begin()+ i + 1 , pre.end());
                rightvin.assign(vin.begin()+ i + 1, vin.end());

                root -> left = reConstructBinaryTree(leftpre , leftvin);
                root -> right = reConstructBinaryTree(rightpre , rightvin);
                break;
            }
        }
        return root;
    }
};

解析

中序中，在根左侧的都是左子树节点，右侧的都是右子树节点，并且可以算出左子树和右子树节点的个数，因此就可以从前序中截取左子树的前序序列和右子树的前序列。这里用了递归的方法，把左子树的前序中序，右子树的前序中序作为输入又传到函数中。完成二叉树的重建。

用两个栈实现队列

源代码

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

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

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

解析

因为栈是先进后出，将栈中元素取出再押入新栈，新栈的出栈顺序就变成原来的逆序，即第一个栈中先进就会先出。所以将新的元素押入到栈1中，在取元素的时候，如果栈2为空，则栈1元素出栈再押入栈2中，然后再顺序将栈2元素出栈

旋转数组中的最小数字

源代码

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

解析

思路是找到的第一个元素比前面元素小的那个元素，就是要找的那个元素。不过这里的时间复杂度应该不是最小的。

斐波那契数列

源代码

class Solution {
public:
    int Fibonacci(int n) {
        if( n == 0)return 0;
        if( n == 1)return 1;
        int a1 = 1;
        int a2 = 0;
        int temp;
        for(int i = 1 ; i < n ; i ++){
            temp = a1 + a2;
            a2 = a1;
            a1 = temp;
        }
        return a1;
    }
};

解析

斐波那契数列 f(n) = f(n - 1) + f(n - 2)，按此规律实现即可。

跳台阶

源代码

class Solution {
public:
    int jumpFloor(int number) {
        if(number == 0) return 0;
        if(number == 1) return 1;
        if(number == 2) return 2;
        int temp;
        int a1 = 2;
        int a2 = 1;
        for(int i = 2 ; i < number ; i ++){
            temp = a1 + a2;
            a2 = a1;
            a1 = temp;
        }
        return a1;
    }
};

解析

其实还是斐波那契数列问题。对于第n个台阶，如果第一次跳1一个，则剩下的解法是f(n-1)，如果跳两个，则剩下的解法是f(n-2)，即f(n) = f(n - 1) + f(n -2);

变态跳台阶

源代码

class Solution {
public:
    int jumpFloorII(int number) {
        if(number == 1)return 1;
        if(number == 2)return 2;
        if(number == 3)return 4;
        int sum = 4;
        while( number >= 4){
            sum *= 2;
            number--;
        }
      
        return sum;
    }
};

解析

这里类似上一题的解题思路，f(3) = f(2) + f(1) + 1;其中1为一次跳三个。而f(4) = f(3) + f(2) + f(1) + 1;而后面三项显然为f(3)所以f(4) = 2 * f(3)；后面以此类推有f(n) = 2 *f(n - 1)

矩形覆盖

源代码

class Solution {
public:
    int rectCover(int number) {
        if( number == 0) return 0;
        if( number == 1) return 1;
        if( number == 2) return 2;
        int temp;
        int f1 = 2;
        int f2 = 1;
        for(int i = 2 ; i < number ; i ++){
            temp = f1 + f2;
            f2 = f1;
            f1 = temp;
        }
        return f1;
    }
};

解析

这个也是斐波那契饿数列问题

o
o

x	x
o	o

n为1时只有一种解法，n为2时有横竖两种解法，当n变大时，类似跳台阶问题，如果是纵向，则为f(n -1)，如果为横向则为f(n - 2),有f(n) = f(n - 1) + f(n - 2)