各种排序算法

一、交换排序

1：🐱冒泡排序 （稳定）

算法思想 ：重复的访问要排序的数列，在访问的过程中对相邻的两个数据元素进行比较交换，直到元素不在需要交换，即该排序过程已经完成。
算法描述： （升序为例）

• 比较相邻的元素，如果第一个比第二个大，就交换他们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾最后一对，这样在最后的元素就会是最大的数；
• 针对所有的元素重复以上步骤，直到排序完成。

具体实现：

public class TestDemo{
   
    private static <T> void swap(T[] arr,int index1,int index2){
   
        T temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }
    private static <T extends Comparable<T>> void BubbleSort(T[] arr){
     //类型擦除 指定传入的泛型参数类型必须实现比较接口中的抽象方法compareTo()方法
        boolean flag;
        for(int i = 0; i<arr.length;i++){
   
            flag = true;
            for(int j =0; j < arr.length-1;j++){
   
                if(arr[j].compareTo(arr[j+1]) > 0){
   
                    swap(arr,j,j+1);
                    flag = false;
                }
            }
            if(flag){
   
                break;
            }
        }
    }

    public static void main(String[] args) {
   
      Integer[] arr = {
   4,6,3,2,6,4,7,8}; //不能直接new泛型数组
      BubbleSort(arr); 
      System.out.println(Arrays.toString(arr));
    }
}

算法分析：

• 时间复杂度：最优O(n) 、最差 O(n^2)、 平均时间复杂度O(n^2)
• 空间复杂度： 平均O(1)
• 稳定性：稳定

2:🐱快速排序（不稳定）

算法思想：
从待排序序列中选取一个关键值作为基准，比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。依此递归，达到总体待排序序列都有序。
算法描述：

• 选择基准：在待排序列中，按照某种方式挑出一个元素，作为 “基准”（pivot）
• 分割操作：以该基准在序列中的实际位置，把序列分成两个子序列。此时，在基准左边的元素都比该基准小，在基准右边的元素都比基准大
• 递归地对两个序列进行快速排序，直到序列为空或者只有一个元素
  具体实现：

public class TestDemo {
   
     private static <T extends Comparable<T>> int partition(T[] arr,int low,int high){
     //分割
        T temp = arr[low];
        while(low < high){
   
            while(low<high && arr[high].compareTo(temp) > 0){
   
                high--;
            }
            if(low == high){
   
                break;
            }else{
   
                arr[low] = arr[high];
            }
            while(low < high && arr[low].compareTo(temp) <= 0){
   
                low++;
            }
            if(low == high){
   
                break;
            }else {
   
                arr[high] = arr[low];
            }
        }
        arr[low] = temp;
        return low;
    }
    private static <T extends Comparable<T>> void quick(T[] arr,int low,int high){
   
       int part =  partition(arr,low,high);
       if