Java函数如何实现数值数组排序

Java提供了多种排序算法，可以对数值数组进行排序。以下是常用的几种排序算法实现：

1. 冒泡排序（Bubble Sort）：

冒泡排序是一种简单的排序算法，依次比较相邻两个元素，如果顺序错误就将它们交换位置，重复多次直到整个数组排序完成。

   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. 选择排序（Selection Sort）：

选择排序每次找到未排序部分的最小元素，然后和未排序部分的 个元素交换位置，重复这个过程直到整个数组排序完成。

   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. 插入排序（Insertion Sort）：

插入排序将数组分为已排序和未排序两部分，每次从未排序部分选择一个元素插入到已排序部分的正确位置，直到整个数组排序完成。

   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. 快速排序（Quick Sort）：

快速排序是一种高效的排序算法，通过选择一个枢纽元素将数组分成两部分，然后对左右两部分递归进行排序，直到整个数组排序完成。

   public static void quickSort(int[] array, int low, int high) {
       if (low < high) {
           int pivotIndex = partition(array, low, high);
           quickSort(array, low, pivotIndex - 1);
           quickSort(array, pivotIndex + 1, high);
       }
   }
   
   private static int partition(int[] array, int low, int high) {
       int pivot = array[high];
       int i = low - 1;
       for (int j = low; j < high; j++) {
           if (array[j] < pivot) {
               i++;
               // 交换元素
               int temp = array[i];
               array[i] = array[j];
               array[j] = temp;
           }
       }
       // 将枢纽元素放在正确位置
       int temp = array[i + 1];
       array[i + 1] = array[high];
       array[high] = temp;
       return i + 1;
   }
   

以上是常用的四种排序算法的Java实现，它们都可以对数值数组进行排序。根据具体情况和数据规模，选择合适的排序算法可以提高排序的效率。