排序算法

一、冒泡排序（Bubble Sort）

核心思想

通过相邻元素两两比较交换，将最大元素逐步“冒泡”到数组末尾。

代码实现

public void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        boolean swapped = false;
        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;
                swapped = true;
            }
        }
        if (!swapped) break; // 优化：无交换则已有序
    }
}

特点

• 时间复杂度：平均 O(n²)，最好 O(n)（已有序）
• 空间复杂度：O(1)
• 稳定排序：是

---

二、选择排序（Selection Sort）

核心思想

每次遍历选择未排序部分的最小元素，放到已排序部分的末尾。

代码实现

public 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[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

特点

• 时间复杂度：O(n²)
• 空间复杂度：O(1)
• 稳定排序：否

---

三、插入排序（Insertion Sort）

核心思想

将未排序元素逐个插入到已排序部分的正确位置。

代码实现

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

特点

• 时间复杂度：平均 O(n²)，最好 O(n)（已有序）
• 空间复杂度：O(1)
• 稳定排序：是

---

四、归并排序（Merge Sort）

核心思想

分治法：将数组分成两半分别排序，再合并两个有序子数组。

代码实现

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

特点

• 时间复杂度：O(n log n)
• 空间复杂度：O(n)
• 稳定排序：是

---

五、快速排序（Quick Sort）

核心思想

分治法：选择一个基准元素，将数组分为左右两部分，递归排序。

代码实现

public void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pivotIndex = partition(arr, low, high);
        quickSort(arr, low, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, high);
    }
}

private 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++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, high);
    return i + 1;
}

private void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

特点

• 时间复杂度：平均 O(n log n)，最坏 O(n²)（已有序）
• 空间复杂度：O(log n)（递归栈）
• 稳定排序：否

---

六、堆排序（Heap Sort）

核心思想

将数组构造成最大堆，逐个取出堆顶元素（最大值）进行排序。

代码实现

public void heapSort(int[] arr) {
    int n = arr.length;
    
    // 构建最大堆
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    
    // 逐个提取堆顶元素
    for (int i = n - 1; i > 0; i--) {
        swap(arr, 0, i);
        heapify(arr, i, 0);
    }
}

private void heapify(int[] arr, int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < n && arr[left] > arr[largest]) largest = left;
    if (right < n && arr[right] > arr[largest]) largest = right;
    
    if (largest != i) {
        swap(arr, i, largest);
        heapify(arr, n, largest);
    }
}

private void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

特点

• 时间复杂度：O(n log n)
• 空间复杂度：O(1)
• 稳定排序：否

---

总结对比表

排序算法	平均时间复杂度	空间复杂度	稳定性	适用场景
冒泡排序	O(n²)	O(1)	稳定	小规模数据或教学
选择排序	O(n²)	O(1)	不稳定	小规模数据
插入排序	O(n²)	O(1)	稳定	小规模或基本有序数据
归并排序	O(n log n)	O(n)	稳定	大规模数据、稳定排序需求
快速排序	O(n log n)	O(log n)	不稳定	大规模数据、内存敏感
堆排序	O(n log n)	O(1)	不稳定	大规模数据、无需额外空间