sort

public class Sort {
//    插入排序
//    第一个先排好，
//    然后排前两个，前三个
    public static void insertionSort(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        for(int i = 1; i < arr.length; i++){
            for(int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--){
                swap(arr, j, j + 1);
            }
        }
    }
// 选择排序
// 先在 0 ~ N 找出最小的
//     1 ~ N 找出最小的
    public static void selectionSort(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        for(int i = 0;i < arr.length - 1;i++){
            int minIndex = i;
            for(int j = i + 1;j < arr.length;j++){
                minIndex = arr[minIndex] > arr[j] ? j : minIndex;
            }
            swap(arr,minIndex,i);
        }
    }

//    归并排序
//    把数组递归分成两部分排序好，然后合并
//    复杂度 O(N * logN)
    public static void mergeSort(int[] arr){
        if(arr == null || arr.length < 2){
            return ;
        }
        mergeSort(arr,0,arr.length - 1);
    }
    public static void mergeSort(int[] arr,int l,int r){
        if(l == r){
            return ;
        }
        int mid = (l + r) / 2;
        mergeSort(arr,l,mid);
        mergeSort(arr,mid + 1,r);
        merge(arr,l,mid,r);
    }
    public static void merge(int[] arr,int l,int mid, int r){
        int[] help = new int[r - l + 1];
        int p1 = l;
        int p2 = mid + 1;
        int i  = 0;
        while(p1 <= mid && p2 <= r){
            help[i++] = arr[p1++] > arr[p2++] ? arr[p2++] : arr[p1++];
        }
        while(p1 <= mid){
            help[i++] = arr[p1++];
        }
        while(p2 <= r){
            help[i++] = arr[p2++];
        }
        for(i = 0;i < help.length;i++){
            arr[l + i] = help[i];
        }
    }
//    快排
//    经典快排 以最后一个数字
//    随机快排
    public static void quickSort(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        quickSort(arr,0,arr.length - 1);
    }
    public static void quickSort(int[] arr,int l,int r){
        if(l < r){
            swap(arr, r, l + (int)(Math.random() * (r - l + 1)) );
            int[] p = quickSort_patation(arr,l,r);
            quickSort(arr, l, p[0] - 1);
            quickSort(arr,p[1] + 1, r);
        }
    }
    public static int[] quickSort_patation(int[] arr,int l,int r){
        int less = l - 1;
        int more = r;
        while(l < more){
            if(arr[l] < arr[r]){
                swap(arr, l++, ++less);
            }else if(arr[l] > arr[r]){
                swap(arr, l, --more);
            }else{
                l++;
            }
        }
        swap(arr, more, r);
        return new int[]{less + 1, more};
    }

//    堆排序
    public static void heapSort(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        for(int i = 0; i < arr.length; i++){
            heapInsert(arr, i);
        }
        int size = arr.length;
        swap(arr, 0, --size);
        while(size > 0){
            heapify(arr, 0, size);
            swap(arr,0, --size);
        }
    }
    public static void heapify(int[] arr,int index,int size){
        int left = index * 2 + 1;
        while(left < size){
            int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
            largest = arr[largest] > arr[index] ? largest : index;
            if(largest == index){
                return;
            }
            swap(arr, index, largest);
            index = largest;
            left = index * 2 + 1;
        }
    }
    public static void heapInsert(int[] arr,int index){
        while(arr[index] > arr[ (index - 1) / 2 ]){
            swap(arr, index, (index - 1 ) / 2 );
            index = (index - 1) / 2;
        }
    }
    public static void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}