Java中常用的排序函数

在Java中，常用的排序函数有许多种，包括冒泡排序、选择排序、插入排序、快速排序、归并排序等等。下面将针对这些常用的排序函数进行介绍。

1. 冒泡排序：冒泡排序是一种简单的排序算法，其原理是比较相邻的两个元素，如果顺序不对则交换位置，使得较大的元素逐渐“冒泡”到顶部。这个过程会持续进行多次，直到所有元素都排好序为止。

冒泡排序的代码实现可以如下所示：

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

2. 选择排序：选择排序是一种简单直观的排序算法，其原理是每次从待排序的数据中选择最小值放在已排序部分的末尾。每次选取最小值都需要遍历未排序部分，找到最小值并进行交换。这个过程会持续进行多次，直到所有元素都排好序为止。

选择排序的代码实现可以如下所示：

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

3. 插入排序：插入排序是一种简单直观的排序算法，其原理是将未排序的元素逐个插入到已排序部分的合适位置。在插入的过程中，需要不断地将有序的元素向后移动，为新元素腾出位置。这个过程会持续进行多次，直到所有元素都排好序为止。

插入排序的代码实现可以如下所示：

   public static void insertionSort(int[] arr) {
       int len = arr.length;
       for (int i = 1; i < len; 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. 快速排序：快速排序是一种高效的排序算法，其原理是选择一个基准元素，通过一趟排序将待排元素分割成独立的两部分，其中一部分的所有元素均小于基准元素，另一部分的所有元素均大于基准元素。然后依次对两部分进行快速排序，直到所有元素都排好序为止。

快速排序的代码实现可以如下所示：

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

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);
       }
   }

   private static void merge(int[] arr, int left, int mid, int right) {
       int[] temp = new int[right - left + 1];
       int i = left;
       int j = mid + 1;
       int k = 0;
       while (i <= mid && j <= right) {
           if (arr[i] <= arr[j]) {
               temp[k] = arr[i];
               i++;
           } else {
               temp[k] = arr[j];
               j++;
           }
           k++;
       }
       while (i <= mid) {
           temp[k] = arr[i];
           i++;
           k++;
       }
       while (j <= right) {
           temp[k] = arr[j];
           j++;
           k++;
       }
       for (int m = 0; m < temp.length; m++) {
           arr[left + m] = temp[m];
       }
   }
   

以上介绍了Java中常用的几种排序函数及其代码实现。这些排序函数具有不同的特点和适用情况，根据具体的需求可以选择合适的排序函数来使用。