如果不限定條件的話，這個問題還是很好解決的，但是當我們要求時間複雜度為O(N)，空間複雜度為O(1)時，問題就沒那麼好解決了。

    簡單的思路就是，建立一個大小為K=100的小堆，調整好，然後從K開始拿十萬個數據一個一個跟堆頭比較，如果比堆頭大，就入堆，然後調整成最小堆，一直迴圈到第N=100000個數據。

void AdjustDown(int* _a, size_t size,int i)
{
    int parent = i;
    int child = 2 * parent + 1;
    while (child < size)
    {
        //找出孩子中的最小值
        if (child + 1 < size && _a[child + 1] < _a[child])
        {
            ++child;
        }
        //與父節點做比較
        if (_a[parent] > _a[child])
        {
            swap(_a[parent], _a[child]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

//找N個數據中的最大K個
int* GetKTop(int* a,size_t size,size_t n)
{
    int* _a = new int[size];
    for (int i = 0; i < size; i++)
    {
        _a[i] = a[i];
    }

    //建堆
    for (int i = (size - 2) / 2; i >= 0; i--)
    {
        AdjustDown(_a, size,i);
    }

    for (int i = 0; i < n - size; i++)
    {
        if (_a[0] < a[size + i])
        {
            _a[0] = a[size + i];
            AdjustDown(_a, size, 0);
        }
    }
    return _a;
}

void _AdjustDown(int* a, size_t size, int i)
{
    int parent = i;
    int child = 2 * parent + 1;
    while (child < size)
    {
        //找出孩子中的最大值
        if (child + 1 < size && a[child] < a[child + 1])
        {
            ++child;
        }
        //拿父節點與最大子節點做比較
        if (a[parent] < a[child])
        {
            swap(a[parent], a[child]);
            parent = child;
            child = 2 * parent + 1;
        }
        else
        {
            break;
        }
    }
}