bubble_sort

现在来讲下冒泡排序。

基本思想：从一端开始，逐个比较相邻的两个元素，发现倒序即交换。

贴下我的代码：(升序排列）

代码一：（每次都首先将未排序的最小数冒到数组最前端）

[cpp] view plain copy print ?

1. #include<iostream>
2. using namespace std;
4. /*从数组末端开始*/
5. void bubble_sort(int a[],int n)
6. {
7. int i,j,temp;
9. for(i=0;i<n-1;i++) //i<n与i<n-1等效
10. {
11. for(j=n-1;j>i;j--)
12. {
13. if(a[j]<a[j-1])
14. {
15. temp=a[j];
16. a[j]=a[j-1];
17. a[j-1]=temp;
18. }
19. }
20. }
21. }
23. int main()
24. {
25. int i,n;
26. int a[100];
28. while(cin>>n,n)
29. {
30. for(i=0;i<n;i++)
31. cin>>a[i];
33. bubble_sort(a,n);
35. for(i=0;i<n;i++)
36. cout<<a[i]<<" ";
38. cout<<endl<<endl;
39. }
41. return 0;
42. }

#include<iostream>
using namespace std;

/*从数组末端开始*/
void bubble_sort(int a[],int n)  
{
	int i,j,temp;

	for(i=0;i<n-1;i++)    //i<n与i<n-1等效
	{
		for(j=n-1;j>i;j--)  
		{
			if(a[j]<a[j-1])
			{
				temp=a[j];
				a[j]=a[j-1];
				a[j-1]=temp;
			}
		}
	}
}

int main()
{
	int i,n;
	int a[100];

	while(cin>>n,n)  
	{
		for(i=0;i<n;i++)
			cin>>a[i];

		bubble_sort(a,n);

		for(i=0;i<n;i++)
			cout<<a[i]<<" ";

		cout<<endl<<endl;
	}

	return 0;
}

代码二：（每次都将未排序的最大数首先冒到数组最后）

[cpp] view plain copy print ?

1. /*从数组首部开始*/
2. void bubble_sort(int a[],int n)
3. {
4. int i,j,temp;
6. for(i=0;i<n-1;i++)
7. {
8. for(j=0;j<n-1-i;j++)
9. {
10. if(a[j]>a[j+1])
11. {
12. temp=a[j];
13. a[j]=a[j+1];
14. a[j+1]=temp;
15. }
16. }
17. }
18. }

/*从数组首部开始*/
void bubble_sort(int a[],int n)  
{
	int i,j,temp;

	for(i=0;i<n-1;i++)   
	{
		for(j=0;j<n-1-i;j++)  
		{
			if(a[j]>a[j+1])
			{
				temp=a[j];
				a[j]=a[j+1];
				a[j+1]=temp;
			}
		}
	}
}

以上的两个代码都是"中规中矩"的，还有可以改善的余地。比如说，如果在某一趟比较中发现已经没有对换了，则说明数组已经有序了。可以结束。以下

代码中引入bool exchanged，来辅助判断某一次排序是否进行了交换。

代码三如下：

[cpp] view plain copy print ?

1. void bubble_sort(int a[],int n)
2. {
3. int i,j,temp;
4. bool exchanged; //用来判断每次是否进行了遍历
6. i=1;
7. do
8. {
9. exchanged=false;
11. for(j=n-1;j>=i;j--)
12. {
13. if(a[j]<a[j-1])
14. {
15. temp=a[j];
16. a[j]=a[j-1];
17. a[j-1]=temp;
19. exchanged=true;
20. }
21. }
23. i++;
24. }while(i<=n-1 && exchanged==true);
25. }

void bubble_sort(int a[],int n)   
{
	int i,j,temp;
	bool exchanged;   //用来判断每次是否进行了遍历

	i=1;
	do
	{
		exchanged=false;
		
		for(j=n-1;j>=i;j--)
		{
			if(a[j]<a[j-1])
			{
				temp=a[j];
				a[j]=a[j-1];
				a[j-1]=temp;

				exchanged=true;
			}
		}

		i++;
	}while(i<=n-1 && exchanged==true);
}

再来分析下吧：

以升序排列来分析哈。基本思想是从最后一个元素开始两两比较，如果后面的数比前面的数小，则调换两数次序，直至比较到最后一个数。此时则确定

一个最小数排到最前面了。那么，下次比较则可以不再比较该数了。就是代码中的第二个for循环，for(j=n-1;j>i;j--)。第一个for循环则是记录已有多少个数已在

确定位置了。

Attiontion:

①冒泡排序也是种原地排序，只需temp这一辅助空间。

②冒泡排序的时间性能是O(n^2)，空间性能是O(n)。

③冒泡排序每次可以确定一个数最终位置。如升序冒泡，每次第二个for循环都可以确定该次的最小数，并将该最小数放在最前面。

欢迎拍砖！