常用排序算法

排序算法分类

• 交换排序
  冒泡排序（稳定）、快速排序（不稳定）
• 插入排序
  直接插入排序（稳定）、希尔排序（不稳定）
• 选择排序
  简单选择排序（不稳定）、堆排序（不稳定）
• 归并排序（稳定）
• 基数排序（稳定）

1、冒泡排序 (Bubble Sort)

冒泡排序是一种典型的排序方法，其基本思想是通过两两比较相邻记录的关键字，使关键字较大的记录如气泡一般逐渐往上“漂浮”。

 public static void bubbleSort(int[] arr) {
        int i, j;
        int temp;
        for (i = 0; i < arr.length - 1; i++) {
            for (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;
                }
            }
        }
    }

2、简单选择排序

原理：每次从未排序部分中找到最小（或最大）元素，将其放到已排序序列的末尾。

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;
                }
            }
            // 交换找到的最小值和当前位置的值
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }

3、直接插入排序 (Insertion Sort)

原理：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

• 直接插入排序写法1 （while循环）

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;
        // 将比 key 大的元素向后移动
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key; // 插入到正确位置
    }
}

• 直接插入排序写法2 （for循环）

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

4、快速排序 (Quick Sort) - 重点掌握

原理：采用分治策略。
挑选基准：从数列中挑出一个元素作为“基准”（pivot）。
分区：重新排列数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面。
递归：递归地将小于基准值元素的子数列和大于基准值元素的子数列排序。

• java代码实现1

public static void quickSort(int[] arr, int i, int j) {
        if (i < j) {
            int pivot = partition(arr, i, j);
            quickSort(arr, i, pivot);
            quickSort(arr, pivot + 1, j);
        }
    }
public static int partition(int[] arr, int i, int j) {
        //第一个数arr[i]作为基准值，暂存在temp，此时arr[i]为空位
        int temp = arr[i];
        while (i < j) {
            //从位置[j]开始，向左依次比较，大于基准值，位置[j]左移
            while (i < j && arr[j] >= temp) {
                j--;
            }
            //找到一个小于基准值的数arr[j]，将arr[j]存到左边空位arr[i]，i右移，此时arr[j]为空位
            if (i < j) {
                arr[i++] = arr[j];
            }
            //从位置[i]开始，向右依次比较，小于基准值，位置[i]左右移
            while (i < j && arr[i] <= temp) {
                i++;
            }
            //找到一个大于基准值的数arr[i]，将arr[i]存到右边空位arr[j]，j左移，此次arr[i]为空位
            if (i < j) {
                arr[j--] = arr[i];
            }
        }
        //当i等于j时，循环结束，此时[i]为划分位置（空位），将基准值存入
        arr[i] = temp;
        return i;
    }

• java代码实现2

public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        // pi 是分区索引，arr[pi] 现在在正确的位置
        int pi = partition(arr, low, high);
        // 递归排序分区的前后部分
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

private static int partition(int[] arr, int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为基准
    int i = (low - 1); // 较小元素的索引
    for (int j = low; j < high; j++) {
        // 如果当前元素小于或等于基准
        if (arr[j] <= pivot) {
            i++;
            // 交换 arr[i] 和 arr[j]
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    // 将基准元素交换到正确位置 (i+1)
    int temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return i + 1;
}
// 调用方式：quickSort(arr, 0, arr.length - 1);

5、归并排序 (Merge Sort) - 重点掌握

原理：采用分治策略。
分割：递归地将当前序列平均分割成两半。
合并：在保持元素顺序的同时将上一步得到的子序列合并到一起。

public static void mergeSort(int[] arr, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 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++];
    // 将临时数组拷贝回原数组
    System.arraycopy(temp, 0, arr, left, temp.length);
}
// 调用方式：mergeSort(arr, 0, arr.length - 1);