冒泡，选择，插入，快速排序算法

冒泡排序算法

public class BubbleSort {

    public static void bubbleSort(int[] arr){

        // 第一轮循环 n-1次
        for (int i = 0; i < arr.length-1; i++) {
            // 第二轮循环 n-1-i
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int [] a = new int [] {9, 5, 1, 2, 7, 3, 4, 8, 6};
        BubbleSort.bubbleSort(a);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}

选择排序算法

public class SelectionSort {
    public static void sort(int [] arrs) {
        // 最外层循环有n-1个minindex
        for (int i = 0; i < arrs.length-1; i++) {
            // 第二层有 i+1到 n 的遍历
            int minindex = i;
            for (int j = i+1; j < arrs.length; j++) {
                if(arrs[j]<arrs[minindex]){
                    minindex=j;
                }
            }
            if(minindex!=i){
                // 最小数据的索引发生了改变，则进行数据的交换
                int temp=arrs[i];
                arrs[i]=arrs[minindex];
                arrs[minindex]=temp;
            }
        }
    }

    public static void main(String[] args) {
        int [] a = new int[]{1,10, 8, 29, 48, 10, 5, 18, 4};
        SelectionSort.sort(a);
        Arrays.stream(a).forEach(System.out::println);
    }
}

插入排序算法

public class InsertSort {
    public static void sort(int[] arr){
        // 第一轮循环 n 从左往右
        for (int i = 0; i < arr.length; i++) {
            // 第二轮循环 i~0 从右往左
            for (int j = i; j > 0; j--) {
                if(arr[j]<arr[j-1]){
                    // 进行交换（右边的小于左边的）因为之前都是排好序的
                    // 新加的数据，我们只要从右往左进行判断就行了
                    int temp = arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=temp;
                }else {
                    // 如果发生了大于的情况，则可以终止这一轮的循环了，节约时间
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {
        int [] a = new int [] {10, 8, 100, 78, 66, 33, 88};

        InsertSort.sort(a);

        Arrays.stream(a).forEach(System.out::println);
    }
}

快速排序算法

public class Quick2Sort {

    public static void sort(int[] arr ,int left, int right){
        // 设置结束的条件
        if(left>=right){
            return;
        }
        // 记录左边编号，记录右边编号
        int i = left;
        int j = right;

        // 记录基准数字
        int base = left;

        // 核心算法
        while (i<j){
            // 对 i 开始移动，遇到就比基准大的，就结束循环
            while(arr[i]<=arr[base]){
                i++;
            }
            // 对 j 开始移动，遇到就比基准小的，就结束循环
            while(arr[j]>arr[base]){
                j--;
            }
            // 进行交换
            if(i<j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        // 把 i-1 和 base 的位置进行交换
        int temp=arr[i-1];
        arr[i-1]=arr[base];
        arr[base]=temp;

        // 循环递归
        // i-1 位置的左边
        sort(arr,left,i-2);
        // i-1 位置的右边
        sort(arr,i,right);
    }

    public static void sort(int [] a){
        sort(a, 0, a.length-1);
    }

    public static void main(String[] args) {
        Integer[] a = {5,2,12,6,67,3,2,3,6,5,23,243,32,567,67,878,3,34,6,6,345,23,21,3,45,100,45,23,2,3,45};
        QuickSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

另外一个代码版本：

public class QuickSort {

    // 私有的构造方法
    private QuickSort() {};

    // 排序算法的方法定义
    public  static <E extends Comparable<E>> void sort(E[] arr){
        sort(arr,0,arr.length-1);
    };

    private static <E extends Comparable<E>> void sort(E[] arr,int l,int r){

        if(l>=r) return;

        int p =partition(arr,l,r);
        sort(arr,l,p-1);
        sort(arr,p+1,r);
    };

    // 首先实现partition的部分
    private static <E extends Comparable<E>> int partition(E[] arr,int l,int r){
        // arr[l+1...j]<v  and arr[j+1...i]>=v  循环不变量
        int j=l;
        for (int i = l+1; i <=r ; i++) {
            if(arr[i].compareTo(arr[l])<0){
                j++;
                swap(arr,i,j);
            }
        }
        swap(arr,l,j);
        return j;
    }

    private static <E> void swap(E[]arr,int i,int j){
        E temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

    public static void main(String[] args) {
        int n=1000000;
        Integer[] arr ={1,10,4,7,8,9,3,21,11};
        sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}