排序算法

《忆排序》
选泡插，                                              选择 冒泡 插入
快归堆希桶计基，                                快速 归并 堆 希尔 桶 计数 基数排序
恩方恩老恩一三，                               平均时间复杂度为 n ² * 3 {选泡插 } nlog₂n * 3{快归堆} n^1.3{希尔}
对恩加K恩乘K,                                     n+k * 2{桶 计数} n*k {基数}
不稳稳稳不稳稳，
不稳不稳稳稳稳。

快速排序

通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

 public static void main(String[] args) {
    int[] arr={1,1,4,7,-2};
    sort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    //快速排序
    public static  void sort(int[] arr,int left,int right) {
        if(left>=right) return;
        int l = left; int r = right; int key = arr[l];
        while(l<r){
           while(arr[r] >= key&&l<r) r--;
           if(l<r)   swap(arr, l, r);
           while(arr[l]<=key&&l<r)  l++;
            if(l<r)  swap(arr, r, l);
       }
       sort(arr,left,l-1);
       sort(arr,l+1,right);
    }
    private static void swap(int[] arr, int l, int r) {
        int t;
        t = arr[r];
        arr[r] = arr[l];
        arr[l] = t;
    }

归并排序

归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
算法描述
步骤1：把长度为n的输入序列分成两个长度为n/2的子序列；
步骤2：对这两个子序列分别采用归并排序；
步骤3：将两个排序好的子序列合并成一个最终的排序序列。

 public static int[] MergeSort(int[] array) {
        if (array.length < 2) return array;
        int mid = array.length / 2;
        //把长度为n的输入序列分成两个长度为n/2的子序列；
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        //对这两个子序列分别采用归并排序；将两个排序好的子序列合并成一个最终的排序序列。
        return merge(MergeSort(left), MergeSort(right));
    }
    /**
     * 归并排序——将两段排序好的数组结合成一个排序数组
     */
    public static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];//空间复杂度O(n)
        for (int index = 0, i = 0, j = 0; index < result.length; index++) {
            if (i >= left.length)
                result[index] = right[j++];
            else if (j >= right.length)
                result[index] = left[i++];
            else if (left[i] > right[j])
                result[index] = right[j++];//保证了稳定性
            else
                result[index] = left[i++];
        }
        return result;
    }

插入排序

插入排序类似于整理扑克牌，基本操作是将一个记录插入到已经排好序的有序数列中，从而得到一个有序但记录数加一的有序数列。
插入排序的时间复杂度为 O(n²)，是稳定的排序方法，适用于数量较少的排序。

public static void insertionSort(int[] arr) {
   	if (arr == null || arr.length < 2) {
   		return;
   	}
   	//0-1有序
   	//0-i有序
   	for (int i = 1; i < arr.length; i++) {//0-i做到有序
   		for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
   			swap(arr, j, j + 1);
   		}
   	}
   }
//i与j同位置的话就会出错
   public static void swap(int[] arr, int i, int j) {
   	arr[i] = arr[i] ^ arr[j];
   	arr[j] = arr[i] ^ arr[j];
   	arr[i] = arr[i] ^ arr[j];
   }

---