在Java中实现排序函数的方法

Java中实现排序函数的方法有很多种，这里介绍几种常见的方法。

1. 冒泡排序

冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，每次比较相邻的两个元素，如果它们顺序错误就交换它们的位置，直到没有任何一对数字需要比较。

具体实现代码如下：

public static void bubbleSort(int[] arr) {
    int temp;
    for(int i=0; i<arr.length-1; 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;
            }
        }
    }
}

2. 选择排序

选择排序是一种简单直观的排序算法，它的基本思想是找到数组中最小值，将其放到数组的最前面，再从剩余未排序的元素中找到最小值，再放到已排序序列的末尾，以此类推，直到所有元素都排序完毕。

具体实现代码如下：

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

3. 插入排序

插入排序是一种简单直观的排序算法，它将数组分为已排序区间和未排序区间，在已排序区间中找到合适的位置插入未排序区间中的元素，直到未排序区间中的元素全部插入完成。

具体实现代码如下：

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

4. 快速排序

快速排序是一种常用的排序算法，它的基本思想是选择一个基准元素，将数组分为小于基准元素和大于基准元素的两部分，再递归地对两部分执行快速排序。

具体实现代码如下：

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

5. 归并排序

归并排序是一种稳定的排序算法，它的基本思想是将一个数组分成两部分，递归地对两部分分别进行归并排序，再将两部分合并成一个有序的数组。

具体实现代码如下：

public static void mergeSort(int[] arr, int left, int right) {
    if(left < right) {
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid+1, right);
        merge(arr, left, mid, right);
    }
}

public static void merge(int[] arr, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];
    int i = left, j = mid + 1, 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 p=0; p<temp.length; p++) {
        arr[left + p] = temp[p];
    }
}

以上是常见的几种排序方法，每种方法都有其适用的场景，在编写代码时需要根据实际情况选择合适的排序方法。以上排序算法的时间复杂度都为O(n^2)或O(nlogn)，在实际使用时需要根据数据量和排序效率的要求选择合适的方法。