用Java实现的数字排序函数

数字排序是计算机科学中的基本算法之一。数字排序是对数字序列的重新排列，使得这些数字按一定的规则有序排列。数字排序算法可以分为内部排序和外部排序两种。

内部排序是指将数据全部存放在内存中进行排序的方法。常用的内部排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。

外部排序是指对于大量数据无法一次性存储在内存中，需要借助辅助存储设备进行排序的方法。常用的外部排序算法包括归并排序、败者树排序、置换排序、多路归并排序等。

下面我们主要介绍Java实现的内部排序算法。

1. 冒泡排序

冒泡排序是一种简单的排序算法，通过不断比较相邻两个元素，将较小元素逐个向前移动，直到整个序列有序。

Java实现代码：

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

2. 选择排序

选择排序是一种简单的排序算法，每次遍历选择最小的元素，放到已排序序列的最后。

Java实现代码：

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

3. 插入排序

插入排序是一种简单的排序算法，每次将未排序的元素插入已排序的序列中。

Java实现代码：

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

4. 快速排序

快速排序是一种高效的排序算法，基于分治思想，将序列分为左右两部分，左半部分小于右半部分，然后对左右两部分递归排序。

Java实现代码：

public static void quickSort(int[] array) {
    quickSort(array, 0, array.length - 1);
}

private static void quickSort(int[] array, int left, int right) {
    if (left < right) {
        int pivot = partition(array, left, right);
        quickSort(array, left, pivot - 1);
        quickSort(array, pivot + 1, right);
    }
}

private static int partition(int[] array, int left, int right) {
    int pivot = array[left];
    int i = left + 1;
    int j = right;
    while (true) {
        while (i <= j && array[i] < pivot) {
            i++;
        }
        while (i <= j && array[j] > pivot) {
            j--;
        }
        if (i > j) {
            break;
        }
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
        i++;
        j--;
    }
    array[left] = array[j];
    array[j] = pivot;
    return j;
}

5. 归并排序

归并排序是一种高效的排序算法，基于分治思想，将序列分为两部分，分别对两部分进行排序，然后将两部分有序地合并成一个序列。

Java实现代码：

public static void mergeSort(int[] array) {
    mergeSort(array, 0, array.length - 1);
}

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

private static void merge(int[] array, 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 (array[i] <= array[j]) {
            temp[k++] = array[i++];
        } else {
            temp[k++] = array[j++];
        }
    }
    while (i <= mid) {
        temp[k++] = array[i++];
    }
    while (j <= right) {
        temp[k++] = array[j++];
    }
    for (k = 0; k < temp.length; k++) {
        array[left + k] = temp[k];
    }
}

总结：

以上是Java实现的五种常用的数字排序算法，它们都具有简单、高效等优点，可以满足各种不同的排序需求。在实际开发过程中，我们可以根据具体的场景选择适当的算法来实现数字排序。