基于partition——最小的K个数、数组中出现次数超过一半的数字

题目一：最小的K个数

解法一：基于partition,O（N）的算法，并且会修改输入的数组，不适用于海量数据，因为数据可能不能一次性读入内存；

 

        public void swap(int[] data,int i,int j)
	{
		int temp=data[i];
		data[i]=data[j];
		data[j]=temp;
	}
	public int partition(int[] data,int low,int high)
	{
		int pivotkey=data[low];
		while(low<high)
		{
			while(low<high&&data[high]>=pivotkey)
				high--;
			swap(data,low,high);
			while(low<high&&data[low]<=pivotkey)
				low++;
			swap(data,low,high);
		}
		return low;//返回pivotley的下标，循环到最后仍然是low；
	}
	public void least_K(int[] data,int k)
	{
		if(data == null||k<=0||k>data.length)
			return;
		
		int low=0;
		int high=data.length-1;
		int pivot=partition(data,low,high);
		while(pivot!=k-1)
		{
		if(pivot<k-1)
		{
			low=pivot+1;
			pivot=partition(data,low,high);
		}
		else
		{
			high=pivot-1;
			pivot=partition(data,low,high);
		}
		}
		
		for(int i=0;i<k;i++)
		{
			System.out.println(""+data[i]);
		}
	}

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        if (input == null || input.length < k || k <= 0){
            return new ArrayList();
        }
        int pivot = partition(input,0,input.length-1);
        while(pivot != k-1){
            if(pivot < k-1){
                pivot = partition(input,pivot+1,input.length-1);
            } else {
                pivot = partition(input,0,pivot-1);
            }
        }
        ArrayList<Integer> array = new ArrayList();
        for (int i=0;i<k;i++){
            array.add(input[i]);
        }
        return array;
    }
    private int partition(int[] data,int low , int high) {
        int pivotkey = data[low];
        while(low < high) {
            while (low < high && data[high] >= pivotkey){
                high--;
            }
            swap(data,low,high);
            while (low < high && data[low] <= pivotkey){
                low++;
            }
            swap(data,low,high);
        }
        return low;
    }
    private void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}

解法二：O(N*logK)的算法，适合处理海量数据；

 

1.构建一个容积为K的最大堆：每次读入新的数据与容器中最大值比较，若大于堆顶元素，则抛弃该值；若小于堆顶元素，将该值赋值在堆顶，并进行percolateDown操作（时间复杂度为O(logK)）。

2.利用红黑数：红黑树通过把结点分为红、黑两种颜色并根据一些规则确保树在一定程度上是平衡的，从而保证在树中查找、删除、插入操作都是O(logK)时间。

 

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

解法一：利用partition找到数组中的中间值，即为次数超过一半的数字，前提是数组中有符合该条件的数字。

解法二：根据数组特点O(n)的算法：

遍历数组，如果遍历到的下一个数字与之前保存的数字相同，则count++,否则count--;当count为0时，在遍历下一个数字时，将count初始化为1（count的reset时间最关键）。

最后保存的数字一定是次数超过一半的数字（前提是符合条件的数字确实存在）。

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array == null){
            return 0;
        }
        int temp = array[0];
        int count = 1;
        for (int i=1; i<array.length; i++){
            if(count == 0){
                temp = array[i];
                count++;
            }
            else{
                if(temp == array[i]){
                    count++;
                }else{
                    count--;
                }
            }
        }
        int index = 0;
        for(int j=0;j<array.length; j++){
            if(array[j]==temp){
                index++;
            }
        }
        if(index*2 > array.length){
            return temp;
        }else{
            return 0;
        }
    }    
}