冒泡排序（C语言版）

先说说冒泡排序的思想：

       1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

       2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

       3.针对所有的元素重复以上的步骤，除了最后一个。

       4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

稳定性和复杂度:

       冒泡排序是稳定的排序算法,时间复杂度最坏为O(n2),平均为O(n2),空间复杂度O(1).

       至于是不是稳定需要看你的算法实现时是怎么样判断两个数需要交换的,如果你判断交换的条件有判等的话就是不稳定的,如果你判断交换的条件没有判等的话就是稳定的.

       下面是我用C语言实现的冒泡排序，如果有什么不对的地方请大家指出来，谢谢。

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

void swap(int *value1, int *value2);
void bubbleSort(int array[], int size);
void printArray(int *array, int size);

int main(int argc, char const *argv[])
{
	int size = 0;
    scanf("%d", &size);
    assert(size > 0);

    int *array = (int *)calloc(size, sizeof(int));
    int i = 0;
    for (i = 0; i < size; ++i) {
        scanf("%d", &array[i]);
    }

    bubbleSort(array, size);
    printArray(array, size);

    free(array);
	return 0;
}

void bubbleSort(int array[], int size)
{
    assert(array != NULL && size > 0);

    int i = 0;
    int j = 0;
    for (i = size - 1; i > 0; --i) {
        for (j = 0; j < i; ++j) {
            if (array[j] > array[j + 1]) {
                swap(&array[j], &array[j + 1]);
            }
        }
    }
}

void swap(int *value1, int *value2)
{
    int tempValue;
    tempValue = *value1;
    *value1 = *value2;
    *value2 = tempValue;
}

void printArray(int *array, int size)
{
    assert(array != NULL && size > 0);
    
    int i = 0;
    for (i = 0; i < size; ++i) {
        printf("%d ", array[i]);
    }
    printf("\n");
}

-----------------------------------------------------新增--------------------------------------------------------------

2014年10月18日

       今天忽然想到可以稍微优化一下冒泡排序的效率，就在这里写出来。

       其实上数据结构课程的时候老师说过可以在一趟冒泡排序里加入一个变量用来判断当前数列是否已经有序，其原理是如果上一次的交换次数为零说明任意两个元素之间的顺序是有序的，也就是说整个数列整体是有序的，所以就不需要再进行一趟冒泡排序了。

       基于以上思想，我写了以下的程序：

void bubbleSort2(int array[], int size)
{
    assert(array != NULL && size > 0);

    int swapTimes = 0;
    int i = 0;
    int j = 0;
    for (i = size - 1; i > 0; --i) {
        swapTimes = 0;
        for (j = 0; j < i; ++j) {
            if (array[j] > array[j + 1]) {
                swap(&array[j], &array[j + 1]);
                ++swapTimes;
            }
        }

        //若一遍冒泡没有交换过一次则说明数列已经是有序的
        if (swapTimes == 0) {
            break ;
        }
    }
}

       优化后的冒泡排序对于数列原本就已经大部分有序的情况效果比较好，但是如果是随即的数列在运行时间上和原来未优化的版本相比并没有多大的改进：

排序随机的10000个1000以内的数，未优化版本耗时139ms，优化版本耗时123ms；

排序随机的100000个1000以内的数，未优化版本耗时14531ms，优化版本耗时13883ms。

总体上没有什么区别。

其他八种排序算法的博客：

常见的9种内部排序(C语言实现)