排序算法集合 -1

1. 冒泡排序 Bubble Sort

冒泡排序的执行时间和空间复杂度： 平均情况与最差情况为O(n2)， 存储空间为O(1)。

/*************************************************************************
    > File Name: bubbleSort.c
    > Author: 
    > Mail: 
    > Created Time: 2016年09月04日 星期日 11时52分20秒
 ************************************************************************/

#include<stdio.h>

void bubbleSort(int *a, int n);
void testSort(int *a, int len, void (*sort)(int*, int));

int main()
{
    int a[] = {2, 1, 5, 6, 9, 6, 3};
    testSort(a, sizeof(a) / sizeof(int), bubbleSort);
    return 0;
}

void bubbleSort(int *a, int n) {
    if (NULL == a || n <= 1)
        return;
    int i, j, temp;

    for (i = 0; i < n - 1; i++) { // n个数需要n-1趟
        for (j = 1; j < n-i; j++) { // 从最开始到最后一位未归位
            if (a[j] < a[j-1]) {
                temp = a[j];
                a[j] = a[j-1];
                a[j-1] = temp;            
            }    
        }    
    }
}

void testSort(int *a, int len, void (*sort)(int*, int)) {
    int i;
    printf("Sort Before: ");
    for (i=0; i < len; i++) { 
        printf("%d ", a[i]);
    }
    printf("\n");

    sort(a, len);

    printf("Sort After: ");
    for (i=0; i < len ; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
}

输出结果：

Sort Before: 2 1 5 6 9 6 3 
Sort After: 1 2 3 5 6 6 9 

2. 选择排序 Selection Sort

选择排序的执行时间和空间复杂度： 平均情况与最差情况为O(n2)， 存储空间为O(1)。

简单而低效， 线性逐一扫描数组元素，从中选出最小的元素，将它移到最前面（也就是与最前面的元素交换）。然后再次线性扫描数组，找到第二小的元素，并且移到前面。如此反复，直到全部元素各归其位。

有一些优势，最多只需要(n-1)次交换，在数据元素的移动操作与比较操作相比开销更大的情况下，选择排序可能比其他算法更好。选择排序是一个原地排序算法，典型的排序算法不是稳定的。

void bubbleSort(int *a, int n);
void selectionSort(int *a, int n);
void testSort(int *a, int len, void (*sort)(int*, int));

int main() {
    int a[] = {2, 1, 5, 6, 9, 6, 3};
    //testSort(a, sizeof(a) / sizeof(int), bubbleSort);
    testSort(a, sizeof(a) / sizeof(int), selectionSort);
    return 0;
}

void selectionSort(int *a, int n) {
    if (NULL==a || n<=1)
        return;

    int i, j, min;
    for (i=0; i<n-1; i++) {
        min=i; // find the smallest from index i;
        for (j = i+1; j<n; j++) {
            if (a[j] < a[min])
            min = j;           
        }

        if (min != i) { // swap
            int temp = a[min];
            a[min] = a[i];
            a[i] = temp;
        }      
    }
}

// 另一种简化规整的实现

// Method 2
void swap(int *a, int index1, int index2) {
    if (index1 != index2) {
        int tmp = a[index1];
        a[index1] = a[index2];
        a[index2] = tmp;
    }
}

// Find the position of minimum value at the start from
int findMinimum(int *a, int start, int len) {
    int minPos = start;
    for (int i=start+1; i<len; i++) {
        if (a[i] < a[minPos])
            minPos = i;
    }

    return start;
}

// Start a subset of the array starting at the given index
void selectionSort(int *a, int start, int len) {
    if (start < len-1) {
        swap(a, start, findMinimum(a, start, len));
        selectionSort(a, start+1, len);
    }
}

3. 归并排序 Merge Sort

归并排序的执行时间和空间复杂度： 平均情况与最差情况为O(nlog(n))， 存储空间看情况而定。

// Lpos = start of left half, Rpos = start of right half
void merge(int a[], int tmpArray[], int Lpos, int Rpos, int RightEnd) {
    int LeftEnd = Rpos - 1;
    int NumElement = RightEnd - Lpos + 1;
    int TmpPos = Lpos;
    int i;

    while (Lpos<=LeftEnd && Rpos<=RightEnd) {
        if (a[Lpos]<=a[Rpos])
            tmpArray[TmpPos++] = a[Lpos++];
        else
            tmpArray[TmpPos++] = a[Rpos++];
    }

    while (Lpos<=LeftEnd)
        tmpArray[TmpPos++] = a[Lpos++];
    while (Rpos<=RightEnd)
        tmpArray[TmpPos++] = a[Rpos++];

    // copy tmpArray back
    for (i=0; i<NumElement; i++, RightEnd--)
        a[RightEnd] = tmpArray[RightEnd];
}

void mergeSortSUB(int *a, int tmpArray[], int Left, int Right) {
    int Center;
    if (Left < Right) {
        Center = (Left + Right) / 2;
        mergeSortSUB(a, tmpArray, Left, Center);
        mergeSortSUB(a, tmpArray, Center+1, Right);
        merge(a, tmpArray, Left, Center+1, Right);
    }
}

void mergeSort(int *a, int len) {
    int* tmpArray = (int*)malloc(sizeof(int) * len);

    if (NULL != tmpArray) {
        mergeSortSUB(a, tmpArray, 0, len -1);
        free(tmpArray);
    } else 
        printf("alloc error\n");
}