Java函数的排序算法实现

Java中的排序算法是对一组数据按照一定规则进行排序的算法。常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。

冒泡排序是一种基本的排序算法，其思想是从数组的第一个元素开始，依次比较相邻的两个元素，若顺序不对则交换位置，直至整个数组有序。具体实现如下：

public static void bubbleSort(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    int n = array.length;
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-1-i; j++) {
            if (array[j] > array[j+1]) {
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}

选择排序的思想是每次从未排序的部分选择最小的元素，放到已排序部分的末尾。具体实现如下：

public static void selectionSort(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    int n = array.length;
    for (int i = 0; i < n-1; i++) {
        int minIndex = i;
        for (int j = i+1; j < n; j++) {
            if (array[j] < array[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            int temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }
    }
}

插入排序的思想是将未排序的元素插入已排序部分的正确位置。具体实现如下：

public static void insertionSort(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    int n = array.length;
    for (int i = 1; i < n; i++) {
        int current = array[i];
        int j = i-1;
        while (j >= 0 && array[j] > current) {
            array[j+1] = array[j];
            j--;
        }
        array[j+1] = current;
    }
}

快速排序是一种分治的排序算法，其递归地将数组分为较小和较大的两个子数组，分别对两个子数组进行排序。具体实现如下：

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

归并排序是将数组分成两个子数组，分别进行排序，然后将排好序的子数组再合并成一个有序数组。具体实现如下：

public static void mergeSort(int[] array, int start, int end) {
    if (start >= end) {
        return;
    }
    int mid = (start + end) / 2;
    mergeSort(array, start, mid);
    mergeSort(array, mid+1, end);
    merge(array, start, mid, end);
}

public static void merge(int[] array, int start, int mid, int end) {
    int[] temp = new int[end-start+1];
    int i = start, j = mid+1, k = 0;
    while (i <= mid && j <= end) {
        if (array[i] <= array[j]) {
            temp[k++] = array[i++];
        } else {
            temp[k++] = array[j++];
        }
    }
    while (i <= mid) {
        temp[k++] = array[i++];
    }
    while (j <= end) {
        temp[k++] = array[j++];
    }
    for (i = 0; i < temp.length; i++) {
        array[start+i] = temp[i];
    }
}

以上就是几种常见的排序算法在Java中的实现。不同的排序算法适用于不同的场景，选择合适的排序算法可以提高排序效率。在实际应用中，还可以根据具体需求对排序算法进行优化，进一步提高排序效率。