Java中的排序算法

排序算法是计算机科学中最基本、最常用的算法之一。在Java程序员的日常开发中，排序算法也经常被使用。本文将介绍Java中的排序算法以及它们的使用。

常见排序算法

Java中常见的排序算法包括：

• 冒泡排序
• 选择排序
• 插入排序
• 快速排序
• 归并排序
• 堆排序

下面对这些排序算法进行详细介绍。

冒泡排序

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，每次比较相邻的两个元素，如果他们的顺序错误就把它们交换过来。

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

选择排序

选择排序是一种简单直观的排序算法。它的工作原理是每次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余未排序的元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

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

插入排序

插入排序是一种简单直观的排序算法。插入排序的工作原理是，将未排序的数据插入到已排序的数据中。

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

快速排序

快速排序使用分治思想来把一个序列（list）分为两个子序列（sub-lists）。具体地，选择一个枢纽元素（pivot），将序列中所有小于枢纽元素的元素放在其左侧，所有大于枢纽元素的元素放在其右侧，然后对左右子序列进行递归排序。

public static void quickSort(int[] arr, int left, int right) {
    if (left < right) {
        int partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex - 1);
        quickSort(arr, partitionIndex + 1, right);
    }
}

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

归并排序

归并排序是一种递归算法，它将输入的数组分成两个部分，分别进行排序，最后再将两个有序的子数组合并成一个大的有序的数组。

public static void mergeSort(int[] arr, int left, int right) {
    if (left < right) {
        int mid = (left + right) >> 1;
        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, j = mid + 1, k = 0;
    while (i <= mid && j <= right) {
        temp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];
    }
    while (i <= mid) {
        temp[k++] = arr[i++];
    }
    while (j <= right) {
        temp[k++] = arr[j++];
    }
    System.arraycopy(temp, 0, arr, left, temp.length);
}

堆排序

堆排序是一种树形选择排序，是对直接选择排序的有效改进。堆的定义如下：具有n个元素的序列 (h1,h2,...,hn)，当且仅当 (hi,hi/2)或 (hi,hi/2+1) 是一对父子关系时，则称之为堆。在堆中元素的比较是沿着路径比较的，因此堆排序的时间复杂度较低。

public static void heapSort(int[] arr) {
    for (int i = arr.length / 2 - 1; i >= 0; i--) {
        adjustHeap(arr, i, arr.length);
    }
    for (int i = arr.length - 1; i >= 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        adjustHeap(arr, 0, i);
    }
}

private static void adjustHeap(int[] arr, int i, int length) {
    int temp = arr[i];
    for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
        if (k + 1 < length && arr[k] < arr[k + 1]) {
            k++;
        }
        if (arr[k] > temp) {
            arr[i] = arr[k];
            i = k;
        } else {
            break;
        }
    }
    arr[i] = temp;
}

总结

本文介绍了Java中的六种常见排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序。程序员在日常的开发中可以根据实际需要选择不同的排序算法来实现所需的排序功能。