冒泡排序算法详解

目标：将数组按从小到大排序

冒泡排序有两种比较方法，一种是从前向后比较，一种是从后向前比较。

从前向后排序举例

初始：4    5    2    1

第一趟：（4比5小，不交换）4    5   2    1

                （5比2大，交换）    4    2    5    1

                （5比1大，交换）    4    2    1    5

第二趟：（4比2大，交换）    2    4    1    5

                （4比1大，交换）    2    1    4    5

第三趟：（2比1大，交换）    1    2    4    5

算法实现（已经过运行测试）

void BubbleSort(int A[],int n)
{
	for(int i=0;iA[j+1])
			{
				int tmp=A[j];
				A[j]=A[j+1];
				A[j+1]=tmp;
			}
		}
	}
}

从后向前排序举例

初始：4    5    2    1

第一趟：（1比2小，交换）    4    5    1    2

                （1比5小，交换）    4    1    5    2

                （1比4小，交换）    1    4    5    2

第二趟：（2比5小，交换）    1    4    2    5

                （2比4小，交换）    1    2    4    5

第三趟：（5比4大，不交换）1    2    4    5

算法实现（已经过测试运行）

void BubbleSort(int A[],int n)
{
	for(int i=0;ii;j--)//从后向前比较
		{
			if(A[j-1]>A[j])
			{
				int tmp=A[j];
				A[j]=A[j-1];
				A[j-1]=tmp;
			}
		}
	}
}

算法性能

时间复杂度：最好情况，数组本身有序，不必进行交换操作，但是比较操作仍会进行，O(n2)；

                        最坏情况，数组逆序，O(n2)；

                        平均情况，O(n2)。

空间复杂度：仅使用了常数个辅助单元，因此空间复杂度为O(1)。

稳定性：稳定。

其他：冒泡排序所产生的有序子序列一定是全局有序的。每趟冒泡结束之后，都会有一个元素被放到最终位置上。

改进

如果数组初始状态已经有序，或者进行若干趟冒泡之后已经有序，则不必进行不必要的比较操作。

改进后的算法（以从前向后冒泡为例）：

void BubbleSort(int A[],int n)
{
	for(int i=0;iA[j+1])
			{
				int tmp=A[j];
				A[j]=A[j+1];
				A[j+1]=tmp;
				flag=true;
			}
		}
		if(flag==flase) //本趟冒泡没有发生数据交换，说明数组已经有序
			return;
	}
}

改进后的时间复杂度

最好情况，数组本身有序，O(n)；

最坏情况，数组逆序，O(n2)；

平均情况，O(n2)。