冒泡排序

冒泡排序

思路：每遍历一次数组，往上冒一个数字，符合条件时去交换，不断地缩小范围，知道所有的数字都排序完；时间效率O(N^2);

初学C语言版本

<span style="font-size:18px;">#include<stdio.h>		
void sort(int a[], int len)
{
	int i, j, tmp;
	for (i = 0; i<len - 1; i++)
	{
		for (j = 0; j<len - i - 1; j++)
		{
			if (a[j]<a[j + 1])
			{
				tmp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = tmp;
			}
		}
	}
	for (i = 0; i<len; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}
int main()
{
	int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	sort(a, sizeof(a) / sizeof(a[0]));
	return 0;
}</span>

初学C++版本

思路如上：

代码如下：

<span style="font-size:18px;">#include<iostream>
using namespace std;

void BubbleSort(int* arr,int len)
{
	if (arr == NULL && len <= 0)
		return;

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

void TestBubbleSort()
{
	int array[10] = { 2, 9, 5, 8, 3, 6, 1, 7, 4, 0 };
	BubbleSort(array, 10);
	Print(array, 10);
}</span>

C++版本的优化

<span style="font-size:18px;">void BubbleSort_B(int* arr, int len)
{
	if (arr == NULL && len <= 0)
		return;

	bool exchange = false;

	for (int i = 0; i < len - 1; ++i)
	{
		for (int j = 1; j < len-i; ++j)
		{
			if (arr[j-1] > arr[j])
			{
				swap(arr[j-1], arr[j]);
				exchange = true;
			}
		}
		//当排序一趟后exchange=false，没有变化，那说明不用再去排序了,直接返回；
		if (exchange == false)
			return;
	    //反之要将 exchange的初始值false置回来，继续排序；
		exchange = false;
	}
}

//测试用例，通过调试俩个函数调用此数组我们可以看到优化版本只需要排序一趟即O(N),而原生版本时间效率为O(N^2);
void TestBubbleSort_B()
{
	int array[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        //调用上面的初级版本
	BubbleSort(array, 10);
	Print(array, 10);
        //调用优化版本
	BubbleSort_B(array, 10);
	Print(array, 10);
}</span>

c++版本测试结果如下图：