剑指offer---最小的K个数（堆和partition算法两种思路解决）

题目30：最小的K个数（leetcode链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/）

题目分析

方法1：对数组进行排序，在选出前K个即可（采用堆排序时间复杂度为NlogN,快排的时间复杂度为NlogN）

方法2（特别适合n特别大的时候）

建一个含有K个节点的堆，由于要找的是最小的K个数，因此应该建大堆（大堆的特点就是根节点的元素是堆中的最大节点），遍历数组如果有比根节点小的元素就将其替换掉并对堆重新进行调整。

时间复杂度分析：建堆的时间复杂度为K*logK,向下调整算法的时间复杂度为logK,当每一个比堆的根节点小的节点插入堆中时都需要进行向下调整，因此总的时间复杂度为N*logK(忽略建堆的时间复杂度)

算法特点分析：1）不会改变原有数据结构  2）适合海量数据的处理（当所给元素个数特别大的时候，采用这个方法可以在较小的空间中对较多的数进行选择）  3）时间复杂度相比第一种方法要小

方法3：使用Partition算法

Partition算法是根据快排衍生出来的一种算法，该算法可以实现从数组中随机选择一个数组，将数组中所有小于它的元素位于它的左边大于它的元素位于右边。代码实现如下：

int Partition(vector<int>& nums,int start,int end)
{
	//产生一个在start和end之间的随机数作为中间值进行比较
	int index = (rand() % (end - start)) + start + 1;
	//将最右边的值和index处的值交换
	swap(&nums[end],&nums[index]);

	int small = start - 1;//small及其前边的数都是小于end处的值
	for (int i = start; i < end; i++)
	{
		if (nums[i] < nums[end])
		{
			++small;//让small指向比nums[end]大的值，需要时进行交换
			if (small != i)
				swap(&nums[i], &nums[small]);
		}
	}
	++small;
	//将end放入合适的位置
	swap(&nums[end],&nums[small]);

	//返回small
	return small;
}

使用Partition算法，当我们所选中的数恰巧是第K个数时，那么经过依次调整，数组的前K个数就是最小的k个数；如果选中的数下标大于K，则第k个数在左边否则在右边，这样递归的查找直到找到第k个数，此时数组的前k个数就是最小的k个数。

代码描述

方法2

class Solution {
public:
    void swap(int* a,int*b)
    {
        int tmp = *a;
        *a = *b;
        *b = tmp;
    }
    //向下调整算法,调整大堆
    void AdjustDown(vector<int>& arr,int root,int size)
    {
        //根节点为下标为root,左孩子节点为：root*2+1 右孩子节点为：root*2+2
        int child = root*2 + 1;
        while(child < size)
        {
            //child为左右孩子中较大的一个
            if(child + 1 < size && arr[child] < arr[child + 1])
                ++child;
            //如果孩子节点大于父节点，交换
            if(arr[root] < arr[child])
            {
                swap(&arr[root],&arr[child]);
                root = child;
                child = root*2 + 1;
            }
            else
                break;
        }
    }
    //建堆
    void CreateHeap(vector<int>& heap,int size)
    {
        //从最后一个非孩子节点开始使用向下调整算法
        for(int i = (size - 2)/2;i >= 0;i--)
        {
            AdjustDown(heap,i,size);
        }
    }
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        //建含有K个节点的大堆
        vector<int> ret;
        if(k <= 0 || arr.size() <= 0)
            return ret;
        for(int  i = 0;i < k;i++)
        {
            ret.push_back(arr[i]);
        }
        CreateHeap(ret,k);
        //遍历数组，调整堆
        for(int i = k;i < arr.size();i++)
        {
            if(arr[i] < ret[0])
            {
                ret[0] = arr[i];
                AdjustDown(ret,0,k);
            }
        }
        return ret;
    }
};

方法3

class Solution {
public:
    void swap(int* a, int* b)
    {
	    int tmp = *a;
	    *a = *b;
	    *b = tmp;
    }
    int Partition(vector<int>& nums,int start,int end)
    {
        if(start < end)
        {
            //产生一个在start和end之间的随机数作为中间值进行比较
            int index = (rand() % (end - start)) + start + 1;
            //将最右边的值和index处的值交换
            swap(&nums[end],&nums[index]);

            int small = start - 1;//small及其前边的数都是小于end处的值
            for (int i = start; i < end; i++)
            {
                if (nums[i] < nums[end])
                {
                    ++small;//让small指向比nums[end]大的值，需要时进行交换
                    if (small != i)
                    swap(&nums[i], &nums[small]);
                }
            }
            ++small;
            //将end放入合适的位置
            swap(&nums[end],&nums[small]);

            //返回small
            return small;
        }
        return 0;
    }
    void _getLeastNumbers(vector<int>& arr,int k,int start,int end)
    {
        int index = Partition(arr,start,end);

        while(index != k-1)
        {
            if(index < k-1)
                index = Partition(arr,index+1,end);
            else if(index > k-1)
                index = Partition(arr,start,index-1);
        }
    }
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int> ret;
        if(k <= 0 || arr.size() <= 0)
            return ret;
        _getLeastNumbers(arr,k,0,arr.size()-1);
        for(int i = 0;i < k;i++)
        {
            ret.push_back(arr[i]);
        }
        return ret;
    }
};