29 最小的K个数

//  2 //题目：输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

//思路一：先找到第K个大的数，如何找到任意第K大的数？
//首先利用快排思想，先随机的选取一个枢轴，然后进行快速排序分成2部分(左边都小于，后面都大于)，最后得到其下标。
//然后利用递归思想，将左边快速排序，将右边快速排序
//--------Partiton思想时间复杂度O（n）--------------
class Solution 
{
public:
    void swap(vector<int> &array, int start, int end)
    {
        int tmp = array[start];
        array[start] = array[end];
        array[end] = tmp;
    }
    int Partition(vector<int> &input,  int start, int end)
    {
        
        int pv = input[start];
        //int tmp;
        while(start < end)
        {
            while ((start < end) && pv < input[end])
            {
                end--;
            }
            //tmp = input[start];
            //input[start] = input[end];
            //input[end] = tmp;
            swap(input, start, end);
            while ((start < end) && pv >= input[start])
            {
                start++;
            }
            //tmp = input[start];
            //input[start] = input[end];
            //input[end] = tmp;
            swap(input, start, end);
        }
        return start;
    }
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) 
    {
        int len = input.size();
        if (len <= 0 || k <=0 ||input.size() < k )
        {
            return {};
        }
        int start = 0;
        int end = len-1;
        int index = Partition(input,start, end);
        while(index != k-1)
        {
            if (index > k-1)
            {
                end = index -1;
                index = Partition(input,start, end);
            }
            else
            {
                start = index+1;
                index = Partition(input,start, end);
            }
        }
        vector<int> tmpVec(input.begin(), input.begin() + k);
        return tmpVec;
    }

};
//调试程序中出现的问题：
//首先做交换函数定义的时候，参数要是引用类型void swap(vector<int> &array, int start, int end)
//第二个，就是快排的时候，做交换swap(input, start, end);
//第三个，快排的枢轴选取为int pv = input[start];
//第四个，数组中任意第K大的数字
    // 找任意的第K大的数字，就要想到快排。
    // int index = Partition(array[], n, int start, int end);
    // while(index != K-1)
    // {
    //     if(index > k-1)
    //     {
    //         end = index-1;
    //         Partition(array[],n, start, end);
    //     }
    //     else
    //     {
    //         start = index+1;
    //         Partition(array[], n, start, end);
    //     }
    // }
// 第五个，使用vector容器的时候，添加元素的时候，不要总是使用push_back();
    // 还可以使用迭代器，
    // 例如：vector<int> tmpVec(input.begin(), input.begin() + k);

//------------采用时间复杂度O(nlogk)的算法，特别适合处理海量数据
//思路：我们可以创建一个大小为K的数据容器来存储最小的K个数字，接下来我们每次从输入的N个整数中读入一个数。
    如果容器中已有数字少于K个，则直接把这次读入的整数放入容器中；如果容器中已有K个数字了，就是容器已满，
    此时我们不能再插入新的数字而只能替换已有的数字。找出这已有K个数字中的最大值，然后拿这次带插入的整数和最大值进行比较。
    如果待插入的值比当前已有的最大值小，则用这个数替换当前已有的最大值；如果待插入的值比当前已有的最大值还要大，
    那么这个数不可能是最小的K个整数之一，于是就抛弃这个整数。
//操作如下：
//1、在K个整数中找到最大数；
//2、有可能在这个容器中删除最大数；
//3、有可能要插入一个新的数字。
//如果用一个二叉树来实现这个数据容器，那么我们能在O(logk)时间内实现操作。因此对于n个输入数字而言，总的时间效率就是O(nlogk)

//常识：想到二叉树来解决问题，就要想到用什么二叉树为好？
//如该题就是每次都需要找到K个整数中最大的数字，很容易想到最大堆。在最大堆中，根节点的值总是大于它的子树中任意结点的值。
//最大堆常识--在O(1)得到已有的K个数字中的最大值，但需要O(logk)时间完成删除和插入操作。

//也可以用红黑树来代替最大堆来实现容器。红黑树通过把结点分为红黑两种颜色并根据一些规则确保树在一定程度上是平衡的，从而保证在红黑书中查找、删除和插入都只需要O(logk)时间。
//------------------红黑树：multiset集合利用仿函数改变排序顺序时间复杂度O（nlogk）-----
class Solution 
{
typedef multiset<int, greater<int>>  intset;
typedef multiset<int ,greater<int>>::iterator setIterator;
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) 
    {
        if (input.size() <= 0 || k<=0 || k > input.size())
        {
            return {};
        }
        intset hasKDigits;//定义红黑树来解决容器
        hasKDigits.clear();//用之前先清空操作
        vector<int>::const_iterator iter = input.begin();
        
        while(iter != input.end())
        {
            if ((hasKDigits.size())<k)
            {
                hasKDigits.insert(*iter);
            }
            else
            {
                //第一个元素是最大值
                setIterator iterGreatest = hasKDigits.begin();
                if (*iter < *(hasKDigits.begin()))
                {
                    hasKDigits.erase(iterGreatest);
                    hasKDigits.insert(*iter);
                }
            }
            ++iter; 
        }
        return vector<int>(hasKDigits.begin(), hasKDigits.end());
    }
};
//总结调试信息：
//第一个，k>input.size()必须要写出来
//第二个，在条件判断语句中，不要
        //   iterEnd = iter.end();
        //   if(iter != iterEnd);而应该写成if(iter!=iter.end())
        //   原因，是因为你在循环条件语句中做迭代器操作，会使迭代器失效。
//第三个，if (*iter < *(hasKDigits.begin())) 尽量不要写if (*iter < *(iterGreatest))
        //原因，在set容器中被删除的迭代器会失效。即不能使用erase(iter++)，而应该使用  
        //for( iter = c.begin(); iter != c.end(); )
        //iter = c.erase(iter);
//第四个，return {};可以写成return vector<int>();
//第五个，返回匿名容器 return vector<int>(hasKDigits.begin(), hasKDigits.end());



//------------------最大堆时间复杂度O（nlogk）-----
class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        int len=input.size();
        if(len <= 0 || k> len || k <= 0)
            return vector <int >();
         
        vector<int> res(input.begin(),input.begin()+k);
        //建堆
        make_heap(res.begin(),res.end());
         
        for(int i=k;i<len;i++)
        {
            if(input[i]<res[0])
            {
                //先pop,然后在容器中删除
                pop_heap(res.begin(),res.end());
                res.pop_back();
                //先在容器中加入，再push
                res.push_back(input[i]);
                push_heap(res.begin(),res.end());
            }
        }
        //使其从小到大输出
        sort_heap(res.begin(),res.end());
         
        return res;
         
    }
};
//总结说明
//使用STL中的最大堆时
// 建立堆，首先要堆原始数据进行备份，通过备份数据建立堆
// vector<int> res(input.begin(),input.begin()+k);
// //建最大堆
// make_heap(res.begin(),res.end());
// //在堆中删除数据--要先调用pop_heap,再在容器中删除数据
// pop_heap(res.begin(),res.end());
// //在堆中添加数据-要先在容器中加入数据，再调用push_heap ()
// push_heap (_First, _Last)
// //堆排序--排序之后就不再是一个合法的heap了
// sort_heap(_First, _Last)

//--------------全排序时间复杂度O（nlogn）--------
class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) 
    {
        vector<int> res;
        if(input.empty()||k>input.size()) 
            return res;
         
        sort(input.begin(),input.end());
         
        for(int i=0;i<k;i++)
            res.push_back(input[i]);
         
        return res;
         
    }
};