Patition函数用法

Patition函数
       实现快速排序算法的关键在于先在数组中选择一个数字，接下来把数组中的数字分为两部分，比选择的数字小的数字移动到数组的左边，比选择的数字大的数字移动到数组的右边。这个函数可以如下实现：

int Parition(int data[ ],int length, int start, int end)
{
    if(data == NULL || length <=0 || start <0 || end >= length)
          throw new std::exception("Invalid Parameters");
    int index = RandomInRange(start, end);
    Swap(&data[index], &data[end]);

    int small = start -1;
    for (index = start; index < end; ++index){
        if (data[index] < data[end]){
            ++small;
        if (small != index)
            Swap(&data[index], &data[small]);
        }
    }
    ++ small;
    Swap(&data[small], &data[end]);
    return small;
}

快速排序的简洁实现

void QuickSort (int data[ ], int legth, int start, int end)
{
    if (start == end) return;
    int index = Partition(data, length, start, end);
    if (index > start)
        QuickSort(data, length, start, index - 1);
    if (index < end)
        QuickSort(data, length, index +1, end);
}

题目：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。
解法：基于Partition函数的O（n）算法
       数组中有一个数字出现的次数超过了数组长度的一半。如果把这个数组排序，那么排序之后位于数组中间的数字一定就是那个出现次数超过数组长度一半的数字。也就是说，这个数字就是统计学上的中位数，即长度为n的数组中第n/2大的数字。我们有成熟的O（n）算法得到数组中任意第k大的数字。
如果选中的数字的下标刚好是n/2，那么这个数字就是数组的中位数。如果它的下标大于n/2,那么中位数应该位于它的左边，我们可以接着在它的左边部分的数组中查找。如果它的下标小于n/2，那么中位数应该位于它的右边，我们接着可以在它的右边部分的数组中查找，这是一个典型的递归问题。

int Parition(int data[ ],int length, int start, int end)
{
    if(data == NULL || length <=0 || start <0 || end >= length)
        throw new std::exception("Invalid Parameters");
    int index = RandomInRange(start, end);
    Swap(&data[index], &data[end]);
    int small = start -1;
    for (index = start; index < end; ++index){
        if (data[index] < data[end]){
             ++small;
        if(small != index)
             Swap(&data[index], &data[small]);
        }
    }
    ++ small;
    Swap(&data[small], &data[end]);
    return small;
}

int MoreThanHalfNum(int *numbers, int length)
{
    if (CheckInvalidArray(numbers, length))
        return 0;
    int middle = length >> 1;
    int start = 0;
    int end = length - 1;
    int index = Partition(numbers,length,start,end);
    while (index != middle) {
        if (index > middle) {
            end = index - 1;
            index = Partition(numbers,length,start,end);
        }
        else {
            start = index + 1;
            index = Partition(numbers,length,start,end);
        }
    }
    int result = numbers[middle];
    if (!CheckMoreThanHalf(numbers, length, result))
        result = 0;
    return result;
}

题目：输入n个整数，找出其中最小的k个数。例如，输入4，5，1，6，2，7，3，8这8个数字，则最小的4个数字是1，2，3，4。
        这道题最简单的思路莫过于把输入的n个整数排序，排序之后位于最前面的k个数就是最小的k个数。这种思路的时间复杂度是O（nlogn）。
解法：O（n）的算法，只有当我们可以修改输入的数组时可用
       可以使用基于Partition函数解决这个问题。如果基于数组的第k个数字来调整，使得比第k个数字小的所有数字都位于数组的左边，比第k个数字大的所有数字都位于数组的右边。这样调整之后，位于数组中左边的k个数字就是最小的k个数字（这k个数字不一定是排序的）。下面是参考代码:

void GetLeastNumbers(int *input, int n, int *output, int k)
{
    if (input == NULL || output == NULL || n <= 0 || k > n || k <= 0)return;
    int start = 0;
    int end = n - 1;
    int index = Partition(input,n,start,end);
    while (index != k - 1) {
        if (index > k - 1) {
            end = index - 1;
            index = Partition(input,n,start,end);
        }
        else {
            start = index + 1;
            index = Partition(input,n,start,end);
        }
    }
    for (int i = 0; i < k; ++i)
        output[i] = input[i];
}

采用这种思路是有限制的。我们需要修改输入的数组，因为函数Partition会调整数组中数字的顺序。