剑指offer

 3.找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：

输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3 

1.哈希表就是一个超时的大动作

2.直接排序

class Solution {
    public int findRepeatNumber(int[] nums) {
        Arrays.sort(nums);
        int res=0;
        for(int i=0;i<nums.length-1;i++){
            if(nums[i]==nums[i+1]){
                res=nums[i];
                break;
            }
        }
        return res;
    }
}

 3.索引与值对应法

class Solution {
    public int findRepeatNumber(int[] nums) {
        for(int i = 0; i < nums.length; i++) {  
            //利用循环交换，将子循环排序，如果这个循环链中有重复，就直接返回
            while(nums[i] != i) {
                if(nums[nums[i]] == nums[i]) return nums[i];
                else {
                    //交换
                    int temp = nums[nums[i]];
                    nums[nums[i]] = nums[i];
                    nums[i] = temp;
                }
            }
        }
        return -1;
    }
}

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

示例:

现有矩阵 matrix 如下：

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。

限制：

0 <= n <= 1000

0 <= m <= 1000

1.暴力法

2.右上角往左下移，如果当前大于目标，左移，小于下移。注意越界问题！！！

class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }
        int rows = matrix.length;
        int columns = matrix[0].length;
        int row = 0;
        int column = columns - 1;
        while(column>=0&&row<rows){
            if(matrix[row][column]==target){
                return true;
            }else if(matrix[row][column]>target){
                //左移
                column--;
            }else{
                //下移
                row++;
            }
        }
        return false;
    }
}

 5.请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = "We are happy."
输出："We%20are%20happy."
 

限制：

0 <= s 的长度 <= 10000

1.数组

class Solution {
    public String replaceSpace(String s) {
        char[] c=s.toCharArray();
        char[] result=new char[3*c.length];
        int k=0;
        for(int i=0;i<c.length;i++){
            if(c[i]==' '){
                result[k++]='%';
                result[k++]='2';
                result[k++]='0';
            }else{
                result[k]=c[i];
                k++;
            }
        }
        String s1=String.copyValueOf(result);
        String s2=s1.substring(0,k);
        return s2;
    }
}

 

 以后转且截取数组可以用这个方法。

2.StringBuider

class Solution {
    public String replaceSpace(String s) {
        StringBuilder sb=new StringBuilder();
        char[] c=s.toCharArray();
        for(int i=0;i<c.length;i++){
           if(c[i]==' '){
               sb.append("%20");
           }else{
               sb.append(c[i]);
           }
        }
        String result=sb.toString();
        return result;
    }
}

6.输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2]
输出：[2,3,1]
 

限制：

0 <= 链表长度 <= 10000

1.栈

class Solution {
    public int[] reversePrint(ListNode head) {
        //写一个栈
        Stack<Integer> s=new Stack();
        ListNode temp=head;
        while(temp!=null){
            s.push(temp.val);
            temp=temp.next;
        }
        //一个一个弹到数组里
        int[] res=new int[s.size()];
        for(int i=0;i<res.length;i++){
            res[i]=s.pop();
        }
        return res;
    }
}

 2.反转链表

class Solution {
    public int[] reversePrint(ListNode head) {
        //写个反转链表
        ListNode reverseHead=new ListNode();
        ListNode temp=head;
        int count=0;
        while(temp!=null){
            ListNode t=temp.next;
            temp.next=reverseHead.next;
            reverseHead.next=temp;
            temp=t;
            count++;
        }
        reverseHead=reverseHead.next;
        int[] res=new int[count];
        for(int i=0;i<res.length;i++){
            res[i]=reverseHead.val;
            reverseHead=reverseHead.next;
        }
        return res;
    }
}

9.用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：

输入：
["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
输出：[null,null,3,-1]
示例 2：

输入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]
提示：

1 <= values <= 10000
最多会对 appendTail、deleteHead 进行 10000 次调用

class CQueue {
    Stack<Integer> in;
    Stack<Integer> out;
    public CQueue() {
        in=new Stack<>();
        out=new Stack<>();
    }
    
    public void appendTail(int value) {
        in.push(value);
    }
    
    public int deleteHead() {
        if(out.isEmpty()){
            if(in.isEmpty()){
                return -1;
            }else{
                //把in的都放到out里，然后弹出一个
                while(!in.isEmpty()){
                    out.push(in.pop());
                }
                return out.pop();
            }
        }else{
            //优先删除out里的
            return out.pop();
        }
    }
}

