快速排序实现

  作为统治世界的算法之一，快速排序（Quick Sort）在很多场合下都能发挥其强大的力量。数据量在百万级别的数据量对快速排序来说是小case.  该算法最早是由图灵奖获得者Tony Hoare设计出来的，他在形式化方法理论以及ALGOL60编程语言的发明中都有卓越的贡献。可以认为是冒泡排序的升级，它们都属于交换排序类。即通过不断的比较和移动交换来实现排序，只不过它的实现，增大了记录的比较和移动的距离，将关键字较大的记录移到后面，较小的移到前面，从而减少了总的比较次数和移动交换次数。

  在实现快速排序的过程中，我们一般需要关注2点，一个是枢纽元的选择（即pivot）,  还有很重要的一点是两个工作指针的初始位置以及他们的运动方向。

  看了很多的实现，pivot一般来说有4种选择：

  1、头元素        Hoare版本的做法,《数据结构与算法分析》中不推荐将第一个元素作为枢纽元，因为在输入是预排序或反序时，会产生糟糕的分割。 其实尾元素道理是一样的。

  2、尾元素        Lomuto版本的做法

  3、中间元素（包括3数中值分割法(median of three), 即取3个关键字先进行排序，将中间数作为pivot, 一般取左中右3个数，也可以随机选取。）

  4、随机选择   排除随机数生成的代价外，是一种不错的选择

 

快排一般来说有以下两个版本，

  一、先看看Hoare最原始的版本，pivot为首元素，其工作指针分别在一头一尾，这完全就一稍微快一点的冒泡嘛= =：

具体实现如下：

#include <stdio.h>

