数组排序JAVA（冒泡排序，插入排序，选择排序，快速排序）

仅供自己做笔记使用，如果有错误，请各位大佬指出。 

冒泡排序：依次比较两个相邻元素，如果第一个比第二个大，就交换位置，这样最后的元素会是最大的数。然后重复以上步骤，除了最后一个数。每次对越来越少的元素重复以上步骤，直到没有元素可以比较为止。

插入排序：将数组第一个元素看作有序序列，第二个元素到最后一个元素看作无序序列，从第二个元素开始依次与前面的元素比较，如果前面的元素大则交换位置，直到放到合适的位置上。

选择排序：首先在未排序的序列中找到最小元素，与第一个位置上的元素交换。再从剩余未排序的序列中继续寻找最小元素，与已排序序列后一个位置上的元素交换。重复以上步骤，直到所有元素均排序完成。

快速排序：从数组中随机抽取一个元素，作为“基准”，与数组最后一个位置上的元素交换。其余元素以该基准进行排序，比基准小的元素放到数组左边，和基准相等的放到数组中间，比基准大的放到数组右边，基准与右边序列的第一个元素交换。这个称为分区操作。最后递归地把小于基准的子序列和大于基准的子序列排序。

import java.util.Scanner;

public class sort {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int len = sc.nextInt();
        int[] arr = new int[len];
        for (int i=0;i<len;i++) {
            arr[i] = sc.nextInt();
        }
        int[] res = SelectionSort(arr);
        System.out.print("[");
        for (int i=0;i<len;i++) {
            if (i==len-1) System.out.print(res[i]);
            else System.out.print(res[i] + ", ");
        }
        System.out.print("]");
    }

    // 交换数组中不同位置上的两个数
    public static void swap(int[] arr, int i, int j) {
        if (i==j) return;
        arr[i] = arr[i]^arr[j];
        arr[j] = arr[i]^arr[j];
        arr[i] = arr[i]^arr[j];
    }

    // 冒泡排序（稳定，时间O(N^2)，空间O(1)）
    public static int[] BubbloSort (int[] arr) {
        // write code here
        int len = arr.length;
        int max = len-1;
        for (int i=0;i<len-1;i++) {
            for (int j=0;j<max;j++) {
                if (arr[j]>arr[j+1]) swap(arr, j, j+1);
            }
            max = max-1;
        }
        return arr;
    }

    // 插入排序（稳定，时间O(N^2)，空间O(1)）
    public static int[] InsertionSort (int[] arr) {
        int len = arr.length;
        for (int i=1;i<len;i++) {
            for (int j=i-1;j>=0;j--) {
                if (arr[j]>arr[j+1]) swap(arr, j, j+1);
            }
        }
        return arr;
    }

    // 选择排序（稳定，时间O(N^2)，空间O(1)）
    public static int[] SelectionSort (int[] arr) {
        int len = arr.length;
        for (int i=0;i<len;i++) {
            for (int j=i+1;j<len;j++) {
                if (arr[i]>arr[j]) swap(arr, i, j);
            }
        }
        return arr;
    }

    // 快速排序（不稳定，时间O(NlogN)，空间O(logN)）
    public static int[] FastSort (int[] arr) {
        int len = arr.length;
        quickSort(arr, 0, len-1);
        return arr;
    }
    public static void quickSort(int[] arr, int left, int right) {
        if (left>=right) return;
        swap(arr, (int)(left+Math.random()*(right-left+1)), right);
        int[] p = partition(arr, left, right);
        quickSort(arr, left, p[0]-1);
        quickSort(arr, p[1]+1, right);
    }
    public static int[] partition(int[] arr, int left, int right) {
        int l = left;
        int r = right-1;
        int mid = left;
        while (mid<=r) {
            if (arr[mid]<arr[right]) {
                swap(arr, mid, l);
                mid++;
                l++;
            }else if (arr[mid]>arr[right]) {
                swap(arr, mid, r);
                r--;
            }else mid++;
        }
        swap(arr, r+1, right);
        return new int[]{l, r+1};
    }
}