七种排序算法的实现和总结

最近把七种排序算法集中在一起写了一遍。

注释里有比较详细的说明。

/*排序算法大集合**/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//------------------快速排序------------------//
/*
核心：
如果你知道多少人该站你前面，多少人站你后面，你一定知道你该站哪个位置。
算法：
1.选取分界数，参考这个分界数，大于参考数放在右边，小于的放在左边。
 2.对左右两边的序列分别递归进行1处理
 3.将整个序列合并得到有序结果
 */
//分区函数
int Part(int Array[],int left, int right)
{
    int temp;
    temp = Array[left];//选取第一个数为分界数
    while(left < right)
    {
        while(left < right && Array[right] > temp)
        {
            right--;    
        }
        Array[left] = Array[right];
        while(left<right && Array[left]<=temp)
        {
            left++;
        } 
        Array[right] = Array[left];
    } 
    Array[left] = temp;
    return left;
}
void Quicksort(int Array[],int left, int right)
{
    if(left < right)
    {
        int p= Part(Array, left, right);
        Quicksort(Array, left, p-1);
        Quicksort(Array, p+1, right);
    }
}
//------------------插入排序------------------//
/*
核心：
每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。
算法：
1.初始时，a[0]自成1个有序区，无序区为a[1..n-1]。令i=1
2.将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。
3. i++并重复第二步直到i==n-1。排序完成。
*/
void InsertSort(int a[], int n)
{
    int i, j, temp;
    for(i = 1; i < n; ++i)
    {
        if(a[i] < a[i - 1])
        {
            temp = a[i];
            for(j = i - 1; j >= 0 && a[j] > temp; --j)
                a[j + 1] = a[j];
            a[j + 1] = temp;
        }
    }
}
//------------------选择排序------------------//
/*
核心：
选择排序将数据分为有序区和无序区从无序区选一个最小的元素直接放到有序区的最后。
算法：
1.初始时，数组全为无序区为a[0..n-1]。令i=0
2.在无序区a[i…n-1]中选取一个最小的元素，将其与a[i]交换。交换之后a[0…i]就形成了一个有序区。
3.i++并重复第二步直到i==n-1。排序完成。
*/
void SelectionSort(int a[], int n)
{
    int min, i, j;
    for(i = 0; i < n - 1; ++i)
    {
        min = i;
        for(j = i + 1; j < n; ++j)
            if(a[j] < a[min])
                min = j;

        if(min != i)
        {
            int t = a[i];
            a[i] = a[min];
            a[min] = t;
        }
    }
}

//------------------冒泡排序------------------//
/*
算法：
1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。
2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。
3．N=N-1，如果N不为0就重复前面二步，否则排序完成。
分析：
冒泡排序毕竟是一种效率低下的排序方法，在数据规模很小时，可以采用。数据规模比较大时，最好用其它排序方法。
*/
void swap(int &a, int &b)
{
    int t = a;
    a = b;
    b = t;
}

void BubbleSort(int a[], int n)
{
    int i, j, flag = n;//用flag来记录a[flag]后面的有序数列，便不再比较
    while(flag > 0)
    {
        j = flag;
        flag = 0;
        for(i = 0; i < j; ++i)
            if(a[i] < a[i - 1])
            {
                swap(a[i], a[i - 1]);
                flag = j;
            }
    }
}

//------------------堆排序------------------//
/*
数据结构：
堆实际上是一棵完全二叉树，其任何一非叶节点满足性质：
任何一非叶节点的关键字不大于或者不小于其左右孩子节点的关键字。
堆分为大顶堆和小顶堆，
大顶堆的堆顶的关键字肯定是所有关键字中最大的，
小顶堆的堆顶的关键字是所有关键字中最小的。
算法：
 1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；
 2)将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n]; 
 3)由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，
 然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。
 不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
*/
void HeapAdjust(int a[], int i, int size)//堆的构造
{
    int LeftChild = i * 2;
    int RightChild = LeftChild + 1;
    if(i <= size / 2)
    {
        int max = i;
        if(a[LeftChild] > a[max])
            max = LeftChild;
        if(RightChild <= size && a[RightChild] > a[max])
            max = RightChild;
        if(max != i)
        {
            swap(a[i], a[max]);
            HeapAdjust(a, max, size);
        }
    }
}

void HeapSort(int a[], int size)
{
    int i;
    for(i = size / 2; i >= 1; --i)//堆的初始化
        HeapAdjust(a, i, size);

    for(i = size; i > 1; --i)
    {
        swap(a[1], a[i]);
        HeapAdjust(a, 1, i - 1);
    }
}