void swap(int *a, int *b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

void printArray(int a[], int num)
{
    for (int i = 0; i < num; i++)
    {
         printf("%d ", a[i]);
    }
     printf("\n");
}

int HoarePartition(int a[], int p, int r)
{
    int key = a[p], i = p - 1, j = r + 1;
    
     // fprintf(fp, "key = %d, i = %d, j = %d\n", key, i, j);

    while (1)
    {
        do 
        {
            j--;
        }while (a[j] > key);
        do
        {
            i++;
        }while (a[i] < key);

        if (i < j)
        {
            swap(&a[i], &a[j]);
        }
        else
        {
            return j;
        }
    }

}

void QuickSort(int a[], int start, int end)
{
    int q;
     // fprintf(fp, "new sort: start = %d, end = %d\n", start, end);

    if (end <= start)
        return;

    q = HoarePartition(fp, a, start, end);
    QuickSort(fp, a, start, q);
    QuickSort(fp, a, q + 1, end);
}

int main()
{
    int a[] = {3, 4, 12, 56, 0, 6, 9, 10, 6, 23};
 
    printf(fp, "init array: \n");
    printArray(fp, a, 10);

    QuickSort(fp, a, 0, 9);
    printf(fp, "sorted: \n");
    printArray(fp, a, 10);
            
    fclose(fp);
    return 0;
}

二、Nico Lomuto也提出了一个版本，pivot为尾元素，工作指针都从左向右一个方向运动，个人觉得这个更好理解：

Lomuto-Partition(A, p, r)
x = A[r]
i = p - 1
for j = p to r - 1
    if A[j] <= x
        i = i + 1
        swap( A[i], A[j] )
swap( A[i+1], A[r] )
return i + 1

QUICKSORT(A, p, r)
 if p < r
    then q ← Lomuto-Partition(A, p, r)   
         QUICKSORT(A, p, q - 1)
         QUICKSORT(A, q + 1, r)

分析如下，摘自算法导论：

两种实现方式对比的话, Lomuto版本更加简单易实现，但不适用于库函数的实现，因为它使用了更多的交换次数。更加细节参见：StackExchange

 

下面是Lomuto版本的实现代码：

#include <stdio.h>

void printArray(int a[], int num)
{
    for (int i = 0; i < num; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}

void swap(int *a, int *b)
{
    int t;
    t = *a;
    *a = *b;
    *b = t;
}


int Partition(int data[], int p, int r)
{
    int key = data[r];
    int i = p - 1;

    for (int j = p; j < r; j++)
    {
        if (data[j] <= key)
        {
            i++;
            swap(&data[i], &data[j]);
        }
    }
    swap(&data[i+1], &data[r]);

    return i + 1;
}

void QuickSort(int data[], int start, int end)
{
    if (start < end)
    {
        int q = Partition(data, start, end);
        QuickSort(data, start, q - 1);
        QuickSort(data, q + 1, end);
    }

}

int main()
{
    int a[] = {3, 32, 13, 8, 9, 9, 12, 33, 41};

    printf("init array:\n");
    printArray(a, 9);
    QuickSort(a, 0, 8);
    printf("sorted:\n");
    printArray(a, 9);
}

 

下面讨论一下变种版本：

三、一种Hoare变种实现，pivot为首元素，工作指针从两边向中间移动，也比较好理解

#include <stdio.h>

void swap(int *a, int *b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

void printArray(int a[], int num)
{
    for (int i = 0; i < num; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}

int HoarePartition(int a[], int p, int r)
{
    int key = a[p], i = p, j = r;
    
    // fprintf(fp, "key = %d, i = %d, j = %d\n", key, i, j);

    while (i < j)
    {
        while (a[j] >= key && i < j)
            j--;
        a[i] = a[j];

        while (a[i] <= key && i < j)
            i++;
        a[j] = a[i];
    }

    a[i] = key;
    return i;
}

void QuickSort(int a[], int start, int end)
{
    int q;
    // fprintf(fp, "new sort: start = %d, end = %d\n", start, end);

    if (end <= start)
        return;

    q = HoarePartition(a, start, end);
    QuickSort(a, start, q - 1);
    QuickSort(a, q + 1, end);
}

int main()
{
    int a[] = {3, 4, 12, 56, 0, 6, 9, 10, 9, 23};
 
     // FILE *fp = fopen("log", "w+");

    printf("init array: \n");
    printArray(a, 10);
    printf("sorted: \n");
    QuickSort(a, 0, 9);
    printArray(a, 10);

            
    fclose(fp);
    return 0;
}

从上面的实现可以看出，快速排序用到的都是递归实现，这在数据量较大的情况下容易出现堆栈溢出，我在一次测试中使用10万的数据量出现了溢出（有点疑惑不过程序确认崩溃了），

所以当你的需求是比较大的数据量时，非递归的实现就会派上用场了。这里看到有人用STL stack实现发现速度明显比较慢（快速排序算法的几种实现的性能对比：递归实现和非递归实现），所以还是建议自己实现堆栈比较靠谱：）

#include <stdio.h>

void swap(int *a, int *b)
{

    int temp;

    temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int *a, int start, int end)
{
    int key = a[end];
    int i = start - 1;
    int j = start;

    for ( ; j < end; j++)
    {
        if (a[j] < key)
        {
            i++;
            swap(&a[i], &a[j]);
        }
    }
    swap(&a[++i], &a[j]);

    return i;
}

void QuickSort(int *a, int size)
{
    int stack[100];
    int top = -1;
    int start, end;
    stack[++top] = 0;
    stack[++top] = size - 1;

    while (top > 0)
    {
        end = stack[top--];
        start = stack[top--];

        int i = partition(a, start, end);

        if (start < i - 1)
        {
            stack[++top] = start;
            stack[++top] = i - 1;
        }
        if (i + 1 < end)
        {
            stack[++top] = i + 1;
            stack[++top] = end;
        }
    }
}

void printArray(int *a, int num)
{
    for (int i = 0; i < num; i++)
    {
        printf("%d ", a[i]);
    }

    printf("\n");
}

int main()
{
    int a[] = {3, 45, 15, 6, 9, 15, 90, 17, 28, 10};

    printf("init array:\n");
    printArray(a, 10);

    QuickSort(a, 10);

    printf("after sorted:\n");
    printArray(a, 10);
    return 0;
}

那么单链表可以使用快速排序吗？答案是可以，实现思路是使用两个链表，一个保存比key小的值，另一个保存比key大的，最后把两个链表再连接起来。这样通过调整指针的指向即可实现排序效果。

#include <stdio.h>
#include <time.h>

typedef struct tagLinkNode
{
    int value;
    struct tagLinkNode *next;
}LinkNode;


void QuickSort(LinkNode** head, LinkNode** end)
{
    LinkNode *head1, *head2, *end1, *end2;
    head1 = head2 = end1 = end2 = NULL;

    if (*head == NULL || *end == NULL)
    {
        // printf("head or end is null\n");
        return;
    }
    // printf("head=%d, end=%d\n", (*head)->value, (*end)->value);

    LinkNode *p, *pre1, *pre2;
    p = pre1 = pre2 = NULL;

    int key = (*head)->value;
    // printf("key is %d\n", key);

    // divide head node
    p = (*head)->next;
    (*head)->next = NULL;

    while (p != NULL)
    {
        // value less than key
        if (p->value < key)
        {
            // printf("less than key!\n");
            if (!head1)
            {
                head1 = p;
                pre1 = p;
            }
            else
            {
                pre1->next = p;
                pre1 = p;
            }
            p = p->next;
            pre1->next = NULL;
        }
        // value larger than key
        else
        {
            // printf("larger than key!\n");
            if (!head2)
            {
                head2 = p;
                pre2 = p;    
            }
            else
            {
                pre2->next = p;
                pre2 = p;
            }
            p = p->next;
            pre2->next = NULL;
        }

    }    

    // printf("merge it\n");
    end1 = pre1;
    end2 = pre2;

    // recuring
    QuickSort(&head1, &end1);
    QuickSort(&head2, &end2);

    // printf("after recuring\n");
    /* conjection 2 List */
    // if 2 List all exist
    if (head1 && head2)
    {
        end1->next = *head;
        (*head)->next = head2;
        *head = head1;
        *end = end2;
    }
    // only left list exist
    else if (head1)
    {
        end1->next = *head;
        *end = *head;
        *head = head1;
    }
    // only right list exist
    else if (head2)
    {
        (*head)->next = head2;
        *end = end2;
    }
}

void addList(LinkNode **head, LinkNode *node)
{
    node->value = rand() % 50 + 1;
    node->next = (*head)->next;

    (*head)->next = node;

    printf("%d ", node->value);
}

LinkNode* getListFirst(LinkNode *head)
{
    return head->next;
}

LinkNode* getListLast(LinkNode *head)
{
    LinkNode *p = head;
    while (p->next != NULL)
    {
        p = p->next;
    }

    return p;
}

void printList(LinkNode *head)
{
    LinkNode *p = head->next;

    while (p != NULL)
    {
        printf("%d ", p->value);
        p = p->next;
    }
}

int main()
{
    srand(time(NULL));
    int i;
    LinkNode linkArray[10];

    LinkNode *listHead;
    listHead = (LinkNode *) malloc(sizeof(LinkNode));
    if (NULL == listHead)
    {
        printf("listHead malloc failed\n");
        return -1;
    }
    listHead->value = 10;
    listHead->next = NULL;

    printf("init array: \n");
    for (i = 0; i < 10; i++)
    {
        addList(&listHead, &linkArray[i]);
    }
    printf("\n");

    LinkNode *first, *end;
    first = getListFirst(listHead);
    end = getListLast(listHead);
    QuickSort(&first, &end);
    listHead->next = first;   // important

    printf("after sorted: \n");
    printList(listHead);
    printf("\n");
}

总结：快速排序是一种平均复杂度在O(nlogn)的算法，最坏在已有序的情况下为O(n²),是不稳定的排序算法。

 

这里有一篇快排细节优化的文章，对pivot的选取以及存在相同元素的情况做了详述。