排序算法：实现，平均复杂度，最好…

1：冒泡算法

    1.1 实现

void bubbleSort(int *a, int n)

{

        int i;

        int j;

        int flag;

        for(i = 0; i < n; i++)

        {

                flag = 0;

                for(j = 0; j < n - i - 1; j++)

                        if(a[j] > a[j + 1])

                        {

                                swap(a[j], a[j + 1]);

                                flag = 1;

                        }

                if(flag == 0)

                        break;

        }

}

    1.2 平均复杂度

            n轮循环，每一轮循平均的复杂度为n/2，故总的复杂度为：O（n * n）

    1.3 最好情况

          当输入序列已经排序好的时候，一轮冒泡下来没有交换过位置，直接退出程序，复杂度为：O（n）

    1.4 最坏情况

          当输入序列是你逆序的时候，每一次比较都要进行交换，复杂度为：O（n*n）

    1.5 稳定性

          a = b的时候，由于只有大于才做交换，故a，b的位置没有机会交换，所以，冒泡排序是稳定的

2：插入排序

    2.1 实现

void insertSort(int *a, int n)

// 该算法是最初始的实现，顺序比较前面元素，效率较低

{

        int tmp;

        int i, j, k;

        for(i = 0; i < n; ++i)

        {

                tmp = a[i];

                for(j = 0; j < i; ++j)

                {

                        if(tmp < a[j])

                        {

                                for(k = i; k > j; --k)

                                {

                                        a[k] = a[k - 1];

                                }

                                a[j] = tmp;

                                break;

                        }

                }

        }

}

void simpleInsertSort(int *a, int n)

PS： 以下代码引自《数据结构与算法分析：C++描述》（第3版）

// 该算法插入时，逆序比较前面一排序元素，效率较高

{

        int tmp;

        int i, j;

        for(i = 1; i < n; ++i)

        {

                for(j = i, tmp = a[i]; a[j - 1] > tmp && j > 0; --j)

                {

                        a[j] = a[j - 1];

                }

                a[j] = tmp;

        }

}

    2.2 平均复杂度

          插入的次数为n，而每次插入操作需要移动的数据平均复杂度为O（n），故总的平均复杂度为：O（n*n）

    2.3 最好情况

          当输入的序列已经有序的时候，只需要进行比较，不用移动数据，故其复杂度仅仅为O（n）

    2.4 最坏情况

          当输入的序列为逆序的时候，每次插入都要移动之前所有元素，故其复杂度为O（n*n）

    2.5 稳定性

          如果a=b，则当a在前面时候，其必然比b先确定，而后面b再插入时，必然在a后面，故该算法稳定

3：shell排序

    3.1 实现

PS： 以下代码引自《数据结构与算法分析：C++描述》（第3版）

void shellSort(int *a, int n)

// 该程序使用的增量为shell增量，最坏情况为O（n*n）

// 更好的效果可以选择Hibbard增量：2^k - 1

{

        int tmp;

        int gap, i, j;

        for(gap = n / 2; gap > 0; gap /= 2)

        {

                for(i = gap; i < n; ++i)

                {

                        tmp = a[i];

                        j = i;

                        for(; j >= gap && tmp < a[j - gap]; j -= gap)

                                a[j] = a[j - gap];

                        a[j] = tmp;

                }

        }

}

    3.2 平均复杂度

          由于使用的增量（程序中的gap）不同，导致的复杂度也不同，常用的有Hibbard增量，基于模拟的结果被认为是O（n^（5/4））

    3.3 最好情况

          当输入序列已经有序的时候，每一次增量向前比较都立即不满足条件而退出，故只有前面两层循环起到了作用，复杂度为O（nlogn）

    3.4 最坏情况

          使用Hibbard增量的时候，该排序算法的最坏情况复杂度为O（n^(3/2)）（已经被证明）

    3.5 稳定性

          由于不同的gap间隔对应的数据是独自比较的，所以，如果a=b但是不在同一个gap间隔上，显然就会出现前后颠倒的情况，即是说，该算法不稳定

4：堆排序

    4.1 实现

PS： 以下代码引自《数据结构与算法分析：C++描述》（第3版）

void percDown(int *, int , int );

void heapSort(int *a, int n)

{

        int i, j;

        // build heap

        for(i = n / 2; i >= 0; i--)

                percDown(a, i, n);

        // delete Max

        for(j = n - 1; j > 0; j--)

        {

                swap(a[0], a[j]);

                percDown(a, 0, j);

        }

}

inline int leftChild(int i)

{

        return 2 * i;

}

void percDown(int *a, int i, int n)

{

        int child;

        int tmp;

        for(tmp = a[i]; leftChild(i) < n; i = child)

        {

                child = leftChild(i);

                if(child != n - 1 && a[child] < a[child + 1])

                        child++;

                if(tmp < a[child])

                        a[i] = a[child];

                else

                        break;

        }

        a[i] = tmp;

}

    4.2 平均复杂度

          排序的过程主要取决于后期的调整（前期的建立堆的过程只需要O（logn * logn）），其复杂度为O（nlongn）

    4.3 最好情况

          对于堆排序，无论输入的序列是否有序或者其他的条件，建立和调整堆的复杂度都不会受到影响，故最好情况的复杂度为O（nlogn）

    4.4 最坏情况

          对于堆排序，无论输入的序列是否有序或者其他的条件，建立和调整堆的复杂度都不会受到影响，故最坏情况的复杂度为O（nlogn）

    4.5 稳定性

          不稳定，暂时没有想到好的说明例子，但是如果画出其二叉树的表示图，就可以直观地看出，a=b时，如果b后于a的插入，其将在a的后面，但是经过percDown调整后，b有可能被调到比a更高的层次（也就是a的前面了），所以，顺序可能存在调换情况。

