Java函数实现常见排序算法

常见的排序算法有冒泡排序、插入排序、选择排序、归并排序、快速排序等。下面将通过 Java 函数实现这些排序算法。

一、冒泡排序

冒泡排序是一种基础的排序算法，在数组中从前往后依次比较相邻的两个数，如果前一个数大于后一个数，则交换两个数的位置，直至整个数组有序。

Java 函数实现：

public static void bubbleSort(int[] arr) {
    int len = arr.length;
    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

二、插入排序

插入排序是一种简单直观的排序算法，在数组中将元素分为有序区和无序区，每次取出无序区中的一个元素插入到有序区中，使得插入后的有序区仍然有序。

Java 函数实现：

public static void insertSort(int[] arr) {
    int len = arr.length;
    for (int i = 1; i < len; i++) {
        int current = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > current) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = current;
    }
}

三、选择排序

选择排序是一种简单的排序算法，每次在无序区中选择最小的元素与无序区的 个元素交换位置，直到整个数组有序。

Java 函数实现：

public static void selectSort(int[] arr) {
    int len = arr.length;
    for (int i = 0; i < len - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

四、归并排序

归并排序是一种分治思想的排序算法，将待排序数组分成若干子序列，每个子序列都是有序的，然后再将子序列两两合并，直到整个数组有序。

Java 函数实现：

public static void mergeSort(int[] arr) {
    int len = arr.length;
    if (len <= 1) {
        return;
    }
    int[] leftArr = Arrays.copyOfRange(arr, 0, len / 2);
    int[] rightArr = Arrays.copyOfRange(arr, len / 2, len);
    mergeSort(leftArr);
    mergeSort(rightArr);
    int i = 0, j = 0, k = 0;
    while (i < leftArr.length && j < rightArr.length) {
        if (leftArr[i] < rightArr[j]) {
            arr[k++] = leftArr[i++];
        } else {
            arr[k++] = rightArr[j++];
        }
    }
    while (i < leftArr.length) {
        arr[k++] = leftArr[i++];
    }
    while (j < rightArr.length) {
        arr[k++] = rightArr[j++];
    }
}

五、快速排序

快速排序是一种分治思想的排序算法，选择一个基准元素，将整个数组分成小于等于基准元素和大于基准元素两个子序列，然后递归地对两个子序列进行排序。

Java 函数实现：

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

以上就是对常见排序算法的 Java 函数实现，通过这些算法，可以更好地理解排序的本质和实现方式。