比较Java中冒泡排序，选择排序，快速排序算法效率

比较Java中冒泡排序，选择排序，快速排序算法效率

原文
讨论从小到大的情况，

冒泡排序算法

冒泡排序算法，通过对数组元素两两比较，把小的往前排，一趟冒泡排序找到一个数组中最小的，虽然没一趟比较的次数会减小，但是如果排序的数组大小很大呢，显然这个算法的效率会变得很低。

算法代码：

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

选择排序算法

选择排序算法：选择排序算法大概是这样的，定义一个变量存储每一次排序的值以及定义一个minIndex来存储最小值的下标，每一趟排序只交换一次，这样可以比冒泡排序更省时。

算法代码：

		int temp;
		for (int i = 0; i < b.length; i++) {
			int min = b[i];
			int minIndex = i;
			for (int j = i + 1; j < b.length; j++) {
				if (b[j] < min) {
					min = b[j];
					minIndex = j;
				}
			}
			temp = b[i];
			b[i] = b[minIndex];
			b[minIndex] = temp;
		}

快速排序

快速排序：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

如果要实现代码在C，C++中要写很多，但是在Java中的util类库中有一个方法Arrays.sort（）括号中将你需要排序的数组名放进去即可，这个方法可以默认的实现从小到大的排序。

那么我们怎么实现从大到小排序呢！

很简单，我们将数组的值逆序输出那么不就可以达到一个降序排序了？

但是循环避免交换过头了，只需要交换的次数为数组长度的一半。

代码：

		Arrays.sort(c);
		/*********** 逆序Arrays.sort()方法 ********/
		for (int i = 0; i < c.length / 2; i++) {
			temp = c[i];
			c[i] = c[c.length - i - 1]; // 就是将最后一个元素和第一个交换，倒数第二个和第二个交换
			c[c.length - i - 1] = temp;
		}

算法代码：

Arrays.sort(c);

三种排序算法比较

三种排序算法比较代码

package merge_k_sorted_lists;

import java.util.Arrays;

public class SpeedOfSortDemo {
	
	//比较冒泡排序，选择排序，快速排序的效率
	public static void main(String[] args) {
		int[] arr = generateRandomArray(100000, 100000);
		int[] a = copyArray(arr);   //冒泡排序
		int[] b = copyArray(arr);   //选择排序
		int[] c = copyArray(arr);   //快速排序
		
		
		long start = System.currentTimeMillis();
		BubbleSort(a);
		long end = System.currentTimeMillis();
		System.out.println("冒泡排序所用时间："+(end-start)+"ms");
       
		
		long start1 = System.currentTimeMillis();
		SelectionSort(b);
		long end1 = System.currentTimeMillis();
		System.out.println("选择排序用时："+(end1-start1)+"ms");
		
		long start2 = System.currentTimeMillis();
		QuickSort(c);
		long end2 = System.currentTimeMillis();
		System.out.println("Arrays.sort()用时："+(end2-start2)+"ms");
		
		System.out.println((isEqual(a, b) && isEqual(b, c))?"":"error");
	}
	
	/**气泡排序*/
	public static void BubbleSort(int[] arr) {
		int temp;
		for(int i = 0;i<arr.length-1;i++) {
			for(int j = 0;j<arr.length-1-i;j++) {
				if(arr[j]>arr[j+1]) {
					temp = arr[j+1];
					arr[j+1] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}
	
	/**选择排序*/
	public static void SelectionSort(int[] arr) {
		int temp;
		for(int i = 0;i<arr.length;i++) {
        	int min = arr[i];
            int minIndex = i;
        	for(int j = i+1;j<arr.length;j++) {
        		if(arr[j]<min) {
        			min = arr[j];
        			minIndex = j;
        		}
        	}
        	temp = arr[i];
        	arr[i] = arr[minIndex];
        	arr[minIndex] = temp;
        }
	}
	
	/**快递排序*/
	public static void QuickSort(int[] arr) {
		Arrays.sort(arr);
	}
	
	/**
	 * 生成随机数组
	 * @param maxSize 最大长度
	 * @param maxValue 最大值
	 * @return
	 */
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}
	
	/**复制数组*/
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}
	
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}
 
}

运行结果展示：
冒泡排序所用时间：9164ms
选择排序用时：1306ms
Arrays.sort()用时：12ms

参考资料

插入排序
选择排序