常见几种排序

选择排序

过程：

package Sort;

import java.util.Arrays;

public class InsertSort {
    public static void insertSort(int[] arr){
        if (arr== null|| arr.length < 2){
            return;
        }
        //0- 0 上有序
        //0- i 上有序
        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);
            }
        }
    }
    //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];
    //}
    //和上面等同
    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
    	arr[i] = arr[j];
        arr[j] = tmp;
    }
}

冒泡排序

public static void bubbleSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    // 0 ~ N-1
    // 0 ~ N-2
    // 0 ~ N-3
    for (int e = arr.length - 1; e > 0; e--) { // 0 ~ e
        for (int i = 0; i < e; i++) {
            if (arr[i] > arr[i + 1]) {
                swap(arr, i, i + 1);
            }
        }
    }
    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];
    }
}

快速排序

package Sort;

import java.util.Arrays;

public class QuickSort {
    public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        process3(arr, 0, arr.length - 1);
    }

    public static void process3(int[] arr, int L, int R) {
        if (L >= R) {
            return;
        }
        swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
        int[] equalArea = netherlandsFlag(arr, L, R);
        process3(arr, L, equalArea[0] - 1);
        process3(arr, equalArea[1] + 1, R);
    }

    // arr[L...R] 玩荷兰国旗问题的划分，以arr[R]做划分值
    //  <arr[R]  ==arr[R]  > arr[R]
    // 返回等于区域左边界与右边界
    public static int[] netherlandsFlag(int[] arr, int L, int R) {
        if (L > R) {
            return new int[]{-1, -1};
        }
        if (L == R) {
            return new int[]{L, R};
        }
        int less = L - 1; // < 区 右边界
        int more = R;     // > 区 左边界
        int index = L;
        while (index < more) {
            if (arr[index] == arr[R]) {
                index++;
            } else if (arr[index] < arr[R]) {
                swap(arr, index++, ++less);
            } else { // >
                swap(arr, index, --more);
            }
        }
        // L...less   less+1...more-1    more...R-1        R
        // L...less   less+1.............more  more+1...   R
        swap(arr, more, R);
        return new int[]{less + 1, more};
    }

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void main(String[] args) {
        int[] a = {2, 6, 3, 2, 1};
        quickSort(a);
        System.out.println(Arrays.toString(a));
    }
}

插入排序

public static void insertionSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    // 0~0 有序的
    // 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);
        }
    }
}

归并排序

1）整体是递归，左边排好序+右边排好序+merge让整体有序
2）让其整体有序的过程里用了排外序方法
3）利用master公式来求解时间复杂度
4）当然可以用非递归实现

// 递归方法实现
public static void mergeSort1(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    process(arr, 0, arr.length - 1);
}

// arr[L...R]范围上，变成有序的
// L...R    N    T(N) = 2*T(N/2) + O(N)  ->
public static void process(int[] arr, int L, int R) {
    if (L == R) { // base case
        return;
    }
    int mid = L + ((R - L) >> 1);
    process(arr, L, mid);
    process(arr, mid + 1, R);
    merge(arr, L, mid, R);
}

public static void merge(int[] arr, int L, int M, int R) {
    int[] help = new int[R - L + 1];
    int i = 0;
    int p1 = L;
    int p2 = M + 1;
    while (p1 <= M && p2 <= R) {
        help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
    }
    // 要么p1越界了，要么p2越界了
    while (p1 <= M) {
        help[i++] = arr[p1++];
    }
    while (p2 <= R) {
        help[i++] = arr[p2++];
    }
    for (i = 0; i < help.length; i++) {
        arr[L + i] = help[i];
    }
}

快速排序

Partition过程

给定一个数组arr，和一个整数num。请把小于等于num的数放在数组的左边，大于num的数放在数组的右边。

要求额外空间复杂度O(1)，时间复杂度O(N)

// arr[L...R] 玩荷兰国旗问题的划分，以arr[R]做划分值
//  <arr[R]  ==arr[R]  > arr[R]
public static int[] netherlandsFlag(int[] arr, int L, int R) {
    if (L > R) {
        return new int[] { -1, -1 };
    }
    if (L == R) {
        return new int[] { L, R };
    }
    int less = L - 1; // < 区 右边界
    int more = R;     // > 区 左边界
    int index = L;
    while (index < more) {
        if (arr[index] == arr[R]) {
            index++;
        } else if (arr[index] < arr[R]) {
            swap(arr, index++, ++less);
        } else { // >
            swap(arr, index, --more);
        }
    }
    // L...less   less+1...more-1    more...R-1        R
    // L...less   less+1.............more  more+1...   R
    swap(arr, more, R);
    return new int[] { less + 1, more };
}

