java常用几种排序算法

快速排序、冒泡排序、选择排序和归并排序是常用的排序算法，它们的区别如下：

1. 快速排序：是一种分治算法，通过选取一个基准元素，将数组分为两部分，一部分小于基准元素，另一部分大于基准元素，然后对这两部分分别进行快速排序。时间复杂度为O(nlogn)，空间复杂度为O(logn)。

2. 冒泡排序：是一种简单的排序算法，通过相邻元素之间的比较和交换，使得每一趟循环都能将最大（或最小）的元素放到正确的位置。时间复杂度为O(n^2)，空间复杂度为O(1)。

3. 选择排序：是一种简单直观的排序算法，每次从未排序的元素中找出最小（或最大）的元素，将其放到已排序序列的末尾。时间复杂度为O(n^2)，空间复杂度为O(1)。

4. 归并排序：是一种分治算法，将数组分成两半，分别进行排序，然后将两个有序数组合并成一个有序数组。时间复杂度为O(nlogn)，空间复杂度为O(n)。

优缺点：

• 快速排序：优点是平均时间复杂度高，适用于大规模数据；缺点是递归深度可能导致栈溢出。
• 冒泡排序：优点是实现简单，适用于小规模数据；缺点是时间复杂度高，不适用于大规模数据。
• 选择排序：优点是实现简单，适用于小规模数据；缺点是时间复杂度高，不适用于大规模数据。
• 归并排序：优点是时间复杂度高，适用于大规模数据；缺点是空间复杂度高，需要额外的存储空间。

Java代码案例分析：

// 快速排序
public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, low, high);
            quickSort(arr, low, pivot - 1);
            quickSort(arr, pivot + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[low];
        while (low < high) {
            while (low < high && arr[high] >= pivot) {
                high--;
            }
            arr[low] = arr[high];
            while (low < high && arr[low] <= pivot) {
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = pivot;
        return low;
    }
}

// 冒泡排序
public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        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]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

// 选择排序
public class SelectionSort {
    public static void selectionSort(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;
                }
            }
            if (minIndex != i) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }
}

// 归并排序
public class MergeSort {
    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, j = mid + 1, k = 0;
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = arr[i++];
        }
        while (j <= right) {
            temp[k++] = arr[j++];
        }
        for (int p = 0; p < temp.length; p++) {
            arr[left + p] = temp[p];
        }
    }
}