数据结构（2）冒泡排序和简单选择排序

一、冒泡排序

• 先抛出主程序

package Sort;

public class BubbleSort {

	public static void main(String[] args) {
		
		int [] a = {2,5,6,7,1,8,9};
		BubbleSort3( a, 6);
		for(int k = 0; k <= 6; k++){
			System.out.println(a[k]);
		}
	}
	
	static void BubbleSort3(int [] a, int n){
		int i = 0;
		int j = 0;
		boolean flag = true;
		for (i=0; i<=n && flag==true; i++){
			flag = false;
			for (j=n; j>=(i+1); j--){
				if (a[j] < a[j-1]){
					swap(a, j, i);
					flag = true;
				}
			}
		}
	}	
	
	static void BubbleSort2(int [] a, int n){
		int i = 0;
		int j = 0;
		for (i=0; i<=n; i++){
			for (j=n; j>=(i+1); j--){
				if (a[j] < a[j-1]){
					swap(a, j, i);
				}
			}
		}
	}
	
	static void BubbleSort1(int [] a, int n){
		int i = 0;
		int j = 0;
		for (i=0; i<=n; i++){
			for (j=i+1;j<=n; j++){
				if (a[j] < a[i]){
					swap(a, j, i);
				}
			}
		}
	}
	
	static void swap(int [] num,int j, int i){
		int temp;
		temp = num[i];
		num[i] = num[j];
		num[j] = temp;
	}
}

• 冒泡排序初级版本　　

	static void BubbleSort1(int [] a, int n){
		int i = 0;
		int j = 0;
		for (i=0; i<=n; i++){
			for (j=i+1;j<=n; j++){
				if (a[j] < a[i]){
					swap(a, j, i);
				}
			}
		}
	}

　　严格意义上讲，这只是对顺序表作交换排序，时间复杂度分析为O(N2)。而且由于swap操作只要在满足后值小于当前值的情况下就进行，而不是与后续值最小的值进行交换，所以就增多了很多不必要的操作。

•  冒泡排序正式版

	static void BubbleSort2(int [] a, int n){
		int i = 0;
		int j = 0;
		for (i=0; i<=n; i++){
			for (j=n; j>=(i+1); j--){
				if (a[j] < a[j-1]){
					swap(a, j, i);
				}
			}
		}
	}

　　这个版本与上一个的区别是，内循环从j=n开始，那么效果就是，相邻比较，小的上升，这就是冒泡排序的命名由来。这个算法会在每一次外循环中，就会把小的值往顺序表前移。但是在当我们的表已经是有顺序的，只是某几位不同的情况呢？我们有一种优化措施。

• 冒泡排序正式优化版 

	static void BubbleSort3(int [] a, int n){
		int i = 0;
		int j = 0;
		boolean flag = true;
		for (i=0; i<=n && flag==true; i++){
			flag = false;
			for (j=n; j>=(i+1); j--){
				if (a[j] < a[j-1]){
					swap(a, j, i);
					flag = true;
				}
			}
		}
	}

　　可以看到我们加入了一个标志位flag，但上次循环没有改变顺序时，说明此时表已经有序，则停止继续循环。冒泡排序的时间复杂度是O(N2)。 

二、简单选择排序

• 先抛出主程序

package Sort;

public class SimpleSelectSort {

	public static void main(String[] args) {
		int [] a = {8,4,5,2,1,7};
		SimpleSelectSort1(a, 5);
		for(int k = 0; k <= 5; k++){
			System.out.println(a[k]);
		}
	}

	static void SimpleSelectSort1(int [] a, int length){
		int i,j,min;
		for ( i=0; i<=length; i++) {
			min = i;
			for ( j=i+1; j<=length; j++) {
				if (a[j] < a[min]) {
					min = j;
				}
			}
			if(i != min)
				swap(a, i, min);
		}
	}
	
	static void swap(int [] num,int j, int i){
		int temp;
		temp = num[i];
		num[i] = num[j];
		num[j] = temp;
	}
}

• 简单选择排序分析

　　简单排序的原理是通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，和第i个记录交换之。

	static void SimpleSelectSort1(int [] a, int length){
		int i,j,min;
		for ( i=0; i<=length; i++) {
			min = i;
			for ( j=i+1; j<=length; j++) {
				if (a[j] < a[min]) {
					min = j;
				}
			}
			if(i != min)
				swap(a, i, min);
		}
	}

　　简单排序的时间复杂度也是O(N2)。这也是业内为何推崇归并排序和快速排序的原因，因为他们的时间复杂度是O(N)。我会在以后的随笔中介绍。