Java中的几种经典排序算法实现

一、引言

排序是计算机科学中的一个基本问题，也是许多实际应用的基础。在Java中，我们可以实现多种排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。每种排序算法都有其独特的特点和适用场景。本文将介绍这些算法的基本原理，并提供相应的Java代码实现。

二、冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法，通过重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

Java代码实现：

java 复制代码

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

三、选择排序（Selection Sort）

选择排序是一种简单直观的排序算法。它的工作原理是首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

Java代码实现：

java 复制代码

public static void selectionSort(int[] arr) {  
    int n = arr.length;  
    for (int i = 0; i < n - 1; i++) {  
        int minIndex = i;  
        for (int j = i + 1; j < n; j++) {  
            if (arr[j] < arr[minIndex]) {  
                minIndex = j;  
            }  
        }  
        // Swap the found minimum element with the first element  
        int temp = arr[minIndex];  
        arr[minIndex] = arr[i];  
        arr[i] = temp;  
    }  
}

四、插入排序（Insertion Sort）

插入排序的工作方式是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

Java代码实现：

java 复制代码

public static void insertionSort(int[] arr) {  
    int n = arr.length;  
    for (int i = 1; i < n; ++i) {  
        int key = arr[i];  
        int j = i - 1;  
        /* Move elements of arr[0..i-1], that are  
           greater than key, to one position ahead  
           of their current position */  
        while (j >= 0 && arr[j] > key) {  
            arr[j + 1] = arr[j];  
            j = j - 1;  
        }  
        arr[j + 1] = key;  
    }  
}

五、快速排序（Quick Sort）

快速排序是一种分而治之的排序算法。通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

Java代码实现：

java 复制代码

public static void quickSort(int[] arr, int low, int high) {  
    if (low < high) {  
        /* pi is partitioning index, arr[p] is now  
           at right place */  
        int pi = partition(arr, low, high);  
  
        // Recursively sort elements before  
        // partition and after partition  
        quickSort(arr, low, pi - 1);  
        quickSort(arr, pi + 1, high);  
    }  
}  
  
/* This function takes last element as pivot, places  
   the pivot element at its correct position in sorted  
   array, and places all smaller (smaller than pivot)  
   to left of pivot and all greater elements to right  
   of pivot */  
public staticint partition(int[] arr, int low, int high) {
int pivot = arr[high]; // pivot
int i = (low - 1); // Index of smaller element

for (int j = low; j <= high - 1; j++) {  
    // If current element is smaller than or  
    // equal to pivot  
    if (arr[j] <= pivot) {  
        i++;    // increment index of smaller element  
        // Swap arr[i] and arr[j]  
        int temp = arr[i];  
        arr[i] = arr[j];  
        arr[j] = temp;  
    }  
}  
 
// Swap pivot and arr[i+1] (or arr[high])  
int temp = arr[i + 1];  
arr[i + 1] = arr[high];  
arr[high] = temp;  
 
return i + 1;
}

六、归并排序（Merge Sort）

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

Java代码实现：

java 复制代码

public static void mergeSort(int[] arr) {  
    if (arr.length > 1) {  
        int mid = arr.length / 2;  
        int[] left = Arrays.copyOfRange(arr, 0, mid);  
        int[] right = Arrays.copyOfRange(arr, mid, arr.length);  
  
        mergeSort(left);  
        mergeSort(right);  
  
        merge(arr, left, right);  
    }  
}  
  
public static void merge(int[] arr, int[] left, int[] right) {  
    int i = 0, j = 0, k = 0;  
    while (i < left.length && j < right.length) {  
        if (left[i] <= right[j]) {  
            arr[k] = left[i];  
            i++;  
        } else {  
            arr[k] = right[j];  
            j++;  
        }  
        k++;  
    }  
    while (i < left.length) {  
        arr[k] = left[i];  
        i++;  
        k++;  
    }  
    while (j < right.length) {  
        arr[k] = right[j];  
        j++;  
        k++;  
    }  
}

七、总结

本文介绍了Java中几种常见的排序算法，包括冒泡排序、选择排序、插入排序、快速排序和归并排序，并提供了相应的Java代码实现。每种排序算法都有其特点和适用场景，需要根据具体需求选择合适的算法。在实际应用中，还需要考虑算法的时间复杂度和空间复杂度，以及数据的特性（如是否稳定、是否大量重复等）来做出最优选择。

希望本文能够帮助读者更好地理解这些排序算法的原理和实现，为在实际项目中应用这些算法提供有价值的参考。