冒泡排序法

冒泡排序法的基本思想：（以升序为例）含有n个元素的数组原则上要进行n-1次排序。对于每一趟的排序，从第一个数开始，依次比较前一个数与后一个数的大小。如果前一个数比后一个数大，则进行交换。这样一轮过后，最大的数将会出现在最末位的数组元素。第二轮则去掉最后一个数，对前n-1个数再按照上面的步骤找出最大数，该数将称为倒数第二的数组元素.....n-1轮过后，就完成了排序。

最坏排序次数为：n(n-1)/2

时间复杂度：O(n^2)

冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素，使较大的数据下沉，较小的数据上升。

函数代码：

#include <stdio.h>

void bubbleSort(int data[], const int length)
{
if ((data == NULL) || (length < 1))
return;

for (int i = length; i > 1; i--)
{
for (int j = 1; j < i; j++)
{
if (data[j - 1] > data[j])
{
int temp = data[j];
data[j] = data[j - 1];
data[j - 1] = temp;
}
}
}
}

测试用例：
#include "BubbleSort.h"
#include <stdio.h>

void Test(char* testName, int data[], int length, int expectedData[])
{
printf("%s begins: ", testName);
bubbleSort(data, length);

if (data == NULL)
{
if (expectedData == NULL)
printf("passed!\n");
else
printf("failed!\n");
}
else
{
for (int i = 0; i < length; i++)
{
if (data[i] != expectedData[i])
{
printf("failed!\n");
return;
}
}
printf("passed!\n");
}
}

void main()
{
int data1[] = {0, 1, 2, 3, 4, 5};
int expectedData1[] = {0, 1, 2, 3, 4, 5};
Test("Test1", data1, sizeof(data1) / sizeof(int), expectedData1);

int data2[] = {5, 4, 3, 2, 1, 0};
int expectedData2[] = {0, 1, 2, 3, 4, 5};
Test("Test2", data2, sizeof(data2) / sizeof(int), expectedData2);

int data3[] = {-3, 5, -1, 0, 3};
int expectedData3[] = {-3, -1, 0, 3, 5};
Test("Test3", data3, sizeof(data3) / sizeof(int), expectedData3);

int data4[] = {1};
int expectedData4[] = {1};
Test("Test4", data4, sizeof(data4) / sizeof(int), expectedData4);

int data5[] = {1, 1, 1, 1, 1, 1};
int expectedData5[] = {1, 1, 1, 1, 1, 1};
Test("Test5", data5, sizeof(data5) / sizeof(int), expectedData5);

//int data6[] = {a, 1, 2, 3, 4, 5};
//int expectedData6[] = {1, 1, 1, 1, 1, 1};
//Test("Test6", data6, sizeof(data6) / sizeof(int), expectedData6);

Test("Test7", NULL, 0, NULL);
}

测试结果：