Java 常用的几种排序

排序算法重要性

1. 学习java必不可少要学习一下排序算法。
2. 在处理数据时，想要排序也必不可少要知道那种算法更好，处理数据的时间更快。
   
   这是我在某站找的一个图片，权当学习借鉴一下了。

到这里不得不说一下 java 的Arrays.sort()所用的排序方法了

Arrays.sort

到这里可以看出来java底层用的也是快排，但是是经过改良的。

1. 经典的快排把数组分成两段，但是这个改良的是将数组分成三段
2. 改良的算法是考虑到cpu的运算

快速排序

	/**
	 * ----升序---- 快排：以第一个数为基数， 先从后往前比较：
	 * 小于基数则换位置，换完位置则以基数的位置为指针，以原来的位置为头指针
	 * 从前往后比较 大于则尾指针向前移动一位
	 * 
	 * 从前往后比较： 头指针数小于基数，则位置不变，头指针向前移动 大于时
	 * 与基数换位置，基数指针位置为换完的位置，然后从后往前比较
	 * 
	 * 直到头指针位置大于或等于尾指针位置(第一个比较完成)
	 * 
	 * 将数组分成两边 在做快排，直到左右不可分
	 * 
	 * @param arr
	 *            数组
	 * @param start
	 *            开始时间
	 * @param begin
	 *            头指针位置
	 * @param last
	 *            尾指针位置
	 * @return
	 */
	public static void sort(int[] arr, int begin, int last) {
		
		int start = begin;
		int end = last;
		// 头大于等于尾 则结束
		if (begin >= last) {
			return;
		}

		// 确认基数
		int x = arr[begin];

		// 循环
		while (begin < last) {
			// 从后往前找
			while (begin < last && arr[last] >= x) {
				last--;
			}
			// 如果是在范围之内找到 则交换位置
			if (begin < last) {
				arr[begin] = arr[last];
				// 头指针位置前进一位
				begin++;
			}
			// 从前往后找
			while (begin < last && arr[begin] <= x) {
				begin++;
			}
			// 头指针所指的数大于基数
			if (begin < last) {
				arr[last] = arr[begin];
				// 尾指针回退一位
				last--;
			}

		}
		// 最后begin >= last 将基数赋予begin 或 last 都可以
		// 因为最后begin会在等于last时候退出循环
		arr[begin] = x;
		// 循环结束 表示一个数已经排序完 递归排序左右两边
		// 左边递归排序
		sort(arr, start, begin - 1);
		// 右边递归排序
		sort(arr, begin + 1, end);
	}

1.快排在不改变jvm参数的情况下，最大只能排序1w-2w的值，超出会堆栈溢出。
2. 设置堆栈内存

插入排序

/**
	 * 
	 * 需要插入的数与前一个数比较，
	 * 大于则不动，小于则与前一个数互换，然后再与前一个数比较
	 * 如下去一直到大于前一个数的位置
	 * 
	 * @param a     传入的需排序的数组
	 * @param start 开始时间
	 * @param end   运行结束时间
	 * @return
	 */
	public static long sort(int[] arr, long start, long end) {
		System.out.println("----------插入--------------");
		start = System.currentTimeMillis();
		
		//比较次数为数组长度-1(第一个数不用比较)
		for(int i = 0; i < arr.length - 1; i++){
			//获取当前比较数的位置
			int j = i;
			//获取需要插入的数
			int x = arr[j+1];
			//循环比较 如果 后者小于前者 则换位置
			while (j >= 0 && arr[j] > x){
				//换位置 将大的值放后面
				arr[j+1] = arr[j];
				//继续与前一个数比较
				j--;
			}
			//比较完 将值放入前一个位置
			arr[j+1] = x;
		}
		
		
		end = System.currentTimeMillis();
		return (end - start) / 1000;
	}

冒泡排序

	/**
	 * 冒泡排序：a[i] > a[i+1] 则a[i]与a[i+1]的数据交换，否则不变
	 * 			每一轮都会选择出一个最值，有i个数字则有i-1轮比较
	 * @param a 传入需要排序的数组
	 * @return
	 */
	public static long sort(int[] a, long start, long end) {
		start = System.currentTimeMillis();
		for (int i = 0; i < a.length; i++) { // 第一层 要比较的轮数
			for (int j = 0; j < a.length - i - 1; j++) { // 第二层 每个数比较几次
				if (a[j] > a[j + 1]) { 					 // 自己不用和自己比 所以减一
					int temp = a[j]; 					 // 每一轮比较完都有一个最值出现，所以减去i
					a[j] = a[j + 1];
					a[j + 1] = temp;
				}
			}
		}
		end = System.currentTimeMillis();
		return (end - start);
	}

