11. 排序（Sorting）

1 十大排序算法

1.1 排序算法的稳定性（Stability）

1. 如果相等的2个元素，在排序前后的相对位置保持不变，那么这是稳定的排序算法
   1. 排序前： 5, 1, 3 𝑏 , 4, 7, 3 𝑐
   2. 稳定的排序： 1, 3 𝑏 , 3 𝑐 , 4, 5, 7
   3. 不稳定的排序： 1, 3 𝑐 , 3 𝑏 , 4, 5, 7
2. 对自定义对象进行排序时，稳定性会影响最终的排序效果
3. 稍有不慎，稳定的排序算法也能被写成不稳定的排序算法，比如下面的冒泡排序代码是不稳定的
   

1.2 原地算法（In-place Algorithm）

1. 不依赖额外的资源或者依赖少数的额外资源，仅依靠输出来覆盖输入
2. 空间复杂度为 𝑂(1) 的都可以认为是原地算法
3. 非原地算法，称为 Not-in-place 或者 Out-of-place

2 辅助工具类

1. Integers：用于获取各种类型的数组，并提供一些检查方法

package com.mj.tools;

import java.util.Arrays;

public class Integers {
   
	//生成数据随机的数组
	public static Integer[] random(int count, int min, int max) {
   
		if (count <= 0 || min > max) return null;
		Integer[] array = new Integer[count];
		int delta = max - min + 1;
		for (int i = 0; i < count; i++) {
   
			array[i] = min + (int)(Math.random() * delta);
		}
		return array;
	}
	
	public static Integer[] combine(Integer[] array1, Integer[] array2) {
   
		if (array1 == null || array2 == null) return null;
		Integer[] array = new Integer[array1.length + array2.length];
		for (int i = 0; i < array1.length; i++) {
   
			array[i] = array1[i];
		}
		for (int i = 0; i < array2.length; i++) {
   
			array[i + array1.length] = array2[i];
		}
		return array;
		
	}
	
	public static Integer[] same(int count, int unsameCount) {
   
		if (count <= 0 || unsameCount > count) return null;
		Integer[] array = new Integer[count];
		for (int i = 0; i < unsameCount; i++) {
   
			array[i] = unsameCount - i;
		}
		for (int i = unsameCount; i < count; i++) {
   
			array[i] = unsameCount + 1;
		}
		return array;
	}
	//返回尾部元素有序的数组
	public static Integer[] headTailAscOrder(int min, int max, int disorderCount) {
   
		Integer[] array = ascOrder(min, max);
		if (disorderCount > array.length) return array;
		
		int begin = (array.length - disorderCount) >> 1;
		reverse(array, begin, begin + disorderCount);
		return array;
	}
	
	public static Integer[] centerAscOrder(int min, int max, int disorderCount) {
   
		Integer[] array = ascOrder(min, max);
		if (disorderCount > array.length) return array;
		int left = disorderCount >> 1;
		reverse(array, 0, left);
		
		int right = disorderCount - left;
		reverse(array, array.length - right, array.length);
		return array;
	}
	//返回头部元素有序的数组
	public static Integer[] headAscOrder(int min, int max, int disorderCount) {
   
		Integer[] array = ascOrder(min, max);
		if (disorderCount > array.length) return array;
		reverse(array, array.length - disorderCount, array.length);
		return array;
	}
	//返回尾部元素有序的数组
	public static Integer[] tailAscOrder(int min, int max, int disorderCount) {
   
		Integer[] array = ascOrder(min, max);
		if (disorderCount > array.length) return array;
		reverse(array, 0, disorderCount);
		return array;
	}
	//返回升序的数组
	public static Integer[] ascOrder(int min, int max) {
   
		if (min > max) return null;
		Integer[] array = new Integer[max - min + 1];
		for (int i = 0; i < array.length; i++) {
   
			array[i] = min++;
		}
		return array;
	}
	//返回降序的数组
	public static Integer[] descOrder(int min, int max) {
   
		if (min > max) return null;
		Integer[] array = new Integer[max - min + 1];
		for (int i = 0; i < array.length; i++) {
   
			array[i] = max--;
		}
		return array;
	}
	
	/**
	 * 反转一个数组，索引范围是[begin, end)
	 */
	private static void reverse(Integer[] array, int begin, int end) {
   
		int count = (end - begin) >> 1;
		int sum = begin + end - 1;
		for (int i = begin; i < begin + count; i++) {
   
			int j = sum - i;
			int tmp = array[i];
			array[i] = array[j];
			array[j] = tmp;
		}
	}
	//复制一个数组
	public static Integer[] copy(Integer[] array) {
   
		return Arrays.copyOf(array, array.length);
	}
	//判断数组中元素是否有序
	public static boolean isAscOrder(Integer[] array) {
   
		if (array == null || array.length == 0) return false;
		for (int i = 1; i < array.length; i++) {
   
			if (array[i - 1] > array[i]) return false;
		}
		return true;
	}
	//打印一个数组中所有元素
	public static void println(Integer[] array) {
   
		if (array == null) return;
		StringBuilder string = new StringBuilder();
		for (int i = 0; i < array.length; i++) {
   
			if (i != 0) string.append("_");
			string.append(array[i]);
		}
		System.out.println(string);
	}
}

2. Sort接口：所有排序类，都实现该接口，该接口提供该排序总共进行了多少次交换、多少次判断、用时等属性

package com.mj.sort;

import java.text.DecimalFormat;

import com.mj.Student;
import com.mj.sort.cmp.SelectionSort;
import com.mj.sort.cmp.ShellSort;

@SuppressWarnings("unchecked")
public abstract class Sort<T extends Comparable<T>> implements Comparable<Sort<T>> {
   
	protected T[] array;
	private int cmpCount;
	private int swapCount;
	private long time;
	private DecimalFormat fmt = new DecimalFormat("#.00");
	
	public void sort(T[] array) {
   
		if (array == null || array.length < 2) return;
		
		this.array = array;
		
		long begin = System.currentTimeMillis();
		sort();
		time = System.currentTimeMillis() - begin;
	}
	
	@Override
	public int compareTo(Sort<T> o) {
   
		int result = (int)(time - o.time);
		if (result != 0) return result;
		
		result = cmpCount - o.cmpCount;
		if (result != 0) return result;