冒泡排序法

冒泡排序法的基本思想：（以升序为例）含有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);
}

测试结果：