快速排序及拓展

1. 快排的递归版本和非递归版本。
2. 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。（29）
3. 输入n个数，找出其中最小的k个数。（30）

1、思路：

　　递归版本：首先随机选定分割数，对数组中小于该分割数的放在左侧，大于该分割数的放在右侧。递归处理左侧和右侧的数字。

 #include <stdio.h>
 #include <stdlib.h>
 #include <exception>
 
 void PrintArray(int* data, int length)
 {
     for (int i = 0; i < length; i++)
         printf("%d ", data[i]);
     printf("\n");
 }
 
 void Swap(int* a, int* b)
 {
      int temp;
      temp = *a;
      *a = *b;
      *b = temp;
 }
 
 int Random(int min, int max)
 {
     int random = rand() % (max - min + 1) + min;
     return random;
 }
 
 int Partition(int* data, int start, int end)
 {
     int index = Random(start, end);
     Swap(&data[index], &data[end]);
     int small = start;
     for (index = start; index < end; index++)
     {
         if (data[index] < data[end])
         {
             Swap(&data[small], &data[index]);
             small++;
         }
     }
     Swap(&data[small], &data[end]);
     return small;
 }
 
 void QuickSort(int* data, int start, int end)
 {
     if (start == end)
         return;
     int index = Partition(data, start, end);
     if (index > start)
         QuickSort(data, start, index - 1);
     if (index < end)
         QuickSort(data, index + 1, end);
 }
 
 int main()
 {
     int test[7] = {23, 13, 49, 6, 31, 19, 28};
     PrintArray(test, 7);
     QuickSort(test, 7, 0, 6);
     PrintArray(test, 7);
 }

　　非递归版本：用数组和下标来模拟栈的操作。

#include <stdlib.h>
#include <stdio.h>
#define SIZE 1000

typedef struct _stackNode
{
    int low;
    int high;
}stackNode;

void PrintArray(int data[], int len)
{
    for (int i = 0; i < len; i++)
        printf("%d ", data[i]);
    printf("\n");
}

void Swap(int* a, int* b)
{
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

int Random(int min, int max)
{
    int r = rand() % (max - min + 1) + min;
    return r;
}

int Partition(int* data, int start, int end)
{
    int index = Random(start, end);
    Swap(&data[index], &data[end]);
    int small = start;
    for (index = start; index < end; index++)
    {
        if (data[index] < data[end])
        {
            Swap(&data[small], &data[index]);
            small++;
        }
    }
    Swap(&data[small], &data[end]);
    return small;
}

void quickSortNoneRecursive(int data[], int len)
{
    int low, high, mid, top;
    stackNode* st;
    if ((st = (stackNode*)malloc(sizeof(stackNode) * SIZE)) == NULL)
    {
        printf("malloc fail!\n");
        exit(0);
    }
    top = 0;
    st[top].low = 0;
    st[top].high = len - 1;

    while (top >= 0)
    {
        low = st[top].low;
        high = st[top].high;
        top--;
        if (low < high)
        {
            mid = Partition(data, low, high);
            if (low < mid)
            {
                top++;
                st[top].low = low;
                st[top].high = mid - 1;
            }
            if (high > mid)
            {
                top++;
                st[top].low = mid + 1;
                st[top].high = high;
            }
        }
    }
    free(st);
}

int main()
{
    int *data = (int*)malloc(sizeof(int) * SIZE);
    for (int i = 0; i < SIZE; i++)
        data[i] = rand() % SIZE;
    PrintArray(data, 50);
    quickSortNoneRecursive(data, SIZE);
    PrintArray(data, 50);
    return 0;
}

2、思路：

　　因为一个数字的出现超过一半，所以他一定会出现在数组的中间。则用快速选择的方法，当找到中间位置即是该数。

 int MoreThanHalfNum_1(int* numbers, int length)
 {
      assert(numbers && length >= 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];
      return result;
 }

3、思路：

　　基于数组的第k个数来做调整，使得比第k个数字小的所有数字都位于数组的左边，比第k个数字大的所有数字都位于数组的右边。但是最小的k个数字是没有排序的，另外也会更改原数组的位置。而且该算法要求所有n个数都要一次性放入内存，这对海量数据不合适。

void GetLeastNumbers_Solution1(int* input, int n, int* output, int k)
{
    if(input == NULL || output == NULL || k > n || n <= 0 || 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];
}