剑指Offer编程题笔记之1-10

前言

题目是来自牛客网的剑指Offer编程题。这是第二次做这些题了。可能会因为做过的题有印象，所以再做起来会很自然的就想到了那种大神的高级解法。但也有可能想到了但是却实现不了。另外第一次做时是本着能做出来就行的想法。因此觉得有必要再做一遍，同时第二次做，就要追求质量了。

这一次，把题做出来，并做笔记，算是加深记忆吧。每篇文章10道题。

题目

二维数组中的查找

第1题

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

思路：
由题目给出的信息可以得到这样的规律，二维数组中右边的数比左边的数大，下面的数比上面的数大，因此，如果以左下角为起点，往上走数字会变小，往右走则会变大。因此可以利用这个规律从左下角的数字开始与目标数字进行判断，直到走到左上角还没能找到。

实现如下：

public class Solution {
    public boolean Find(int target, int [][] array) {
        int x = array.length-1;
        int y = 0;
        while(x>=0&&y<=array[0].length-1){
            if(array[x][y]==target)
            return true;
        else if(array[x][y]<target)
            y++;
        else
            x--;
        }
        return false;
    }
}

替换空格

第2题

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

思路：
就是替换呗，尽量不要降低时间复杂度和空间复杂度。

实现如下：

public String replaceSpace(StringBuffer str) {
    StringBuffer sb = new StringBuffer();
    char[] ch = str.toString().toCharArray();
    for(int i=0;i<ch.length;i++){
        if(ch[i]==' ')
            sb.append("%20");
        else
            sb.append(ch[i]);
    }
    return sb.toString();
}

另一种解法：利用StringBuffer的charAt方法，这样就不需要额外空间了。
优化版：

public String replaceSpace(StringBuffer str) {
    StringBuffer sb = new StringBuffer();
    char c;
    for(int i=0;i<str.length();i++){
        if((c=str.charAt(i))==' ')  //可以利用StringBuffer的charAt方法
            sb.append("%20");
        else
            sb.append(c);
    }
    return sb.toString();
}

从尾到头打印链表

第3题

题目描述
输入一个链表，从尾到头打印链表每个节点的值。

思路：
立马想到的是有先进后出特性的栈！先把节点值存到栈中，再通过出栈方法输出节点值。

实现如下：

public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
    Stack<Integer> stack = new Stack<>();
    ListNode p = listNode;
    while(p!=null){
        stack.push(p.val);
        p = p.next;
    }
    ArrayList<Integer> list = new ArrayList<>();
    while(!stack.isEmpty()){
        list.add(stack.pop());
    }
    return list;
}

用两个栈来实现队列

第4题

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

思路：
栈的特性是先进后出，如果有两个栈，那我们把12345放到栈A，再拿出来，结果是54321。那如果我们拿出来并放入栈B，那么就是以54321的顺序放进栈B，这样我们再从栈B取出全部，顺序就是12345，这就实现了队列的先进先出效果了。具体的实现是通过用一个栈（设为A栈）来存数据，另一个栈（设为B栈）来取数据。且要存数据的时数据要全放在A栈中即确保B栈为空，取数据时数据要全放在B栈中即确保A栈为空。可以画图模拟下，很好懂。

实现如下：

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();//stack1用来存数据
    Stack<Integer> stack2 = new Stack<Integer>();//stack2用来取数据

    public void push(int node) {
        while(!stack2.isEmpty())
            stack1.push(stack2.pop());
        stack1.push(node);
    }

    public int pop() {
        while(!stack1.isEmpty())
            stack2.push(stack1.pop());
        return stack2.pop();
    }
}

旋转数组的最小数字

第5题

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

思路：
{3,4,5,1,2}，观察得到的信息是相邻的两个数字若左边的数字比右边的大，说明右边的数字是最小的数字。因此，可以利用两个紧挨着的前后指针AB，若指针A指向的数字比指针B指向的数字大，说明指针B指向的数是最小的。

public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int length=array.length;
        if(length==0)
            return 0;
        for(int i=0;i<length-2;i++){
            if(array[i]>array[i+1])
                return array[i+1];
        }
        return array[0];
    }
}

菲波那切数列

第6题

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

思路：
斐波那契数列，又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……即前两个数相加的和为下一个数的值。
实现斐波那契额数列，可以用递归，也可以是非递归。递归耗时但代码简洁，非递归效率高并代码不简洁。非递归的话可以会出现StackOverflowError异常。因此，还是使用非递归吧。