5：归并排序

    5.1 实现

PS： 以下代码引自《数据结构与算法分析：C++描述》（第3版）

void merge(int *, int *, int , int , int );

void mergeSort(int *, int *, int , int );

void simpleMergeSort(int *a, int n)

{

        int *b = new int[n];

        mergeSort(a, b, 0, n - 1);

        delete b;

}

void mergeSort(int *a, int *tmp, int left, int right)

{

        if(left < right)

        {

                int center = (left + right) / 2;

                mergeSort(a, tmp, left, center);

                mergeSort(a, tmp, center + 1, right);

                merge(a, tmp, left, center + 1, right);

        }

}

void merge(int *a, int *tmp, int leftPos, int rightPos, int rightEnd)

{

        int leftEnd = rightPos - 1;

        int tmpPos = leftPos;

        int numElements = rightEnd - leftPos + 1;

        while(leftPos <= leftEnd && rightPos <= rightEnd)

        {

                if(a[leftPos] < a[rightPos])

                        tmp[tmpPos++] = a[leftPos++];

                else

                        tmp[tmpPos++] = a[rightPos++];

        }

        while(leftPos <= leftEnd)

                tmp[tmpPos++] = a[leftPos++];

        while(rightPos <= rightEnd)

                tmp[tmpPos++] = a[rightPos++];

        for(int i = 0; i < numElements; i++, rightEnd--)

                a[rightEnd] = tmp[rightEnd];

}

    5.2 平均复杂度

          对于各种输入序列，归并排序的处理过程都是一样的，T（1） = 1, T（N） = T（N/2） + N，不难求得最后的复杂度T（N）为O（NlogN）

    5.3 最好情况

          与平均情况一致

    5.4 最坏情况

          与平均情况一致

    5.5 稳定性

          由于没有发生数据交换，所有当a=b的时候，a一开始如果在b前面，则其每一次合并后仍然在b前面，故该排序算法是稳定的

6：快速排序

    6.1 实现

PS： 以下代码引自《数据结构与算法分析：C++描述》（第3版）

int median3(int *, int , int);

void quickSort(int *, int , int);

void simpleQuickSort(int *a, int n)

{

        quickSort(a, 0, n - 1);

}

void quickSort(int *a, int left, int right)

{

// if number of elements less than 10, used insertSort

        if(left + 10 > right)

                insertSort(a, right - left + 1);

        else

        {

                int pivot = median3(a, left, right);

                int i = left, j = right;

                for(;;)

                {

                        while(a[++i] < pivot);

                        while(a[--j] > pivot);

                        if(i < j)

                                swap(a[i], a[j]);

                        else

                                break;

                }

                // reset pivot

                swap(a[i], a[right - 1]);

                quickSort(a, left, i - 1);

                quickSort(a, i + 1, right);

        }

}

// find out median of three elements and set pivot

int median3(int *a, int left, int right)

{

        int center = (left + right) / 2;

        if(a[center] < a[left])

                swap(a[left], a[center]);

        if(a[right] > a[left])

                swap(a[left], a[right]);

        if(a[right] < a[center])

                swap(a[center], a[right]);

        // place pivot at position right - 1

        swap(a[center], a[right - 1]);

        return a[right - 1];

}

    6.2 平均复杂度

            平均复杂度为O（NlogN）

    6.3 最好情况

            每次都刚好选到了一个区间段的中位数，相当于归并排序的过程，复杂度为O（NlongN）

    6.4 最坏情况

            每次都刚好选到了最小的元素作为主元，导致极度的不平衡，退化为插入排序的最坏情况了，复杂度为O（N^2）

    6.5 稳定性

            当a=b>pivot且a在b前面的时候，由于从后面开始遍历，故b会先于a被替换到pivot的前面，这样，b就变成了在a的前面，也就是说，ab位置对调，故该排序算法不稳定

7：直接选择排序

    7.1 实现

void selectSort(int *a, int n)

{

        int i, j;

        int tmp;

        for(i = 0; i < n; ++i)

        {

                tmp = i;

                for(j = i + 1; j < n; j++)

                        if(a[j] < a[tmp])

                                tmp = j;

                swap(a[i], a[tmp]);

        }

}

    7.2 平均复杂度

          每次循环需要访问n-i个元素得到最小值，故其总的比较次数为（N+1）*N/2，故复杂度为O（N^2）

    7.3 最好情况

          与平均情况一致

    7.4 最坏情况

          与平均情况一致

    7.5 稳定性

          假设a=b，并且a在b的前面，而在某轮循环中最小值在b的后面，而次最小值需要跟a交换，那么该轮过后，b就在a前面了，所以，该排序算法不稳定