Java函数实现数组的排序算法

1. 冒泡排序

冒泡排序是比较常见的一种排序算法，也是最简单的一种排序算法，其主要思想是：将需要排序的数组进行多次遍历，每次遍历都将相邻的两个元素进行比较，如果前一个元素大于后一个元素则进行交换，这样一次遍历结束后，最大的元素就会被交换到最后面，接下来再次遍历，依次类推，最终完成整个数组的排序。

Java代码实现：

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

2. 选择排序

选择排序是另外一种比较简单的排序算法，其主要思想是在待排序的数组中选择一个最小（或者最大）的元素，放在数组的最前面，接着再在剩下的数组中选择一个最小（或者最大）的元素，放在已经排好序的元素后面，直到整个数组都排好序。

Java代码实现：

public static void selectionSort(int[] arr) {
    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;
            }
        }
        if (minIndex != i) {
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

3. 插入排序

插入排序也是一种比较常见的排序算法，其主要思想是将待排序的数组分成左右两个部分，左边部分是有序的，右边部分是无序的，每次遍历到一个元素，就将其插入到左边有序的部分中，最终得到一个有序的数组。

Java代码实现：

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

4. 希尔排序

希尔排序是一种改进版的插入排序算法，其主要思想是将数组分成若干个子数组，每个子数组都进行插入排序，不过每次插入排序的步长会逐渐缩小，最终完成整个数组的排序。

Java代码实现：

public static void shellSort(int[] arr) {
    int len = arr.length;
    int step = len / 2;
    while (step > 0) {
        for (int i = step; i < len; i++) {
            int cur = arr[i];
            int j = i - step;
            while (j >= 0 && arr[j] > cur) {
                arr[j + step] = arr[j];
                j -= step;
            }
            arr[j + step] = cur;
        }
        step /= 2;
    }
}

5. 快速排序

快速排序是比较流行的一种排序算法，其主要思想是选取一个基准元素，将数组分成左右两个部分，剩下的元素比基准元素小的放在左边，比基准元素大的放在右边，然后再对左右两个部分进行递归排序，最终得到一个有序的数组。

Java代码实现：

public static void quickSort(int[] arr, int left, int right) {
    if (left >= right) {
        return;
    }
    int i = left;
    int j = right;
    int pivot = arr[left];
    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);
}

总结：

以上就是常见的排序算法实现，不同的排序算法适用于不同的场合和数据量，相应的代码实现也略有不同。在实际使用时应根据需求选择合适的排序算法，以满足实际需求。