递归实现：

public class Solution {
    public int Fibonacci(int n) {
        if(n<=1)
            return n;
        return Fibonacci(n-1)+Fibonacci(n-2);
    }
}

非递归实现：

public class Solution {
    public int Fibonacci(int n) {
        if(n<=1)
            return n;
        int n1 = 0;
        int n2 = 1;
        int result = 0;
        for(int i=2;i<=n;i++){
            result = n1+n2;
            n1 = n2;
            n2 = result;
        }
        return result;
    }
}

跳台阶

第7题

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

思路：
找规律，发现f(1)=1,f(2)=2,f(3)=3,f(4)=5,f(5)=8,这是斐波那契数列啊。。。
还有一种思路：
引用牛客网用户“绒绒Alice”的分析：

比较倾向于找规律的解法，f(1) = 1, f(2) = 2, f(3) = 3, f(4) = 5， 可以总结出f(n) = f(n-1) + f(n-2)的规律，但是为什么会出现这样的规律呢？假设现在6个台阶，我们可以从第5跳一步到6，这样的话有多少种方案跳到5就有多少种方案跳到6，另外我们也可以从4跳两步跳到6，跳到4有多少种方案的话，就有多少种方案跳到6，其他的不能从3跳到6什么的啦，所以最后就是f(6) = f(5) + f(4)；这样子也很好理解变态跳台阶的问题了。

实现如下：

public class Solution {
    public int JumpFloor(int target) {
        if(target<=2)
            return target;
        int n1 = 1;
        int n2 = 2;
        int result=0;
        for(int i=3;i<=target;i++){
            result = n1+n2;
            n1 = n2;
            n2 = result;
        }
        return result;
    }
}

变态跳台阶

第8题

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

思路：
一样找规律，f(1)=1,f(2)=2,f(3)=4,f(4)=8,f(5)=16…这不是2的n-1次方吗！！可以通过移位运算符实现2的n次方

实现如下：

public class Solution {
    public int JumpFloorII(int target) {
        if(target<=0)
            return -1;
         return  1<<(target-1);//通过移位运算符实现
    }
}

另一种思路：
沿用上一题牛客网用户“绒绒Alice”的那种分析思路：
可分析得到f(5)=f(4)+f(3)+f(2)+f(1)，且f(6)=f(5)+f(4)+f(3)+f(2)+f(1)，整合二式可得f(6)=2*f(5)。
可得f(n)=2*f(n-1)。即后一个数是前一个数的2倍。实现方式同上面的代码。
这里难点是通过f(5)=f(4)+f(3)+f(2)+f(1)能想到f(6)=f(5)+f(4)+f(3)+f(2)+f(1)，而不是单靠f(5)=f(4)+f(3)+f(2)+f(1)一个公式就得出规律。

矩阵覆盖

第9题

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

思路：
画图列举n=1，2，3，4的情况，可以发现，又是一个斐波那契数列。

实现如下：

public class Solution {
    public int RectCover(int target) {
        if(target<0)
            return -1;
        if(target<=2)
            return target;
        int n1 = 1;
        int n2 = 2;
        int result = 0;
        for(int i=3;i<=target;i++){
            result = n1+n2;
            n1 = n2;
            n2 = result;
        }
        return result;
    }
}

二进制中1的个数

第10题

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

思路：
我们的目的就是计算该二进制表示中1的个数。我们可以将该数和1做与运算，若为1，说明该数的二进制表达中的最低位为1，结果若为0，说明该数的二进制表达中最低位为0。如何比较每一位呢，通过移位，每比较移位，就右移1位。直至该数变成0。

实现如下：

public class Solution {
    public int NumberOf1(int n) {
        int i = 0;
        while(n!=0){
            if((n&1)==1)    //"&"的优先级比"=="低，因此要加括号
                i++;
            n=n>>>1;    //注意，用的是无符号右移，这样移位时高位会补0。若用了>>，则表示有符号右移，当n是负数时，高位会补1
        }
        return i;
    }
}

另一种解法：
思路是一样的，计算二进制表达中1的个数。可以通过Integer.toBinaryString方法，得到该整数的二进制表达字符串。
实现如下：

public class Solution {
    public int NumberOf1(int n) {
        char[] ch = Integer.toBinaryString(n).toCharArray();
        int result = 0;
        for(int i=0;i<ch.length;i++){
            if(ch[i]=='1')
                result++;
        }
        return result;
    }
}