//------------------归并排序------------------//
/*
算法：
    并：
        将二个有序数列合并，只要从比较二个数列的第一个数，
        谁小就先取谁，取了后就在对应数列中删除这个数。
        然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。
        将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。
    归：
        当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，
        然后再合并相邻的二个小组就可以了。
        这样通过先递归的分解数列，
        再合并数列就完成了归并排序。
*/
void MergeArray(int a[], int first, int mid, int last, int temp[])
//使a[first...mid]和a[mid+1...last]两部分归并为有序数列
{
    int i = first, j = mid + 1;
    int m = mid, n = last;
    int k = 0;
    while(i <= m && j <= n)
    {
        if(a[i] < a[j])
            temp[k++] = a[i++];
        else
            temp[k++] = a[j++];
    }

    while(i <= m)
        temp[k++] = a[i++];
    while(j <= n)
        temp[k++] = a[j++];

    for(i = 0; i < k; ++i)
        a[first + i] = temp[i];
}

void mergesort(int a[], int first, int last, int temp[])
{
    if(first < last)
    {
        int mid = (first + last) / 2;
        mergesort(a, first, mid, temp);
        mergesort(a, mid + 1, last, temp);
        MergeArray(a, first, mid, last, temp);
    }
}

bool MergeSort(int a[], int n)
{
    int *p = new int[n];
    if(p == NULL)
        return false;        //若内存分配失败则返回FALSE
    mergesort(a, 0, n - 1, p);
    delete []p;
    return true;
}

//------------------LSD基数排序------------------//
/*
算法：
1、分配，先从个位开始，根据位值(0-9)分别放到0~9号桶中
2、收集，再将放置在0~9号桶中的数据按顺序放到数组中
3、重复(1)(2)过程，从个位到最高位
*/
//a[]为常量表，用来取num的第pos位的数字
const int a[] = {1, 1, 10, 100, 1000, 10000,
        100000, 1000000, 10000000, 100000000, 1000000000};

int GetNumInPos(int num, int pos)//取num的第pos位的数字
{
    return ((num / a[pos]) % 10);
}

int FindMaxDigit(int array[], int size)//找到数组中最大的位数
{
    int cnt = 1, x = 10;
    for(int i = 0; i < size; ++i)
    {
        while(array[i] >= a[cnt + 1])
            ++cnt;
    }
    return cnt;
}

void RadixSort(int array[], int size)
{
    int *radixArrays[10]; //分配0~9的桶子空间
    int i;
    int KeyNum = FindMaxDigit(array, size);
    for(i = 0; i < 10; ++i)
    {
        radixArrays[i] = (int *)malloc(sizeof(int) * (size + 1));
        radixArrays[i][0] = 0;        //此处记录各组数据的个数
    }

    int pos;
    for(pos = 1; pos <=KeyNum; ++pos)
    {
        for(i = 0; i < size; ++i)
        {
            int num = GetNumInPos(array[i], pos);
            int index = ++radixArrays[num][0];
            radixArrays[num][index] = array[i];
        }
        //收集
        int j;
        for(i = 0, j = 0; i < 10; ++i)
        {
            for(int k = 1; k <= radixArrays[i][0]; ++k)
                array[j++] = radixArrays[i][k];
            radixArrays[i][0] = 0;
        }
    }
    for(i = 0; i < 10; ++i)
        free(radixArrays[i]);        //释放分配的空间
}

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

int main(void)
{
    int  array1[] = {12, 14, 54, 5, 6, 3, 9, 8, 47, 89}, array2[15];
    
    memcpy(array2, array1, sizeof(array1));
    int Left = 0, Right = 9;
    Quicksort(array2, Left, Right);
    printf("快速排序：
");
    PrintArr(array2, 10);
    
    memcpy(array2, array1, sizeof(array1));
    InsertSort(array2, 10);
    printf("插入排序：
");
    PrintArr(array2, 10);
    
    memcpy(array2, array1, sizeof(array1));
    SelectionSort(array2, 10);
    printf("选择排序：
");
    PrintArr(array2, 10);
    
    memcpy(array2, array1, sizeof(array1));
    BubbleSort(array2, 10);
    printf("冒泡排序：
");
    PrintArr(array2, 10);
    
    //堆排序是从a[1]开始排所以要对数组进行一下调整 
    int i;
    for(i = 0; i < 10; ++i)
        array2[i + 1] = array1[i];
    HeapSort(array2, 10);
    printf("堆排序：
");
    for(i = 0; i < 10; ++i)
        printf("%d  ", array2[i + 1]);
    printf("
");
    
    memcpy(array2, array1, sizeof(array1));
    MergeSort(array2, 10);
    printf("归并排序：
");
    PrintArr(array2, 10);
    
    memcpy(array2, array1, sizeof(array1));
    RadixSort(array2, 10);
    printf("基数排序：
");
    PrintArr(array2, 10);
    
    return 0;
}