快速排序1.0

在arr[L…R]范围上，进行快速排序的过程：

1）用arr[R]对该范围做partition，<= arr[R]的数在左部分并且保证arr[R]最后来到左部分
的最后一个位置，记为M； <= arr[R]的数在右部分（arr[M+1…R]）
2）对arr[L…M-1]进行快速排序(递归)
3）对arr[M+1…R]进行快速排序(递归)

因为每一次partition都会搞定一个数的位置且不会再变动，所以排序能完成.

public static int partition(int[] arr, int L, int R) {
    if (L > R) {
        return -1;
    }
    if (L == R) {
        return L;
    }
    int lessEqual = L - 1;
    int index = L;
    while (index < R) {
        if (arr[index] <= arr[R]) {
            swap(arr, index, ++lessEqual);
        }
        index++;
    }
    swap(arr, ++lessEqual, R);
    return lessEqual;
}

public static void quickSort1(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    process1(arr, 0, arr.length - 1);
}

public static void process1(int[] arr, int L, int R) {
    if (L >= R) {
        return;
    }
    // L..R partition arr[R]  [   <=arr[R]   arr[R]    >arr[R]  ]
    int M = partition(arr, L, R);
    process1(arr, L, M - 1);
    process1(arr, M + 1, R);
}

快速排序2.0

在arr[L…R]范围上，进行快速排序的过程：

1）用arr[R]对该范围做partition，< arr[R]的数在左部分，== arr[R]的数中间，
>arr[R]的数在右部分。假设== arr[R]的数所在范围是[a,b]
2）对arr[L…a-1]进行快速排序(递归)
3）对arr[b+1…R]进行快速排序(递归)

因为每一次partition都会搞定一批数的位置且不会再变动，所以排序能完成

荷兰国旗问题
// arr[L...R] 玩荷兰国旗问题的划分，以arr[R]做划分值
//  <arr[R]  ==arr[R]  > arr[R]
// 返回等于区域左边界与右边界
public static int[] netherlandsFlag(int[] arr, int L, int R) {
    if (L > R) {
        return new int[] { -1, -1 };
    }
    if (L == R) {
        return new int[] { L, R };
    }
    int less = L - 1; // < 区 右边界
    int more = R;     // > 区 左边界
    int index = L;
    while (index < more) {
        if (arr[index] == arr[R]) {
            index++;
        } else if (arr[index] < arr[R]) {
            swap(arr, index++, ++less);
        } else { // >
            swap(arr, index, --more);
        }
    }
    // L...less   less+1...more-1    more...R-1        R
    // L...less   less+1.............more  more+1...   R
    swap(arr, more, R);
    return new int[] { less + 1, more };
}

public static void quickSort2(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    process2(arr, 0, arr.length - 1);
}

public static void process2(int[] arr, int L, int R) {
    if (L >= R) {
        return;
    }
    int[] equalArea = netherlandsFlag(arr, L, R);
    process2(arr, L, equalArea[0] - 1);
    process2(arr, equalArea[1] + 1, R);
}

快速排序3.0(随机快排+荷兰国旗技巧优化）

在arr[L…R]范围上，进行快速排序的过程：
1）在这个范围上，随机选一个数记为num，
2）用num对该范围做partition，< num的数在左部分，== num的数中间，>num的数在右部分。
假设== num的数所在范围是[a,b]
3）对arr[L…a-1]进行快速排序(递归)
4）对arr[b+1…R]进行快速排序(递归)

因为每一次partition都会搞定一批数的位置且不会再变动，所以排序能完成

public static void quickSort3(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    process3(arr, 0, arr.length - 1);
}

public static void process3(int[] arr, int L, int R) {
    if (L >= R) {
        return;
    }
    swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
    int[] equalArea = netherlandsFlag(arr, L, R);
    process3(arr, L, equalArea[0] - 1);
    process3(arr, equalArea[1] + 1, R);
}