LeetCode-0330

剑指 Offer 11. 旋转数组的最小数字（简单）

思路：不需要扫一遍，只需要发现有一个数开始比之前小就可以。

问题：首先需要主要有重复元素。同时有可能旋转了n-1次，最小值在最后面，所以不能看到递增就输出num[0]，如果循环到最后都没有发现减小，就说明最小值在开头，可以比较一下开头和结尾看看有没有进行旋转。

class Solution {
    public int minArray(int[] numbers) {
            if(numbers.length==1||numbers[0]<numbers[numbers.length-1])return numbers[0];
            for(int i=1;i<numbers.length;i++){
                if(numbers[i]<numbers[i-1])return numbers[i];
            }
        return numbers[0];    
    }
}

剑指 Offer 15. 二进制中1的个数(简单)

思路：左右摇摆一下，和之前的一对比就可以比较出0还是1，但是这个方法c++可以用，但是java就是过不了。Java用的补码，右移的时候左边会补1而不是补0，所以做不对。

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int cnt = 0;
        while(n>0){
            if(n!=n>>1<<1){
                cnt++;
            }
            n=n>>1;
        }
        return cnt;
    }
};

对于Java语言这个题目的做法：

1. 把1这个数循环左移32次，一次次做与运算并且不等于0，说明这一位上是1.
2. n&(n-1) ，会把1都与掉，有几个1会与几次。
3. 妖术

// 1.
public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        int cnt = 0;
        for(int i=0;i<32;i++){
            if((n & (1<<i))!=0)cnt++;
        }
        return cnt;
    }
}

// 2.
public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        int cnt = 0;
        while(n!=0){ //	注意这里不能写n>0 ， 因为还会有负数的情况
            n&=n-1;
            cnt++;
        }
        return cnt;
    }
}

// 3.
public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        return Integer.bitCount(n);
    }
}

剑指 Offer 16. 数值的整数次方(中等)

思路：快速幂，我使用的栈，题解使用递归，非常优雅

问题：一开始忘记快速幂的处理了，不管指数%2等于什么都/2处理就错了。

​ 官方题解里面需要注意：int范围-2147483648~2147483647 如果-2147483648反转成正书刚好超限，所以必须先转为int。

​ 也是统一的问题，int需要取相反数的时候必须转为long

class Solution {
    public double myPow(double x, int n) {
        double res = 1;
        Stack<Integer>sta = new Stack();
        while(n!=0){
            if(n%2==1){
                sta.push(1);
                n--;
            }
            else if(n%2==-1){
                sta.push(-1);
                n++;
            } 
            else{
                sta.push(0);
                n/=2;
            }
        }
        while(!sta.isEmpty()){
            if(sta.peek()==1)res*=x;
            else if(sta.peek()==-1)res/=x;
            else res = res*res;
            sta.pop();
        }
        return res;
    }
}

23. 合并 K 个升序链表(困难)

npy很高兴的跟我说她A了一道hard，我听到题目的第一反应是归并，她说你在说什么哦，我又想了想，觉得写归并比较麻烦，直接放数组里sort一遍拿出来得了。然后几分钟就A了，后来得知她用堆做的，感觉其实也差不多。并且还提醒我可以用lambda写比较器。

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {

        List<Integer> array = new ArrayList<Integer>();
        for(int i=0;i<lists.length;i++){
            ListNode head = lists[i];
            while(head!=null){
                array.add(head.val);
                head = head.next;
            }
        }
        array.sort((o1,o2)->o1-o2);
        if(array.size()==0)return null;
        ListNode root = new ListNode(array.get(0));
        ListNode last = root;
        for(int i=1;i<array.size();i++){
            ListNode tp = new ListNode(array.get(i));
            last.next = tp;
            last = tp;
        }
        return root;
    }
}