10-1和10-2完全一样啊。。懒得做了。。

 

class Solution {
    static final int MOD = 1000000007;

    public int fib(int n) {
        if (n < 2) {
            return n;
        }
        int[][] q = {{1, 1}, {1, 0}};
        int[][] res = pow(q, n - 1);
        return res[0][0];
    }

    public int[][] pow(int[][] a, int n) {
        int[][] ret = {{1, 0}, {0, 1}};
        while (n > 0) {
            if ((n & 1) == 1) {
                ret = multiply(ret, a);
            }
            n >>= 1;
            a = multiply(a, a);
        }
        return ret;
    }

    public int[][] multiply(int[][] a, int[][] b) {
        int[][] c = new int[2][2];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                c[i][j] = (int) (((long) a[i][0] * b[0][j] + (long) a[i][1] * b[1][j]) % MOD);
            }
        }
        return c;
    }
}

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

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：

输入：n = 2
输出：2
示例 2：

输入：n = 7
输出：21
示例 3：

输入：n = 0
输出：1
提示：

0 <= n <= 100

1.填表

class Solution {
    public int numWays(int n) {
        //
        int[] result=new int[101];
        result[0]=1;
        result[1]=1;
        for(int i=2;i<=100;i++){
            result[i]=(result[i-1]+result[i-2])%(1000000007);
        }
        return result[n];
    }
}

 2.动态规划

class Solution {
    public int numWays(int n) {
        //动态规划
        int a=1;
        int b=1;
        int sum=0;
        if(n<=1){
            return 1;
        }
        for(int i=2;i<=n;i++){
            sum=(a+b)%1000000007;
            a=b;
            b=sum;
        }
        return sum;
    }
}

3.斐波那契记得四舍五入round和n+1；这里取模这种不能用斐波那契？？为什么？？

 11.把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。

给你一个可能存在 重复 元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为 1。  

注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

示例 1：

输入：numbers = [3,4,5,1,2]
输出：1
示例 2：

输入：numbers = [2,2,2,0,1]
输出：0
 

提示：

n == numbers.length
1 <= n <= 5000
-5000 <= numbers[i] <= 5000
numbers 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

class Solution {
    public int minArray(int[] numbers) {
        //二分一下
        int left=0;
        int right=numbers.length-1;
        int mid=0;
        while(left<right){
            mid=(left+right)/2;
            //中间大于右边，那么值一定在中间+1到右边
            if(numbers[mid]>numbers[right]){
                left=mid+1;
                //如果等于右边，只能排除当前右边
            }else if(numbers[mid]==numbers[right]){
                right--;
                //中间小于右边的话，说明一定在左边到中间
            }else{
                right=mid;
            }
        }
        return numbers[left];        
    }
}

 15.编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为 汉明重量).）。

提示：

请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用 二进制补码 记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。
 

示例 1：

输入：n = 11 (控制台输入 00000000000000000000000000001011)
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
示例 2：

输入：n = 128 (控制台输入 00000000000000000000000010000000)
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。
示例 3：

输入：n = 4294967293 (控制台输入 11111111111111111111111111111101，部分语言中 n = -3）
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。
 

提示：

输入必须是长度为 32 的 二进制串 。

public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        //int类型二进制数小于32位。
        int count=0;
        for(int i=0;i<32;i++){
            int k=(1<<i);
            if((n&k)!=0){
                count++;
            }
        }
        return count;
    }
}

public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        int count=0;
        //一比特数
        while(n!=0){
            n&=(n-1);
            count++;
        }
        return count;
    }
}

24.定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
 

限制：

0 <= 节点个数 <= 5000

迭代一下，学习一下递归。 

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null){
            return null;
        }
        ListNode reverseHead=new ListNode();
        ListNode temp=head;
        while(temp!=null){
            ListNode t=temp.next;
            temp.next=reverseHead.next;
            reverseHead.next=temp;
            temp=t;
        }
        return reverseHead.next;
    }
}

class Solution {
    public ListNode reverseList(ListNode head) {
        //递归一下
        if(head==null||head.next==null){
            return head;
        }
        ListNode temp=reverseList(head.next);
        head.next.next=head;
        head.next=null;
        return temp;
    }
}