数据结构之各种排序方式:直接插入，希尔，直接选择，冒泡，归并，计数，快速排序三种方式

1.排序的概念

稳定性： 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次

序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排

序算法是稳定的；否则称为不稳定的。

内部排序： 数据元素全部放在内存中的排序。

外部排序： 数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

2.常见的排序算法

2.1插入排序

2.1.1基本思想：

直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

2.1.2直接插入排序：

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与

array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

// 时间 O(n^2)     空间 O(1)
// 最坏	        平均        最好
// n^2（逆序）     n^2	    n (已经有序）
void InsertSort(int array[], int size) {
    
	// 外边的循环实现减治过程
	// 一次取一个数，插入到前面的有序区间内
	// 更优化的版本
	// for (int i = 1; i < size; i++) {
    
	for (int i = 0; i < size; i++) {
    
		int key = array[i];
		// 内部的循环实现的是插入的过程
		// j 从 [i-1, 0]
		// 如果 array[j] > key，往后搬
		// 如果 array[j] == key，跳出循环（保证了稳定性）
		// 如果 array[j] < key，跳出循环
		int j;
		for (j = i - 1; j >= 0 && array[j] > key; j--) {
    
			array[j + 1] = array[j];
		}
		// j + 1 就是要插入的位置
		array[j + 1] = key;
	}
}
// 插入排序的降序
void InsertSortR(int array[], int size) {
    
	for (int i = 1; i < size; i++) {
    
		int k = array[i];
		int j;
		for (j = i - 1; j >= 0; j--) {
    
			if (array[j] >= k) 
				break;
			else 
				array[j + 1] = array[j];
		}
		array[j + 1] = k;
	}
}
//二分法插入排序
//O(n^2) 稳定  适合记录数较多的场景，在寻找插入位置上花时间变小
//折半插入排序的记录比较次数与初始序列无关
//待排数据存储在数组a中，以及待排序列的左右边界
public void BinaryInsertSort(int[] a, int left, int right) {
    
    int low, middle, high;
        int temp;
    for (int i = left + 1; i <= right; i++) {
    
            temp = a[i];
            low = left;
            high = i - 1;
            while (low <= high) {
    
                middle = (low + high) / 2;
                if (a[i] < a[middle])
                    high = middle - 1;
                else
                    low = middle + 1;
        }

            for (int j = i - 1; j >= low; j--)
                    a[j + 1] = a[j];
            a[low] = temp;
        }
}

// 带 gap 参数的插入排序（升序）
void InsertSortWithGap(int array[], int size, int gap) {
    
	for (int i = gap; i < size; i++) {
    
		int k = array[i];
		int j;
		for (j = i - gap; j >= 0; j -= gap) {
    
			if (array[j] <= k) 
				break;
			else 
				array[j + gap] = array[j];
		}
		array[j + gap] = k;
	}
}

特性总结：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定

2.1.3希尔排序（缩小增量排序）

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个

组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工

作。当到达=1时，所有记录在统一组内排好序。

// 升序
// 时间复杂度
// 1）最好	O(n)
// 2）平均	O(n^1.2) - O(n^1.3)
// 3）最差	O(n^2)
// 空间复杂度    O(1)
// 不稳定（一旦分组，很难保证相同数分到一个组里）
//每次遍历无序区间，找到最大数的下标。
//1.交换 最大的数 和 无需区间的最后一个数
//2.区间 [size-1]  3.重新循环
void ShellSort(int array[], int size) {
    
	int gap = size;
	while (1) {
    
		gap = gap / 3 + 1;
		// gap 比较大的数 -> 小 -> 1 停止
		InsertSortWithGap(array, size, gap);
		if (gap == 1) 
			break;
	}
}
// 带 gap 的插入排序降序
void InsertSortWithGap(int array[], int size