基础排序算法复习

1.计数排序
计数排序的四个步骤:
a.初始化c[0…k]为0；
b.对于每个元素a[i]， c[ a[i] ]++，c记录a中各个元素出现的次数，比如{1, 1, 3}中，c[1] = 2, c[2] = 0, c[3] = 1；
c.对于i=1 to k， c[i] = c[i] + c[i-1]，此时c记录小于等于i的元素的个数，c[1] = 2, c[2] = 2, c[3] = 3；
d.按照计数结果存放元素到b中：对i = n-1 to 0，b[ c[ a[i] ] ] = a[i], c[ a[i] ]–；
最后一步稍复杂，首先，采用倒序，可以使得程序较为稳定，在处理相等元素时，不用将元素位置换来换去，a[i]指的是第i个元素，c[a[i]]记录元素值小于等于a[i]的个数，b[ c[ a[i] ]]则表示把元素a[i]排在了它应当在的位置.
代码如下：

void COUNTINGSORT(int *A, int *B, int array_size, int k)
{
    int  i, value, pos;
    int *C = new int[k + 1];
    for (i = 0; i <= k; i++)
    {
        C[i] = 0;
    }
    for (i = 0; i< array_size; i++)
    {
        C[A[i]] ++;
    }
    for (i = 1; i <= k; i++)
    {
        C[i] = C[i] + C[i - 1];
    }
    for (i = array_size - 1; i >= 0; i--)
    {
        value = A[i];
        pos = C[value];
        B[pos - 1] = value;
        C[value]--;
    }
}

2.选择排序
选择排序的算法比较简单，每次只要找到未排序序列中的最小值与当前位置的元素交换即可，在写算法的时候要注意边界。选择排序的时间复杂度为O(n^2),并且是不稳定的排序算法。
代码如下:

void SelectSort(int r[],int n) {
    if (n < 1 || r == NULL)return;
    int index, j, temp = 0;
    for (int i = 0; i <n; i++)
    {
        index = i;
        for (j = i + 1; j <=n; j++)
        {
            if (r[j] < r[index])index = j;
            if (index != i)
            {
                 temp = r[i];
                r[i] = r[index];
                r[index] = temp;
            }
        }
    }
}

3.冒泡排序:
冒泡排序算法应该时最简单的一种排序算法，但是时间复杂度也比较高，为O(n^2),每次只要将最大或最小元素排在最右边即可。
代码:

void BubbleSort(int r[], int n) {
    if (r == NULL || n < 1)return;
    for (int i = 0; i <n; i++) {
        for (int j = i; j < n; j++)
        {
            if (r[i] > r[j])
            {
                int temp = r[j];
                r[j] = r[i];
                r[i] = temp;
            }
        }
    }
}

有关基数排序，这篇文章值得学习。