选择排序

/**
	 * 选择：从数组中选择最小的数与第一个交换
	 * 		重复步骤选择出第二第三...
	 * @param arr	数组
	 * @param start	开始时间
	 * @param end	结束时间
	 * @return
	 */
	public static long sort(int[] arr, long start, long end) {
		start = System.currentTimeMillis();
		//定义一个交互变量
		int temp;
		//每个位置都要选出最小的  所以有几个数 就有几轮
		for (int i = 0; i < arr.length-1; i++) {
			//获取地址
			int min = i;
			//自身不用比,i之前的数据都已经排序完，顾也不用比
			for (int j = i+1; j < arr.length - 1; j++) {
				//如果有比当前小的
				if (arr[j] < arr[min]){
					//最小的索引变化
					min = j;
				}
			}
			//有变化过
			if (min != i){
				temp = arr[i];
				arr[i] = arr[min];
				arr[min] = temp;
			}
		}
		
		end = System.currentTimeMillis();
		return (end - start);
	}

归并排序

/**
	 *  归并： 将数组分为两个等长的子数组，一直分
	 *  直到每个数组中只有一个数，最后合并
	 *  左边的第一个和右边的第一个比较 小的放入temp数组的第一个
	 *  然后小的第二个再个另一个第一个比较，小的移过去，这就是合并
	 * @param a
	 * @param start
	 * @param end
	 */
	public static void sort(int[] arr, int start, int end) {
		int mid ;
		if( start < end) {
			//划分子数组
			mid = (start+end)/2;
			//左边子数组再划分
			sort(arr, start, mid);
			//右边子数组再划分
			sort(arr, mid+1, end);
			//归并
			merge(arr, start, mid, end);
		}
		
	}
	
	public static void merge(int[] arr, int start, int mid, int end) {
		//初始化数组来存放合并的数据
		int[] temp = new int[end-start+1];
		//左边数据的起始点
		int left = start;
		//右边数据的起始点
		int right = mid+1;
		//temp数组索引
		int i = 0;
		//左右边的数组已经排序完成，合并
		while (left <= mid && right <= end) {
			//如果在范围内 且 数小的则放入数组
			if (arr[left] < arr[right]) {
				temp[i++] = arr[left++];
			} else {
				temp[i++] = arr[right++];
			}
		}
		//循环结束后 将剩余数据放入数组
		while (left <= mid) {
			temp[i++] = arr[left++];
		}
		while (right <= end) {
			temp[i++] = arr[right++];
		}
		
		//将数组覆盖原来的数组
		for (int j = 0; j < temp.length; j++) {
			arr[start+j] = temp[j];
		}
	}

比较各种算法

public class Main {
	//数组大小
	static int size = 100000;
	//运行开始时间
	static long start;
	//运行结束时间
	static long end;
	//初始化数组
	static int[] arr;
	
	//各种排序的时间(ms)
	public static void main(String[] args) {
		//Arrays.sort 默认使用快排，但是会根据数据的长度在使用升级版快排 dualpivotquicksort
		System.out.println("-----------Arrays.sort-------------------");
		giveNum(size);
		start = System.currentTimeMillis();
		Arrays.sort(arr);
		end = System.currentTimeMillis();
		System.out.println(end-start);
		System.out.println("-----------归并---------------------------");
		giveNum(size);
		start = System.currentTimeMillis();
		GuiBing.sort(arr, 0, arr.length-1);
		end = System.currentTimeMillis();
		System.out.println(end-start);
		System.out.println("-----------快排---------------------------");
		giveNum(size);
		start = System.currentTimeMillis();
		KuaiPai.sort(arr, 0, arr.length-1);
		end = System.currentTimeMillis();
		System.out.println(end-start);
		System.out.println("-----------选择---------------------------");
		giveNum(size);
		System.out.println(XuanZe.sort(arr, start, end));
		System.out.println("-----------冒泡---------------------------");
		giveNum(size);
		System.out.println(MaoPao.sort(arr, start, end));
		System.out.println("-----------插入---------------------------");
		giveNum(size);
		System.out.println(ChaRu.sort(arr, start, end));
		
	}
	// 赋值
	public static void giveNum(int size) {
		arr = new int[size];
		Random random = new Random();
		for (int i = 0; i < arr.length; i++) {
			arr[i] = random.nextInt(100);
		}
	}
}

当size为10w时

由此可见jdk自带的排序还是非常好的。我看了一下底层实现，它在不同的长度会用不同的排序方法以达到最佳的效果。