排序算法

见：https://blog.csdn.net/weixin_41190227/article/details/86600821

各种算法的比较

1. 冒泡排序：稳定，O(n2)
2. 插入排序：稳定，O(n2)
3. 归并：稳定，O(nlogn) ，需要 O(n) 额外存储空间
4. 选择排序：不稳定，O(n2)
5. 快排：不稳定，O(nlogn)，最好O(nlogn)，最坏O(n2)（这是有序的情况）
6. 堆排序：不稳定，O(nlogn)
7. 希尔排序：不稳定，O(nlogn)

快排实现

import java.util.Arrays;

public class Sort {
    public static void main(String[] args) {
        int[] a = {2,1,34,43,5,2,5,65,7,2,-1,-54};
        Sort sort = new Sort();
        sort.fastSort(a, 0, a.length);
        //a = sort.mergeSort(a);
        for(int i = 0; i < a.length; i++){
            System.out.print(a[i] + ",");
        }
    }

    /**
     * 快排，递归的方式
     * @param a
     * @param begin
     * @param end
     */
    public void fastSort(int[] a, int begin, int end){
        if(end - begin <= 1){
            return;
        }
        int index = end - 1;
        for(int i = begin + 1; i < end; i++){
            if(a[i] > a[begin] && index == end - 1){
                index = i;
            }
            if(a[i] <= a[begin] && index < end - 1){
                int num = a[index];
                a[index] = a[i];
                a[i] = num;
                index++;
            }
        }
        int num = a[index - 1];
        a[index - 1] = a[begin];
        a[begin] = num;
//        for(int i = 0; i < a.length; i++){
//            System.out.print(a[i] + ",");
//        }
        System.out.println();
        fastSort(a, begin, index - 1);
        fastSort(a, index, end);
    }
}

归并排序实现

import java.util.Arrays;

public class Sort {
    public static void main(String[] args) {
        int[] a = {2,1,34,43,5,2,5,65,7,2,-1,-54};
        Sort sort = new Sort();
        //sort.fastSort(a, 0, a.length);
        int[] x = sort.mergeSort(a);
        for(int i = 0; i < x.length; i++){
            System.out.print(x[i] + ",");
        }
    }

    public int[] mergeSort(int[] a){
        if(a.length <= 1){
            return a;
        }
        int mid = a.length/2;
        return merge(mergeSort(Arrays.copyOfRange(a, 0, mid)), mergeSort(Arrays.copyOfRange(a, mid, a.length)));
    }
    public int[] merge(int[] m, int[] n){
        int[] res = new int[m.length + n.length];
        int i = 0;
        int j = 0;
        while(i < m.length && j < n.length){
            if(m[i] < n[j]){
                res[i + j] = m[i++];
            }else{
                res[i + j] = n[j++];
            }
        }
        if(i <= m.length - 1){
            while (i < m.length) {
                res[i + j] = m[i++];
            }
        }
        if(j <= n.length - 1){
            while (j < n.length) {
                res[i + j] = n[j++];
            }
        }
        return res;
    }
}

堆排序实现

import java.util.Arrays;

public class Sort {
    public static void main(String[] args) {
        int[] a = {2,1,34,43,5,2,5,65,7,2,-1,-54};
        Sort sort = new Sort();
        //sort.fastSort(a, 0, a.length);
        //a = sort.mergeSort(a);
        sort.heapSort(a);
        for(int i = 0; i < a.length; i++){
            System.out.print(a[i] + ",");
        }
    }

    /**
     * 堆排序，每次选出最大值放在数组末尾
     * @param a
     */
    public void heapSort(int[] a){
        int index = a.length;
        while(index > 0){
            adjustHeap(a, 0, index);
            int num = a[index - 1];
            a[index - 1] = a[0];
            a[0] = num;
            index--;
        }
    }

    /**
     * 调整堆，使最大值放在第一个
     * @param a
     * @param i
     * @param end
     */
    private void adjustHeap(int[] a, int i, int end){
        int maxIndex = -1;
        int max = a[i];
        if(2 * i + 1 < end){
            adjustHeap(a, 2 * i + 1, end);
            if(max < a[2 * i + 1]){
                max = a[2 * i + 1];
                maxIndex = 2 * i + 1;
            }
        }
        if(2 * i + 2 < end){
            adjustHeap(a, 2 * i + 2, end);
            if(max < a[2 * i + 2]){
                maxIndex = 2 * i + 2;
            }
        }
        if(maxIndex == -1){
            return;
        }else{
            int num = a[i];
            a[i] = a[maxIndex];
            a[maxIndex] = num;
        }
    }
}