jianzhi offer day1

第一题。

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

想：如果从左上角走，那右边和下边都比他大，但是如果从左下角走，那上边的都比他小，右边的都比他大就好判断。

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

第二题

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

想：在原字符串上修改，但是有个问题，因为%20比空格多2个字节，所以字符长度也得改，那就得注意不能溢出。所以要从后往前弄，把第1个位置上的数变为第3位置上的数，并且加入%20

class Solution {
public:
    void replaceSpace(char *str,int length) {
        int cnt = 0;
        int i = length - 1;
        for (int i = 0; i < length; cnt += (str[i++] == ' '));
        str = (char *)realloc(str, length += 2 * cnt);
        for (int j = length - 1; i >= 0; i--) {
            if (str[i] != ' ')
                str[j--] = str[i];
            else
                str[j] = '0', str[j - 1] = '2', str[j - 2] = '%', j -= 3;
        }
    }
};

第三题

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

栈

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
       stack<char>cs;
        while(head!=nullptr){
         cs.push(head->val);
            head=head->next;
         }
        vector<int> ret;
        while (!cs.empty()){
            ret.push_back(cs.top());cs.pop();}
        return ret;
    }
};

第四题:

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

第五题：

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

 

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 a=stack2.top();
        stack2.pop();
        return a;
    }

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

第六题：

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。

NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

没看懂非递减什么意思。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        
    }
};

第七题：

斐波那契数列：

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

n<=39。F0=0,F1=1；Fn=Fn−1+Fn−2(n≥2)

class Solution {
public:
    int Fibonacci(int n) {
        if(n==0)
            return 0;
        if(n==1)
            return 1;
        int f1=0.f2=1,ret;
        if(n>=2){
            for(int i=2;i<=n<i++){
                ret=f1+f2;
                f1=f2,f2=ret;
        }
        return ret;
    }
};

第八题：

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

动态规划。

遇到这种动态规划，暴力的解法多层嵌套，计数器加一。但是动态规划的解法，可以从后往前想，把问题划分成子问题。最后一次跳上台阶可以从n-1跳1步，也可以从n-2跳2步。那问题就变为到n-1有多少种，n-2有多少种，这不就是斐波那契。

class Solution {
public:
    int jumpFloor(int n) {
        if (n == 1)
            return 1;
        int f1 = 1, f2 = 1, ret;
        for (int i = 2; i <= n; i++)
            ret = f1 + f2, f1 = f2, f2 = ret;
        return ret;
    }
};

第九题

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

公式f(n)=f(1)+f(2)+f(3)+...+f(n-1)表示最后一次跳上台阶。f(n-1)=f(1)...+f(n-2)。f(n)=2f(n-1)，等比数列，直接套公式。

第十题：矩形覆盖

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

动态规划，想最后一步完成有几种情况。横着2块，竖着1块。

也是f(n)=f(n-1)+f(n-2)  f(1)=1,f(2)=2

第十一题：二进制中的1个数

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

没理解题意

第十二题：调整数组顺序，使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

若不考虑后面的粗话。可以用归并思想

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        int head=0,tail=array.size()-1;
        int key;
        while(head<tail){
            if(array[head]%2!=0){
               head++; 
            }
                
            else{
                key=array[tail];
                array[tail]=array[head];
                array[head]=key;
                tail--;
            }
        }
    }
};

若考虑，可以用插入排序，如果是奇数插到偶数前面。偶数就不动。

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        int key;
        int a=array.size();
        for(int i=0;i<a;i++){
            if(array[i]%2==1){
                int j=i;
                 while(j>0 && array[j-1]%2==0){
                 key=array[j];
                array[j]=array[j-1];
                array[j-1]=key;
                j--;
            }
          }
        }
    }
};

第十三题：链表中倒数第K个结点

输入一个链表，输出该链表中倒数第K个结点。

法一，所有链表-k=正面第几个，然后从正面数。O(2n)

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
    
    }
};

法2，两个指针，第一个指针先往后移k-1次，然后第二个指针和第一个指针在同时往后移，知道第一个为nullptr。