Java排序算法

import java.util.Arrays;

public class Test {
    // 冒泡排序
    public static void BubbleSort(int[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }

    // 选择排序
    public static void SelectSort(int[] a) {
        int k, temp;
        for (int i = 0; i < a.length - 1; i++) {
            k = i;
            for (int j = i; j < a.length - 1; j++) {
                if (a[k] > a[j + 1]) {
                    k = j + 1;
                }
            }
            if (k != i) {
                temp = a[i];
                a[i] = a[k];
                a[k] = temp;
            }
        }
    }

    // 快速排序
    public static void QuickSort(int[] a, int left, int right) {
        /*
         * if (left > right) { return; } 如果左边比右边大了就退出循环 也可以在递归调用的时候判断
         */
        // 把左边的值给p
        int p = a[left];
        // 把左边索引给i，右边给j
        int i = left, j = right;
        // 如果左边小于右边就循环，等于就退出循环
        while (i < j) {
            // 如果右边索引的值比p大，且i<j，继续向左边寻找
            while (a[j] >= p && i < j) {
                j--;
            }
            // 如果左边索引的值比p小，且(i<j)，继续向右边寻找
            while (a[i] <= p && i < j) {
                i++;
            }
            // 左边找到比p大的，右边找到比p小的，交换他们的位置
            if (i < j) {
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
        // 把中间值给最左边
        a[left] = a[i];
        // 把最左边的值给中间
        a[i] = p;
        // 如果左边的索引比中间索引小就递归
        if (left < i)
            QuickSort(a, left, i - 1);
        // 如果右边的索引比中间索引大就递归
        if (i < right)
            QuickSort(a, i + 1, right);
    }

    private static void print(int[] a) {
        System.out.println(Arrays.toString(a));
    }

    // 插入排序
    public static void InsertSort(int[] a) {
        for (int i = 1; i < a.length; i++) {
            // 每次将a[i]插入到a[0]-a[i-1]中去
            int temp = a[i];
            // a[j]是a[i]的前一个元素
            int j = i - 1;
            //当a[j]比temp小且j>=0时,把当前的a[j]后移一位
            while (j >= 0 && a[j] > temp) {
                a[j + 1] = a[j];
                j--;
            }
            // 循环退出后把temp插入到当前的j后面的一个元素
            a[j + 1] = temp;
        }
    }

    public static void main(String[] args) {
        int[] a = { 46, 12, 25, 33, 33, 68, 19, 80 };

        System.out.println("待排序:");
        Test.print(a);

        System.out.println("冒泡排序:");
        Test.BubbleSort(a); // 冒泡排序
        Test.print(a);

        System.out.println("快速排序:");
        Test.QuickSort(a, 0, a.length - 1); // 快速排序
        Test.print(a);

        System.out.println("选择排序:");
        Test.SelectSort(a); // 选择排序
        Test.print(a);

        System.out.println("插入排序:");
        Test.InsertSort(a); // 插入排序
        Test.print(a);
    }
}

运行结果：

待排序:
[46, 12, 25, 33, 33, 68, 19, 80]
冒泡排序:
[12, 19, 25, 33, 33, 46, 68, 80]
快速排序:
[12, 19, 25, 33, 33, 46, 68, 80]
选择排序:
[12, 19, 25, 33, 33, 46, 68, 80]
插入排序:
[12, 19, 25, 33, 33, 46, 68, 80]