快速排序和归并排序的迭代实现

一、 快速排序

     快速排序是经典的排序算法，其设计思路是递归的，下面是一段示例代码。

void sort(int A[], int n) 
{
    if (n <= 0) return;

    int i = 0;
    for (int j = 0; j < n; j++) 
        if (A[j] < A[0])
            swap(A[j], A[++i]);
    swap(A[0], A[i]);

    sort(A, i);
    sort(A + i + 1, n - i - 1);
}

     这段代码能够对大小为 n 的数组 A 原地排序。第3行检查 n 是否合法，若不合法，直接退出。 第 5-9 行实现partition操作 (见于 CLRS，即《算法导论》)，第 11-12 行分别对partition后得到的两个部分递归调用 sort。

     这3行是不能缺少的，否则会导致递归无法退出。

     递归实现的快速排序在平均情况下会创建深度为 log n 的调用栈。

     现在介绍快速排序的迭代实现，在进一步说明之前，先列出其中一种实现的源代码。

void sort(int A[], int start, int end) // sort A[start ... end]
{
    int s = 0, stack[64];

    stack[s++] = start, stack[s++] = end;

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

        if (start >= end) 
            continue;

        int i = partition(A, start, end);
        if (i - start >= end - i) {
            stack[s++] = start, stack[s++] = i - 1;
            stack[s++] = i + 1, stack[s++] = end;
        } else {
            stack[s++] = i + 1, stack[s++] = end;
            stack[s++] = start, stack[s++] = i - 1;
        }
    }
}

    这段代码实现了对子数组A[start ... end] 的快速排序。这里除了下面几个关键的地方外，不对这段代码做过多的文字说明。 

    1. stack 数组的大小为 64， 理论上可以对大小为 2 ^ 31 （2 ^ 30 + 2 ^ 29 + ... + 2 ^ 0 + 2 ^ 0） 的数组进行排序。

    2. 第 15-21行，对分割后两个子数组大小的比较是必不可少的。若非如此，我们可能需要大小为 2n （n = end - start + 1）的 stack 才能完成排序（请考虑以第一个元素作为锚点分割，初始数组有序的情形）。

二、归并排序

     数组归并排序的递归实现原理上比快速排序更简单，通常使用递归的方法实现，算法的时间复杂度为O(nlogn)，在每次归并时需要额外的空间（O(n)），这里不再说明。我们知道，对链表，我们也可以采用归并排序的方法对其排序，时间复杂度为 O(nlogn)。链表归并排序的实现同样有递归和迭代两种。

     链表排序的递归实现源代码： 

struct list_node 
{
    struct list_node* next;
    int data;
};

int list_len(list_node* l) 
{
    int ret = 0;
    while (l != NULL) {
        l = l->next;
        ++ret;
    }
    return ret;
}

void merge(list_node* l1, list_node* l2) 
{
    list_node p;
    list_node *q = &p;
    while (l1 != NULL && l2 != NULL) {
        if (l1->data < l2->data) {
            q->next = l1;
            l1 = l1->next;
        } else {
            q->next = l2;
            l2 = l2->next;
        }
        q = q->next;
    }
    q->next = l1 != NULL ? l1 : l2;
    return p.next;
}

list_node* sort(list_node* l) {
    int n = list_len(l);
    if (n <= 1)
        return;

    list_node *p = l, *q = NULL;
    for (int i = n / 2; i > 0; i--) 
        q = p, p = p->next;
    q->next = NULL;

    l = sort(l);
    p = sort(p);

    return merge(l, p);
}

        上述算法的思路： 计算链表的长度，在链表长度的一半的位置将链表切分成两个链表，对这两个链表分别排序，最后将它们合并为一个链表。

        SGI STL中针对list<>容器实现了sort方法，在这一方法中采用的是归并排序的迭代形式，下面代码展示出了算法的具体实现。（算法思路待续）

#include <iostream>
#include <list>
#include <iterator>
#include <algorithm>
using namespace std;

template <class T>
void print(list<T>& lst) {
    ostream_iterator<T> o_iter(cout, " ");
    copy(lst.begin(), lst.end(), o_iter);
    cout << endl;
}

void sort(list<int> &lst) {
    int size = lst.size();
    if (size != 0 && size != 1) {
    　　list<int> carry;
    　　list<int> counter[64];
    　　int fill = 0;
    　　while (!lst.empty()) { 
        　　carry.splice(carry.begin(), lst, lst.begin());
       　　 int i = 0;
        　　while(i < fill && !counter[i].empty()) {
                counter[i].merge(carry);
                carry.swap(counter[i++]);
            }
            carry.swap(counter[i]);         
            if (i == fill) ++fill;
        } 

        for (int i = 1; i < fill; ++i) 
        　　counter[i].merge(counter[i-1]);
        lst.swap(counter[fill-1]);
    }
}

int main() {
    list<int> lst {1, 4, 2, 8, 5, 7};
    sort(lst);
    print(lst);
    return 0;
}