1. 冒泡排序：

思想：将元素前后比较，大的放到后面去，最终每轮循环过后都可以将当前区间的最大元素放到最后面（每轮循环过后区间大小减一）

public static void bubbleSortLowBetter(int[] array){
    
	int n = array.length;
	//循环n - 1次
	for(int i = 0;i < n - 1;i++){
    
	//前后交换位置，每循环一次都可以把当前无序数组最大的元素放在最后面去
	///所以每次循环次数都减i
		for(int j = 0; j < n - i - 1; j++){
    
		//如果前面的大于后面的，则将其交换位置
			if(array[j] > array[j + 1]){
    
				int temp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = temp;
			}
		}
	} 
}

---

2. 插入排序：

2.1 直接插入排序：

思想：
默认第一个元素为有序数组，后面的为无序数组。
首先用value将要排序的数字保存起来，将无序数组的第一个元素与有序数组从后向前一一比较，因为已经提前用value保存了无序数组的第一个（也就是有序数组最后一个的下一个））所以如果value小于有序数组元素，有序数组元素可以直接依次向后推移（前面的覆盖后面的，为value的插入让出位置）。当value大于数组中的元素时，跳出循环将value插到那个元素的后面（之前那个位置的元素后面得元素已经依次向后推移到下一个位置了）

 public static void insertSort(int[] array){
    

 	int n = array.length;
 	//外层循环是将所有元素遍历一遍
 	//内层循环是给当前元素找到位置
 	//两层循环过后所有元素都找到了正确的位置
 	for(int i = 1;i < n;i++){
    
 		//已排序集合的最后一个元素下标
		int j = i - 1;
		//待排序集合的第一个元素
		int value = array[i];
		//将待排序元素与已经排好序的数组（从最后一个元素开始，每次j--向前推进）作比较，
		//如果已经排好的元素大于待排序的元素，则将其向后移一位（array[j + 1] = array[j];）
		//直到遇到小于待排序的元素，或者到头，则将需要排序的元素其插入到这个小于待排序的元素后方。
		for(;j >= 0;j--){
    
			if(array[j] > value){
    
				array[j + 1] = array[j];
			}else{
    
				break;
			}
			//假如此时已经到了最后一步，j--后，比较array[j]与value的大小，发现value不小于array[j]
			//则将value放在array[j]的后面，也就是array[j + 1] = value;
			//并且此时的array[j + 1]的值已经在上一轮的循环中依次向后推移了，所以不必担心，array[j]后面的值没被保存
		}					
		array[j + 1] = value;	
	}
 }

---

2.2 折半插入排序（二分查找排序）：

思想：将无序集合的第一个元素i与有序集合的中间元素mid相比较

1. 如果比中间元素大，那么一定比中间数组前面的元素要大，则可以以mid + 1作为新的分区起始位置。
2. 如果比中间元素小，那么也就比中间元素后面的小，则以mid - 1作为新的数分区起始位置。
3. 直到Low和High的前后位置发生变化，此时High + 1的位置为新的元素插入点

当数组无序的时候这种方法效率更高，但是当数组近乎有序的时候，不如直接插入排序从前向后比较。

public static void binaryInsertSort(int[] array){
    
      int low,high,mid,temp = 0;
      int n = array.length;
      //此循环是将无序数组的元素与有序数组的元素比较，找到无序数组元素应该放在有序数组的哪
      for(int i = 1; i < n; i++){
    
          //有序集合的第一个元素
          low = 0;
          //有序集合的最后一个元素（无序集合第一个元素的上一个元素）
          high = i - 1;
          //无序集合的第一个元素（正在排序的元素）
          temp = array[i];
          //当low > high的时候，将新的元素插到high的后面（high + 1）
          while(low <= high){
    
              //有序集合的中间元素
              mid = (high + low)/2;
              if(array[mid] > temp){
    
                  low  = mid + 1;
              }else{
    
                  high = mid - 1;
              }
          }
          //此时j是由后向前推进，所以只需 > high即可，这样会在high前停下，如果 = high则会跨过high。
          //由于循环的最后一步 j--,所以此处为 j + 1。
          int j = i - 1;
          for(;j > high; j--){
    
              array[j + 1] = array[j];
          }
          array[j  + 1] = temp;
      }
  }

