三种排序算法

一、冒泡排序

package com.light.springboot.algorithm;

import com.alibaba.fastjson.JSON;

public class SortMaopao {

	public static void main(String[] args) {
		int[] intArray = {0,1,2,3,4};
		System.out.println(JSON.toJSON(maopaoSort(intArray)));
	}
	
	/**
	 * 冒泡排序法
	 * 冒泡排序是由两个for循环构成，第一个for循环的变量 i 表示总共需要多少轮比较，第二个for循环的变量 j 表示每轮参与比较的元素下标【0,1，......，length-i】
	 * 因为每轮比较都会出现一个最大值放在最右边，所以每轮比较后的元素个数都会少一个，这也是为什么 j 的范围是逐渐减小的。相信大家理解之后快速写出一个冒泡排序并不难。
	 * @param array
	 * @return
	 */
	public static int[] maopaoSort(int[] array){
		int count = 0;//排序轮数
		boolean flag = true;//设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
		
		//i为一共要比较多少轮
		for (int i = 1; i < array.length; i++) {
			
			//j为参与比较的数组下标范围，每比较一轮，最大值放在最右边，下一轮参与比较的元素就减一
			for (int j = 0; j < array.length-i; j++) {
				
				//如果前面的数比后面的大，就交换两个数据的位置
				if (array[j] > array[j+1]) {
					int tmp = array[j];
					array[j] = array[j+1];
					array[j+1]=tmp;
					flag = false;//有交换，说明比较没完成
				}
			}
			count++;//计数
			
			//flag为true，说明本轮比较无交换，排序已完成
			if (flag) {
				break;
			}
		}
		System.out.println("排序" + count + "轮");
		return array;
	}
}

　　

冒泡排序解释：

　　冒泡排序是由两个for循环构成，第一个for循环的变量 i 表示总共需要多少轮比较，第二个for循环的变量 j 表示每轮参与比较的元素下标【0,1，......，length-i】，因为每轮比较都会出现一个最大值放在最右边，所以每轮比较后的元素个数都会少一个，这也是为什么 j 的范围是逐渐减小的。相信大家理解之后快速写出一个冒泡排序并不难。

　　冒泡排序性能分析：

　　假设参与比较的数组元素个数为 N，则第一轮排序有 N-1 次比较，第二轮有 N-2 次，如此类推，这种序列的求和公式为：

　　（N-1）+（N-2）+...+1 = N*（N-1）/2

　　当 N 的值很大时，算法比较次数约为 N²/2次比较，忽略减1。

　　假设数据是随机的，那么每次比较可能要交换位置，可能不会交换，假设概率为50%，那么交换次数为 N²/4。不过如果是最坏的情况，初始数据是逆序的，那么每次比较都要交换位置。

　　交换和比较次数都和N² 成正比。由于常数不算大 O 表示法中，忽略 2 和 4，那么冒泡排序运行都需要 O(N²) 时间级别。

　　其实无论何时，只要看见一个循环嵌套在另一个循环中，我们都可以怀疑这个算法的运行时间为 O(N²)级，外层循环执行 N 次，内层循环对每一次外层循环都执行N次（或者几分之N次）。这就意味着大约需要执行N²次某个基本操作。

 

二、选择排序

package com.light.springboot.algorithm;

/**
 * 选择排序法
 * 一共排i轮，第 i 轮选出 i 之后最小的值，放在第i个位置
 * 选择排序和冒泡排序执行了相同次数的比较：N*（N-1）/2，但是至多只进行了N次交换。
 * 当 N 值很大时，比较次数是主要的，所以和冒泡排序一样，用大O表示是O(N2) 时间级别。但是由于选择排序交换的次数少，所以选择排序无疑是比冒泡排序快的。
 * 当 N 值较小时，如果交换时间比选择时间大的多，那么选择排序是相当快的。
 * @author qiaozhong
 *
 */
public class Sortxuanze {
	public static void main(String[] args) {
		int[] intArray = {0,5,3,7,8,8,9,6,5,4};
		for (int i = 0; i < intArray.length; i++) {
			System.out.println(xuanzeSort(intArray)[i]);
		}
	}
	
	public static int[] xuanzeSort(int[] intArray){
		for(int i=0; i < intArray.length; i++){
			for(int j=i; j<intArray.length; j++){
				if (intArray[i] > intArray[j]) {
					int tmp = intArray[j];
					intArray[j] = intArray[i];
					intArray[i] = tmp;
				}
			}
		}
		
		return intArray;
	}
}

　　

选择排序性能分析：

　　选择排序和冒泡排序执行了相同次数的比较：N*（N-1）/2，但是至多只进行了N次交换。

　　当 N 值很大时，比较次数是主要的，所以和冒泡排序一样，用大O表示是O(N²) 时间级别。但是由于选择排序交换的次数少，所以选择排序无疑是比冒泡排序快的。当 N 值较小时，如果交换时间比选择时间大的多，那么选择排序是相当快的。

 

三、插入排序

package com.light.springboot.algorithm;

/**
 * 插入排序法
 * 直接插入排序基本思想是每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。
 * @author qiaozhong
 *
 */
public class SortCharu {
	public static void main(String[] args) {
		int[] intArray = {0,5,3,7,8,8,9,6,5,4};
		for (int i = 0; i < intArray.length; i++) {
			System.out.println(charuSort(intArray)[i]);
		}
	}
	
	/**
	 * @param intArray
	 * @return
	 */
	public static int[] charuSort(int[] intArray){
		
		//默认首个元素自己为有序的，所以从第二个元素开始拍讯，循环length-1次
		for (int i=1; i < intArray.length; i++) {
			
			//记录要插入的数据
			int j = i;
			int tmp = intArray[j];
			
			//若当前值小于前面元素值，就把前面元素向后移动一个位置，直到当前值大于前面元素数值，或者当前值移动到数组首位
			while(j>0 && tmp < intArray[j-1]){
				intArray[j] = intArray[j-1];
				j--;
			}
			intArray[j] = tmp;//要插入的数据存插入到正确位置
		}
		return intArray;
	}
}

　　

插入排序性能分析：

　　在第一轮排序中，它最多比较一次，第二轮最多比较两次，一次类推，第N轮，最多比较N-1次。因此有 1+2+3+...+N-1 = N*（N-1）/2。

　　假设在每一轮排序发现插入点时，平均只有全体数据项的一半真的进行了比较，我们除以2得到：N*（N-1）/4。用大O表示法大致需要需要 O(N²) 时间级别。

　　复制的次数大致等于比较的次数，但是一次复制与一次交换的时间耗时不同，所以相对于随机数据，插入排序比冒泡快一倍，比选择排序略快。

　　这里需要注意的是，如果要进行逆序排列，那么每次比较和移动都会进行，这时候并不会比冒泡排序快。

 

总结：

上面讲的三种排序，冒泡、选择、插入用大 O 表示法都需要 O(N²) 时间级别。一般不会选择冒泡排序，虽然冒泡排序书写是最简单的，但是平均性能是没有选择排序和插入排序好的。

　　选择排序把交换次数降低到最低，但是比较次数还是挺大的。当数据量小，并且交换数据相对于比较数据更加耗时的情况下，可以应用选择排序。

　　在大多数情况下，假设数据量比较小或基本有序时，插入排序是三种算法中最好的选择。

　　后面我们会讲解高级排序，大O表示法的时间级别将比O(N²)小。