本文主要内容：
1.插入排序
2.希尔排序
3.直接选择排序
4.堆排序
1.排序：默认情况下为非降序排序
2.稳定性：能够保证排序过程中相同的数据排序前后相对位置不变
3.插入排序：减治算法排序
每次从无序区间选择第一个数插入到有序区间的合适位置（打牌）
时间复杂度：最坏o(n的平方)：完全逆序 最好o(n)：完全有序[从后往前找]
一般情况：o(n的平方)
越接近有序，执行时间效率越高
空间复杂度：o(1)
稳定性：稳定
计时：long begin = System.naoTime ();long end = System.naoTime ();
System.out.println(end-begin);
4.希尔排序（Shell Sort）:分组进行插入排序
分组越多：大数据可以很快走到最后，每次分组排序后，数据不太有序
分组越少：每次分组排序后，数据更有序
size = 10;gap = size;
gap = gap/3+1;[4,2,1]
gap = gap/2;[5,2,1]
前提：利用插入排序中，数据越接近有序，时间效率越高。在插入排序之前做预排序（分组插排），使数据尽可能接近有序。
如何分组：一开始分很多组，越来越少
时间复杂度：最好：o(n) 平均：O(n1.3,n1.4) 最坏：O(n^2)
空间复杂度：O(1)
稳定性：不稳定（相等的两个数被分到了两个不同的组）
在插排中还有折半插排
5.直接选择排序：减治算法
选择排序：每次遍历无序区间（直接遍历/利用堆），找到无序区间的最大的数，把最大的数放在无序区间的最后，一直选择n-1数之后，数据完全有序
时间复杂度：o(n^2)
空间复杂度：O(1)
稳定性：不稳定 例如：9 5 2 3 5
6.堆排序：首先将现有的元素建大堆，然后将最大的元素与最后的元素交换，将堆进行向下调整，选出第二大元素与末尾元素交换，向下调整一直循环下去。
堆排的时间复杂度：o(n*nlog(n))
空间复杂度：o(1)
稳定性：不稳定
选择排序选最大的数，选最小的可以吗？
选择排序也可以，同时选最大和最小
堆排往往建大堆，小堆更复杂，效率更低
public class Solution3 {
//创建一个随机数组
public static int[] createArray(){
Random random = new Random(135531);
int[] array = new int[10];
for(int i = 0;i<array.length;i++){
int a = random.nextInt(100);
array[i] = a;
}
return array;
}
//打印数组
public static void showArray(int[] array){
for(int i =0;i<array.length;i++){
System.out.print(array[i]+" ");
}
System.out.println();
}
//插入排序：时间复杂度：o(n^2) 空间复杂度：o(1) 是稳定的
//给定一组数，假设前面的部分是有序的，后面的部分是无序的，从无序的部分找一个元素插入到有序的部分，直到全部有序
//起初有序部分只有第一个数，后面都是无序部分
//假如有n个数，默认第一个数有序，则外层循环可以循环n-1次
public static void insertSort(int[] array){
for(int i = 0;i<array.length-1;i++){
//有序：[0,i],无序：[i+1,array.length)
int key = array[i+1];//待插入元素
//从后往前遍历有序部分，找到合适的位置，后面的元素往后挪动一位，最后插入元素
int j = 0;
for(j = i;j>=0;j--){
if(key>=array[j]){
break;
}
array[j+1] = array[j];//即j下标以后的元素均往后移动一位
}
array[j+1] = key;
}
}
public static void insertSort1(int[] array){
for(int i = 1;i<array.length;i++){
//有序：[0,i),无序：[i,array.length)
int key = array[i];
int j = 0;
for(j = i-1;j>=0;j--){
if(key>=array[j]){
break;
}
array[j+1] = array[j];
}
array[j+1] = key;
}
}
//希尔排序：时间复杂度为O(n^1.3-n^1.4) 空间复杂度为：O(1) 不稳定
//将现有的元素按照一定的公式进行分组，将各个组内元素进行插入排序(预排序)
//最后当分组为1时，插入排序，终止
//公式为：[(array.length)/3]+1
public static void insertSortWithGap(int[] array,int gap){
//当gap为1时，就是插入排序
//假设有十个数进行希尔排序，前四个元素可以看成有序的，所以只需要循环六次即可，即array.length-gap次
for(int i = 0;i<array.length-gap;i++){
int key = array[i+gap];
int j = 0;
for(j=i;j>=0;j = j-gap){
if(key>=array[j]){
break;
}
array[j+gap] = array[j];
}
array[j+gap] = key;
}
}
public static void shellSort(int[] array){
int gap = array.length;
while (true){
gap = gap/3+1;
insertSortWithGap(array,gap);
if(gap==1){
return;
}
}
}
//直接选择排序:时间复杂度为o(n^2),空间复杂度为O(1),不稳定
//给定一组无序的数，假设前面的数是无序的，后面的数是有序的，在无序部分找到最大的数与无序部分的最后一个元素进行交换，直到有序
//起初有序部分为0，无序部分为所有元素
//假设有n个数，选择排序直到后n-1个元素有序，就默认整个数组有序，即循环n-1次
public static void swap(int[] array,int a,int b){
int temp = array[a];
array[a] = array[b];
array[b] = temp;
}
public static void selectSort(int[] array){
for(int i = 0;i<array.length-1;i++){
//无序：[0,array.length-i) 有序：[array.length-i,array.length)
int max = 0;
for(int j = 1;j<array.length-i;j++){
if(array[max]<array[j]){
max = j;
}
}
swap(array,max,array.length-i-1);
}
}
//堆排序
//给定一组数据，将这组数据建成大堆，将最大的元素与最后一个元素交换后，删除最后一个元素。
//继续向下调整，找到第二大，继续交换，一次循环，直到排序完成
//开始时无序部分是[0,array.length-i)，建堆后，当最大元素与最后元素交换后，无序部分的元素为：[0,array.length-i-1)
public static void heapify(int[] array,int size,int index){
//向下调整
//首先应该考虑index是否为叶子结点，如果不是，则需要考虑index结点是否有右孩子
// 如果有右孩子，则将左右孩子中最大的结点与index节点比较，如果孩子结点较大，则进行交换，然后继续向下调整
while (true) {
int left = 2 * index + 1;
if (left >= size) {
return;
}
int max = left;
int right = left + 1;
if (right < size && array[max] < array[right]) {
max = right;
}
if (array[max] <= array[index]) {
return;
}
swap(array, max, index);//java中值传递
index = max;
}
}
public static void createHeap(int[] array){
//建大堆
//从最后一个结点的父节点往前遍历，依次做向下调整
for(int i = (array.length-2)/2;i>=0;i--){
heapify(array,array.length,i);
}
}
public static void heapSort(int[] array){
createHeap(array);
//因为已经建大堆，即最大元素已知，假设有n个元素，只需要循环n-1次
for(int i = 0;i<array.length-1;i++){
swap(array,0,array.length-i-1);
heapify(array,array.length-i-1,0);
}
}
public static void main(String[] args) {
int[] a = createArray();
showArray(a);
insertSort(a);
showArray(a);
insertSort1(a);
showArray(a);
System.out.println("==========================");
shellSort(a);
showArray(a);
System.out.println("==========================");
selectSort(a);
showArray(a);
System.out.println("==========================");
heapSort(a);
showArray(a);
}
}
//运行结果：
39 91 83 19 40 0 11 61 51 73
0 11 19 39 40 51 61 73 83 91
0 11 19 39 40 51 61 73 83 91
==========================
0 11 19 39 40 51 61 73 83 91
==========================
0 11 19 39 40 51 61 73 83 91
==========================
0 11 19 39 40 51 61 73 83 91
来源：https://blog.csdn.net/weixin_43256788/article/details/100127201