排序（一）

一、冒泡排序

基本思想：每次循环将最大的值放在最后，冒泡排序最优的时间复杂度是O(n)， 最差的时间复杂度O(n^2) ，平均时间复杂度O(n^2)，空间复杂度为O(1)，是稳定排序。

伪代码：

for i=A.length-1 downto 1 //这里只需到A[1]，因为A[1]确定了A[0]自然就确定了
   for j=0 to i-1
        if A[j]>A[j+1]
            exchange A[i] and A[j+1]

java代码实现：

public static void bubbleSort(int A[]) {
	for(int i = A.length-1; i > 0; i--){
		for(int j = 0; j < i ;j++){
			if(A[j] > A[j+1]){
				int temp = A[j];
				A[j] = A[j+1];
				A[j+1] = temp; 
			}
		}
	}
}

改进：

如果某次循环中没有发生交换，则说明已经排好序，以后的排序就可以不执行，直接退出，为此加上一个flag，标识此次循环是否发生了交换。

public static void bubbleSort(int A[]) {
	for(int i = A.length-1; i > 0; i--){
		boolean flag = false;
		for(int j = 0; j < i ;j++){
			if(A[j] > A[j+1]){
				int temp = A[j];
				A[j] = A[j+1];
				A[j+1] = temp;
				flag = true;
			}
		}
		if(!flag)
			break;
	}
}
}

二、插入排序

基本思想：把一个数组划分为两部分，一个有序，一个无序，每次从无序列当中取出一个插入到有序列中的正确位置。插入排序的最优的时间复杂度是O(n)， 最差的时间复杂度O(n^2) ，平均时间复杂度O(n^2)，空间复杂度为O(1)，是稳定排序。

伪代码：

for i=1 to A.length-1
    key=A[i]
    j=i-1
    while j>=0 and key<A[j]
        A[j+1]=A[j]
        j=j-1
    A[j+1]=key         

java代码：

public static void insertSort(int A[]){
	for(int i = 1; i < A.length; i++){
		int key = A[i];
		int j = i-1;
		while(j >= 0 && key < A[j]){
			A[j+1] = A[j];
			j--;
		}
		A[j+1] = key;
	}
}

三、选择排序

基本思想：从所有值中选出最小与第一个元素交换位置，然后从剩下的元素中找出最小的放在第二个位置，依此类推。选择排序的最差时间复杂度O(n^2) ，平均时间复杂度O(n^2)，空间复杂度为O(1)，是稳定排序。

伪代码：

for i=0 to A.length-2
   k=i
   for j=i+1 to A.length-1
      if A[j]<A[k]
        k=j
   if k!=i
      exchange A[i] and A[k]

java代码：

public static void selectSort(int A[]){
	for(int i = 0; i < A.length-2; i++){
		int k = i;
		for(int j = i+1; j < A.length-1; j++){
			if(A[j] < A[k])
				k=j;
		}
		if(k!=i){
			int temp = A[k];
			A[k] = A[i];
			A[i] = temp;
		}
	}
}