剑指offer-20200308

20200308

题目 ：数组中出现次数超过一半的数字

数组中给一个数字出现的次数超过数组长度的一半，请找出这个数字。

思路 ：排完序，取中值；也可以用hashMap。

code

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        int left = 0;
        int right = nums.length - 1;
        int middle = (left + right) / 2;
        return nums[middle];
    }
}

题目：最小的k个数

输入整数数组arr，找出其中最小的k个数。例如，输入5、4、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

思路 排序之后，输出来即可。

class Solution{
    public int[] getLeastNumbers(int[] arr, int k){
        if(k == 0) {
            return new int[0];
        }
        if(k == arr.length)
            return arr;
        int[] res = new int[k];
        for(int i=0;i<k;i++){
            res[i] = arr[i];
        }
        return res;
    }
}

思路 大顶堆

class Solution{
    public int[] getLeastNumbers(int[] arr, int k){
        if(k == 0)
            return new int[0];
        int len = arr.length;
        if(k == len){
            return arr;
        }
        //对arr数组的前k个数建堆
        int[] heap = new int[k];
        for(int i=0;i<k;i++){
            heap[i] = arr[i];
        }
        buildHeap(heap);
        
        //遍历arr数组剩余的数，与堆顶元素进行比较大小，小进行替换堆顶，之后保持大顶堆。
        for(int i=k;i<len;i++){
            if(arr[i] < heap[0]){
                heap[0] = arr[i];
                heapify(heap,0);
            }
        }
        //返回堆
        return heap;
    }
    
    //建堆
    //主要 parent = (i-1)/2;childleft = 2*i + 1;childright = 2 * i+ 2;
    private void buildHeap(int[] nums){
        //最后一个结点
        int lastNode = nums.length - 1;
        //最后一个节点的父节点
        int startHeapify = (lastNode - 1) / 2;
        //开始heapfiy直到最后
        while(startHeapify >= 0){
            heapify(nums,startHeapify--);
        }
    }
    
    //维护堆
    private void heapify(int[] nums,int i){
        int len = nums.length;
        if(i >= len){
            return ;
        }
        int c1 = ((i << 1) + 1), c2 = ((i << 1)+2);
        //假定节点i是最大节点。
        int max = i;
        if(c1 < len && nums[c1] > nums[max])
            max = c1;
        if(c2 < len && nums[c2] > nums[max])
            max = c2;
        if(max != i){
            swap(nums,max,i);
            heapify(nums,max);
        }
    }
    private void swap(int[] nums,int i, intj){
        nums[i] = nums[i] + nums[j] - (nums[j] = nums[i]);
    }
}

res = new int[k];
for(int i=0;i<k;i++){
res[i] = arr[i];
}
return res;
}
}

**思路** 大顶堆

```java
class Solution{
    public int[] getLeastNumbers(int[] arr, int k){
        if(k == 0)
            return new int[0];
        int len = arr.length;
        if(k == len){
            return arr;
        }
        //对arr数组的前k个数建堆
        int[] heap = new int[k];
        for(int i=0;i<k;i++){
            heap[i] = arr[i];
        }
        buildHeap(heap);
        
        //遍历arr数组剩余的数，与堆顶元素进行比较大小，小进行替换堆顶，之后保持大顶堆。
        for(int i=k;i<len;i++){
            if(arr[i] < heap[0]){
                heap[0] = arr[i];
                heapify(heap,0);
            }
        }
        //返回堆
        return heap;
    }
    
    //建堆
    //主要 parent = (i-1)/2;childleft = 2*i + 1;childright = 2 * i+ 2;
    private void buildHeap(int[] nums){
        //最后一个结点
        int lastNode = nums.length - 1;
        //最后一个节点的父节点
        int startHeapify = (lastNode - 1) / 2;
        //开始heapfiy直到最后
        while(startHeapify >= 0){
            heapify(nums,startHeapify--);
        }
    }
    
    //维护堆
    private void heapify(int[] nums,int i){
        int len = nums.length;
        if(i >= len){
            return ;
        }
        int c1 = ((i << 1) + 1), c2 = ((i << 1)+2);
        //假定节点i是最大节点。
        int max = i;
        if(c1 < len && nums[c1] > nums[max])
            max = c1;
        if(c2 < len && nums[c2] > nums[max])
            max = c2;
        if(max != i){
            swap(nums,max,i);
            heapify(nums,max);
        }
    }
    private void swap(int[] nums,int i, intj){
        nums[i] = nums[i] + nums[j] - (nums[j] = nums[i]);
    }
}