Java常见的排序算法

Java几种常见的排序算法

public class SortUtils {

    // 冒泡排序
    public static void bubbleSort(int[] arr) {
        int temp;
        // 循环比较
        for (int i = 0; i < arr.length; i++) {
            // 循环比较
            for (int j = 0; j < arr.length - i - 1; j++) {
                // 如果当前值大于后一个值，则交换
                if (arr[j] > arr[j + 1]) {
                    // 交换
                    temp = arr[j];
                    // 将后一个值赋值给当前值
                    arr[j] = arr[j + 1];
                    // 将当前值赋值给后一个值
                    arr[j + 1] = temp;
                }
            }
        }
    }

    // 选择排序
    public static void selectionSort(int[] arr) {
        int temp;
        // 循环比较
        for (int i = 0; i < arr.length; i++) {
            int min = i;
            // 循环比较
            for (int j = i + 1; j < arr.length; j++) {
                // 如果当前值小于前一个值，则交换
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }
            temp = arr[i];
            // 将前一个值赋值给当前值
            arr[i] = arr[min];
            // 将当前值赋值给前一个值
            arr[min] = temp;
        }
    }

    // 插入排序
    public static void insertionSort(int[] arr) {
        int temp;
        // 循环比较
        for (int i = 1; i < arr.length; i++) {
            // 循环比较
            for (int j = i; j > 0; j--) {
                // 如果当前值小于前一个值，则交换
                if (arr[j] < arr[j - 1]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
    }

    // 希尔排序
    public static void shellSort(int[] arr) {
        // 计算分组间隔
        int temp;
        // 分组间隔为1时，直接返回
        int gap = arr.length / 2;
        // 当分组间隔大于1时，继续进行分组
        while (gap > 0) {
            // 对分组进行排序
            for (int i = gap; i < arr.length; i++) {
                // 循环比较
                for (int j = i; j >= gap; j -= gap) {
                    // 如果当前值小于前一个值，则交换
                    if (arr[j] < arr[j - gap]) {
                        // 交换
                        temp = arr[j];
                        // 将前一个值赋值给当前值
                        arr[j] = arr[j - gap];
                        // 将当前值赋值给前一个值
                        arr[j - gap] = temp;
                    }
                }
            }
            // 减少分组间隔
            gap /= 2;
        }
    }

    // 归并排序
    public static void mergeSort(int[] arr) {
        mergeSort(arr, 0, arr.length - 1);
    }

    private static void mergeSort(int[] arr, int left, int right) {
        // 当数组长度小于等于1时，不再进行排序
        if (left >= right) {
            // 当数组长度为1时，直接返回
            return;
        }
        // 计算中间值
        int mid = (left + right) / 2;
        // 对左边数组进行递归排序
        mergeSort(arr, left, mid);
        // 对右边数组进行递归排序
        mergeSort(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 i = left;
        // 初始化临时数组下标
        int j = mid + 1;
        // 初始化临时数组下标
        int k = 0;
        // 循环遍历数组
        while (i <= mid && j <= right) {
            // 当左边数组元素小于右边数组元素时，将左边数组元素放入临时数组
            if (arr[i] < arr[j]) {
                // 将左边数组元素放入临时数组
                temp[k++] = arr[i++];
            }
            // 当左边数组元素大于右边数组元素时，将右边数组元素放入临时数组
            else {
                // 将右边数组元素放入临时数组
                temp[k++] = arr[j++];
            }
        }
        // 当左边数组元素还有剩余时，将左边数组元素放入临时数组
        while (i <= mid) {
            // 将左边数组元素放入临时数组
            temp[k++] = arr[i++];
        }
        // 当右边数组元素还有剩余时，将右边数组元素放入临时数组
        while (j <= right) {
            // 将右边数组元素放入临时数组
            temp[k++] = arr[j++];
        }
        // 将临时数组中的元素放入原数组
        for (int m = 0; m < temp.length; m++) {
            // 将临时数组中的元素放入原数组
            arr[left + m] = temp[m];
        }
    }


    // 快速排序
    public static void quickSort(int[] arr) {
        quickSort(arr, 0, arr.length - 1);
    }

    private static void quickSort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int temp = arr[left];
        int i = left;
        int j = right;
        while (i < j) {
            while (i < j && arr[j] >= temp) {
                j--;
            }
            if (i < j) {
                arr[i++] = arr[j];
            }
            while (i < j && arr[i] <= temp) {
                i++;
            }
            if (i < j) {
                arr[j--] = arr[i];
            }
        }
        arr[i] = temp;
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }

    // 堆排序
    public static void heapSort(int[] arr) {
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            heapAdjust(arr, i, arr.length - 1);
        }
        for (int i = arr.length - 1; i > 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            heapAdjust(arr, 0, i - 1);
        }
    }

    private static void heapAdjust(int[] arr, int parent, int length) {
        int temp = arr[parent];
        int child = 2 * parent + 1;
        while (child <= length) {
            if (child < length && arr[child] < arr[child + 1]) {
                child++;
            }
            if (temp < arr[child]) {
                arr[parent] = arr[child];
                parent = child;
                child = 2 * parent + 1;
            }
            else {
                break;
            }
        }
        arr[parent] = temp;
    }

    // 基数排序
    public static void radixSort(int[] arr) {
        // 获取最大数的位数
        int max = arr[0];
        // 循环遍历数组
        for (int i = 1; i < arr.length; i++) {
            // 当数组元素大于最大数时，将数组元素赋值给最大数
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        int exp = 1;
        // 循环遍历最大数的位数
        while (max / exp > 0) {
            // 定义临时数组
            int[] bucket = new int[10];
            for (int i = 0; i < arr.length; i++) {
                bucket[(arr[i] / exp) % 10]++;
            }
            for (int i = 1; i < 10; i++) {
                bucket[i] += bucket[i - 1];
            }
            int[] temp = new int[arr.length];
            for (int i = arr.length - 1; i >= 0; i--) {
                temp[--bucket[(arr[i] / exp) % 10]] = arr[i];
            }
            for (int i = 0; i < arr.length; i++) {
                arr[i] = temp[i];
            }
            exp *= 10;
        }
    }
}