排序算法 (Java语言实现)

选择排序

class Demo {

    public static void main(String[] args) {
        int[] arr = new int[6];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 20);
        }

        System.out.println("排序前：");
        for (int item : arr) {
            System.out.println(item);
        }

        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) { // 找到最小元素的下标
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            swap(arr, i, minIndex); // 将当前最小的元素放到正确位置
        }

        System.out.println("排序后：");
        for (int item : arr) {
            System.out.println(item);
        }
    }

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

冒泡排序

class Demo {
    public static void main(String[] args) {

        int[] arr = new int[10];
        boolean isSort = true; // 是否还需要排序

        geneArr(arr);

        System.out.println("排序前：");
        listArr(arr);

        for (int i = 0; i < arr.length - 1; i++) { // 排序逻辑
            isSort = false;
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    isSort = true;
                    swap(arr, j, j + 1);
                }
            }
            if (!isSort) { // isSort为false，说明本次内循环没有产生元素交换，则后面的元素已经有序
                break;
            }
        }

        System.out.println("排序后：");
        listArr(arr);
    }

    /**
     * 生成数组
     * 
     * @param arr
     */
    private static void geneArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 20);
        }
    }

    /**
     * 遍历输出数组中每个元素
     * 
     * @param arr
     */
    private static void listArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    /**
     * 交换数组中元素位置
     * 
     * @param arr
     * @param i
     * @param j
     */
    private 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];
    }
}

注意：若a[i]==a[j]，则不能用异或预算，否则会洗成零

归并排序

package p3;
import utils.ArrUtil;

class MergeSort {

    public static void main(String[] args) {
        int[] arr = new int[6];
        ArrUtil.geneArr(arr, 10);
        if (arr == null || arr.length < 2) {
            return;
        }
        System.out.println("排序前");
        ArrUtil.listArr(arr);
        process(arr, 0, arr.length - 1);
        System.out.println("排序后");
        ArrUtil.listArr(arr);
    }

    private static void process(int arr[], int left, int right) {

        if (left == right) {
            return;
        }
        int mid = left + ((right - left) >> 1);
        process(arr, left, mid);
        process(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }

    private static void merge(int[] arr, int left, int mid, int right) {

        int[] temp = new int[right - left + 1]; // 归并排序需要开辟一个新的数组空间
        int tempIndex = 0;
        int leftIndex = left;
        int rightIndex = mid + 1;
        while (leftIndex <= mid && rightIndex <= right) { // leftIndex、rightIndex只会向后移动，故都不能超出自己的右边界

            if (arr[leftIndex] <= arr[rightIndex]) {
                temp[tempIndex++] = arr[leftIndex++];
            } else {
                temp[tempIndex++] = arr[rightIndex++];
            }
        }
        while (leftIndex <= mid) {
            temp[tempIndex++] = arr[leftIndex++];
        }
        while (rightIndex <= right) {
            temp[tempIndex++] = arr[rightIndex++];
        }
        for (int i = 0; i < temp.length; i++) {
            arr[left + i] = temp[i];
        }
    }
}

快速排序

package p3;

import utils.ArrUtil;

class QuickSortClass {

    public static void main(String[] args) {
        int[] arr = new int[5];
        ArrUtil.geneArr(arr, 10);
        if (arr == null || arr.length < 2) {
            return;
        }
        System.out.println("排序前：");
        ArrUtil.listArr(arr);

        quickSort(arr, 0, arr.length - 1);

        System.out.println("排序后");
        ArrUtil.listArr(arr);
    }

    private static void quickSort(int[] arr, int left, int right) {

        if (left < right) {
            // 快排每次开始的时候随机选取一个数，与最后一个数交换，减少最坏情况发生次数
            swap(arr, left + (int) (Math.random() * (right - left + 1)), right);
            // 返回的是最靠近小于区域的枢轴与最靠近大于区域的枢轴的下标
            int[] boundary = partition(arr, left, right);
            quickSort(arr, left, boundary[0] - 1); // 进行小于区域排序
            quickSort(arr, boundary[1] + 1, right); // 进行大于区域排序
        }
    }

    private static int[] partition(int[] arr, int left, int right) {
        int lessBoundary = left - 1; // 小于区边界
        int moreBoundary = right; // 大于区边界
        while (left < moreBoundary) {
            // 这里的right是不变动的，充当枢轴的下标
            if (arr[left] < arr[right]) { // 当目前的left对应的元素小于枢轴的时候，将当前left对应的元素与小于区域边界的后一个元素交换，left接着往后走
                swap(arr, ++lessBoundary, left++);
            } else if (arr[left] > arr[right]) { // 当目前的left对应的元素大于枢轴的时候，将当前left对应的元素与大于区域边界前一个元素交互，left不动
                swap(arr, left, --moreBoundary);
            } else { // 当前值等于枢轴值，只有left往后走，没有交互操作
                left++;
            }
        }
        swap(arr, moreBoundary, right);
        return new int[] { lessBoundary + 1, moreBoundary };
    }

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