---

2.3 希尔排序（缩小增量排序）：

因为直接插入排序对于近乎有序的序列效率较高。
所以希尔排序是将待排序的的序列分成若干小的序列（以步长进行分组，一般以数组的一半开始，每次循环除2）进行直接插入排序，最后再将基本有序的整体序列（也就是步长为1的序列）进行一次直接插入排序。

public static void shellSort(int[] array){
    
	int n = array.length;
	int step = n/2;
	//当步长为1的循环结束，序列也就完全有序了，此时跳出循环
	while(step >= 1){
    
		//外层循环，遍历每一个元素
		for(i = step;i < n;i++){
    
		//value保存无序数组的第一个元素，因为待会会被覆盖
		int value = array[i];
		//有序数组的第一个元素
		int j = i - step;	
		//内层循环，给当前元素找到合适的位置
			for(;j >= 0;j -= step){
    
				if(array[j] > array[j + step]){
    
					//如果有序数组的元素大于无序数组元素，无序数组元素向后推移
					array[j + step] = array[j];      
				}else{
    
					break;
				}
			}
			array[j + step] = value;
		}
		step = step/2;
	}
}

---

3.简单选择排序

思想：
每次都找到当前无序数组中最小（最大），放到无序数组的最前面（最后面），也就是与最前面（最后面）的元素交换位置。

 public static void selectionSort(int[] array) {
    
 	int n = array.length;
 	//外层i可以理解为有序数组最后一个的下标
 	for(int i = 0;i < n - 1;i++){
    
 		int minIndex = i;
 		//内层j可以认为是无序数组的第一个下标
 		//将无序数组从前向后遍历，如果其中有小于array[i]的那么就找到其中最小的
 		//如果没有，则array[i]保持原位，i++，继续比较后面的元素
		for(int j = i + 1;j < n;j++){
    
			if(array[minIndex] > array[j]){
    
				minIndex = j;
		}
		if(array[i] != array[minIndex]){
    
			int temp = array[i];
			array[i] = array[minIndex];
			array[minIndex] = temp;
		}
	}
 }

---

4. 归并排序：

思想：
归并排序算法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
注：当拆分到最后一步时，每个数组中只有一个元素，那么此时可以认为数组都是有序的。

/*
拆分数组
p为数组的开始位置，r为数组结束位置
*/
private static void mergeSortIntern(int[] array,int p,int r) {
    
	//终止条件
	if(p > r){
    
		return;
	}
	int mid = (p + r)/2;
	//将数组左半部分拆分
	mergeSortIntern(array,p,mid);
	//将数组右半部分拆分
	mergeSortIntern(array,mid + 1,r);
	//将数组合并
	merge(array,p,mid,r);
}

/*
合并数组
p为数组起始位置
mid为数组中间位置
r为数组终止位置
*/
private static void merge(int[] array,int p,int mid,int r) {
    
	/*
	i、j、k可以理解为三个指针
	i指向左数组的第一个位置
	j指向右数组的第一个位置
	k指缓存数组的第一个位置
	将左数组与右数组的元素从头开始比大小，哪边小将哪边元素加入temp数组
	然后k指针向后移动一位，同时那个i或者j也向后移动一位
	直到i或者j达到数组边缘，此时循环结束
	*/
	int i = p;
	int j = mid + 1;
	int k = 0;
	int temp = new int[r - p + 1];
	while(i <= mid && j <= r){
    
		if(array[i] < array[j]){
    
			temp[k++] = array[i++];
			/*
			temp[k] = array[i];
			k++;
			i++;
			*/
		}else{
    
			temp[k++] = array[j++];
		}
	}
	
	/*
	判断左右数组中还有哪个数组剩有元素,将剩余元素加入temp数组中
	首先默认是左数组中还剩元素，之后判断如果j指针没有指到数组最后一位的下一位
	则剩下的是右数组，给start与end重新赋值
	*/
	int start = i;
	int end = mid;
	if(j <=   r){
    
		int strat = j;
		int end = r;
	}
	while(start < end){
    
		temp[k++] = array[start++];
	}
	
	//将temp中的数据写回原数组（用正确顺序的数组覆盖原数组）
	for(i = 0; i < r - p; i++){
    
		array[p + i] = temp[i];
	}
}

---

5. 快速排序

挖坑：

public class ex2 {
    
	//一个简单的测试用例
    public static void main(String[] args) {
    
        int[] a = new int[]{
    1,6,7,8,91,3,4,6,52,87,2,6,9};
        quickSort(a,0,a.length -1);
        for (int i:a
             ) {
    
            System.out.println(i);
        }
    }

    public static int p(int[] a,int l,int h) {
    
        int temp = a[l];//基准值
        while(l < h){
    
            //找到比基准值小的
            while((l < h) && a[h] >= temp){
    
                h--;
            }
            /*当跳出while循环只有两种情况：
              1.两个指针相遇了
              2.找到了比temp小的值
            */
            if(l == h){
    
                break;
            }else{
    
                a[l] = a[h];
            }
            //找到比基准值大的
            while((l < h) && temp > a[l]){
    
                l++;
            }
            if(l == h){
    
                break;
            }else{
    
                a[h] = a[l];
            }
        }
        //此时l == p
        a[l] = temp;
        return l;
    }

    public static void quick(int[] a,int low,int high) {
    
        if (low == high){
    
            return;
        }
        int par = p(a,low,high);
        //递归左边————>前提是左边有两个数据以上
        if (par > low + 1){
    
            quick(a,low,par -1);
        }
        //递归右边————>前提是保证右边有两个数据以上
        if (par < high -1){
    
            quick(a,par + 1,high);
        }
    }

    public static void quickSort(int[] a,int l,int h) {
    
        quick(a,l,h);
    }
}

左右指针：

public int[] MySort (int[] arr) {
    
        QuickSort(arr,0,arr.length - 1);
        return arr;
    }

    public void QuickSort(int[] input, int l, int r){
    
        //i，j记录数组左右端点
        int i = l;
        int j = r;
        //以数组第一个为基准值
        int v = input[l];
        while(i < j) {
    
            //找到右半边比基准值小的
            while (i < j && input[r] >= v) {
    
                i--;
            }
            //找到左半边比基准值大的
            while (i < j && input[l] <= v) {
    
                j++;
            }
            //交换
            swap(input,l,i);
        }
        //将基准值放入正确位置
        swap(input,l,i);
        //当基准值左边数组长度大于1再排序
        if (i - 1 > l){
    
            QuickSort(input,i,l - 1);
        }
        //当基准值右边数组长度大于1再排序
        if (j + 1 < r){
    
            QuickSort(input,l + 1,j);
        }
    }

    public void swap(int[] input,int a, int b){
    
        int temp = input[a];
        input[a] = input[b];
        input[b] = temp;
    }

堆排序

import java.util.*;

/**
 * @author fengweibo
 * @version 1.0
 * @date 2021/10/27 20:26
 */

import java.util.*;


public class Solution {
    
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
    
        heapSort(arr);
        return arr;
    }

    public  void heapfiy(int[] tree, int n ,int i){
    
        if (i >= n) {
    
            return;
        }
        int max = i;
        int l = i * 2 + 1;
        int r = i * 2 + 2;
        if (l < n && tree[l] > tree[max]){
    
            max = l;
        }
        if (r < n && tree[r] > tree[max]){
    
            max = r;
        }
        if (max != i){
    
            swap(tree,max,i);
            heapfiy(tree,n,max);
        }

    }

    public  void swap(int[] tree,int i, int j){
    
        int temp = tree[i];
        tree[i] = tree[j];
        tree[j] = temp;
    }

    //buildheap 建立稳定堆
    public  void buildHeap(int[] tree,int n){
    
        int i = (n-1)/2;
        for (int j = i; j >= 0; j--) {
    
            heapfiy(tree,n,j);
        }
    }


    //循环交换第一个元素与最后一个元素
    public  void heapSort(int[] tree){
    
        int n = tree.length;
        buildHeap(tree,n);
        for (int i = n - 1; i >= 0; i--) {
    
            swap(tree,0,i);
            heapfiy(tree,i,0);
        }
    }
}