几种排序算法的实现和比较

冒泡排序

稳定性: 稳定
最坏时间复杂度O(N^2)
最好时间复杂度O(N)
平均时间复杂度O(N^2)

void bubble_sort(int *a, int n)
{
    for(int i = 0; i < n; ++i)
    {
        int flag = false;
        for(int j = n - 2; j >= 0; --j)
        {
            if(a[j] > a[j + 1])
            {
                _swap(a[j], a[j+1]);
                flag = true;
            }
        }
        if(!flag)
            break;
    }
}

插入排序

稳定性: 稳定
平均时间复杂度O(N^2)
最坏时间复杂度O(N^2)
最好时间复杂度O(N)

void insert_sort(int *a, int n)
{
    for(int i = 1; i < n; i++)
    {
        int j = i - 1;
        int key = a[i];
        while(j >= 0 && a[j] > key)
        {
            a[j + 1] = a[j];
            --j;
        }
        a[j + 1] = key;
    }
}

选择排序

稳定性: 不稳定
平均时间复杂度O(N^2)
最坏时间复杂度O(N^2)
最好时间复杂度O(N^2)

void select_sort(int *a, int n)
{
    for(int i = 0; i < n; ++i)
    {
        int min = a[i];
        int index = i;
        for(int j = i + 1; j < n; j++)
        {
            if(a[j] < min)
            {
                min = a[j];
                index = j;
            }
        }
        if(index != i)
            _swap(a[index], a[i]);
    }

}

快速排序

稳定性: 不稳定
最差时间复杂度O(N^2)
最好时间复杂度O(NlogN)
平均时间复杂度O(NlogN)

void quick_sort(int *a, int l, int r)
{
    if(l < r)
    {
        int i = l;
        int j = r;
        int x = a[i];
        while(i < j)
        {
            while(i < j && a[j] >= x)
                --j;
            if(i < j)
                a[i] = a[j];
            while(i < j && a[i] <= x)
                ++i;
            if(i < j)
                a[j] = a[i];
        }
        a[i] = x;
        quick_sort(a, l, i - 1);
        quick_sort(a, i + 1, r);
    }
}

希尔排序

稳定性: 不稳定
平均时间复杂度O(NlogN)

void shell_sort(int *a, int n)
{

    for(int grap = n/2; grap > 0; grap /= 2)
    {
        for(int i = 0; i <= grap; ++i)
        {
            for(int j = i + grap; j < n; j += grap)
            {
                int temp = a[j];
                int k = j - grap;
                while(k >= 0 && a[k] > temp)
                {
                    a[k + grap] = a[k];
                    k -= grap;
                }
                a[k + grap] = temp;
            }
        }
    }
}

归并排序

稳定性: 稳定
平均时间复杂度O(NlogN)
最坏时间复杂度O(NlogN)
最好时间复杂度O(NlogN)
空间复杂度O(N)

void _merge(int *a, int left, int mid, int right)
{
    int len = right - left + 1;
    int *temp = new int[len];
    int i = left;
    int j = mid + 1;
    int k = 0;
    while(i <= mid && j <= right)
    {
        if(a[i] < a[j])
            temp[k++] = a[i++];
        else
            temp[k++] = a[j++];
    }
    while(i <= mid)
    {
        temp[k++] = a[i++];
    }
    while(j <= right)
    {
        temp[k++] = a[j++];
    }

    for(k = 0; k < len; ++k)
        a[k + left] = temp[k];
    delete []temp;
}

void merge_sort(int *a, int left, int right)
{
    if(left < right)
    {
        int mid = (left + right) / 2;
        merge_sort(a, left, mid);
        merge_sort(a, mid + 1, right);
        _merge(a, left, mid, right);
    }
}

堆排序

稳定性: 不稳定
平均时间复杂度O(NlogN)
最坏时间复杂度O(NlogN)
最好时间复杂度O(NlogN)

void adjust_heap(int *a, int holeIndex, int len)
{
    int temp = a[holeIndex];
    int child = 2 * holeIndex + 1;
    while(child < len)
    {
        if(child + 1 < len && a[child] < a[child + 1])
            child++;
        if(a[child] > temp)
        {
            a[holeIndex] = a[child];
            holeIndex = child;
            child = 2 * holeIndex + 1;
        }
        else
            break;
    }
    a[holeIndex] = temp;
}

void build_heap(int *a, int len)
{
    for(int i = (len - 1) / 2; i >= 0; --i)
        adjust_heap(a, i, len);
}

void heap_sort(int *a, int len)
{
    build_heap(a, len);
    for(int i = len - 1 ; i >= 0; --i)
    {
        _swap(a[0], a[i]);
        adjust_heap(a, 0, i);
    }
}