算法进阶之路：十大经典排序算法详解与实践

算法进阶之路：十大经典排序算法详解与实践

在计算机科学的世界里，排序算法是基础且至关重要的一环。无论是数据库查询、数据分析还是日常的编程任务，高效的排序算法都能显著提升程序的性能。本文将带你深入了解十大经典排序算法，包括它们的原理、优缺点以及代码实现，帮助你在算法面试中游刃有余。

1. 简单插入排序

原理

简单插入排序是一种直观的排序算法，它逐个遍历数组元素，将每个元素插入到前面已排序部分的适当位置。

步骤

1. 从第一个元素开始，该元素默认已排序。
2. 取下一个未排序的元素，与已排序的元素从后往前依次比较。
3. 如果当前元素小于已排序元素，则将已排序元素后移一位。
4. 重复步骤3，直到找到合适的位置插入当前元素。

代码实现（Java）

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

2. 希尔排序

原理

希尔排序是插入排序的一种改进版本，通过引入“间隔”的概念来允许交换更远距离的元素，从而可以快速减少大量的小范围无序情况。

步骤

1. 选择一个增量序列，该序列中的值逐渐减小到1。
2. 按增量序列中的值将数组分割成若干子序列，分别进行插入排序。
3. 增量值为1时，整个数组将进行一次插入排序，此时数组基本有序。

代码实现（Java）

public void shellSort(int[] arr) {
    int n = arr.length;
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}

3. 选择排序

原理

选择排序算法是一种原址比较排序算法。它的工作原理是每次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

步骤

1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
2. 从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3. 重复第二步，直到所有元素均排序完毕。

代码实现（Java）

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;
            }
        }
        // 交换 arr[i] 和 arr[minIndex]
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

4. 堆排序

原理

堆排序是一种基于比较的排序算法，它使用二叉堆的数据结构来实现。二叉堆是一种特殊的完全二叉树，所有的父节点都满足某种特定的顺序关系（大于或小于）与它们的子节点。

步骤

1. 将未排序序列构建成一个最大堆。
2. 交换堆顶元素与最后一个元素，将堆的大小减一，并且重新调整为最大堆。
3. 重复步骤2，直到堆的大小为1。

代码实现（Java）

public 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) {
        int swap = arr[i];
        arr[i] = arr[largest];
        arr[largest] = swap;

        // 递归地调整交换后的子树
        heapify(arr, n, largest);
    }
}

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--) {
        // 将当前根节点与最后一个节点交换
        int swap = arr[0];
        arr[0] = arr[i];
        arr[i] = swap;

        // 调整堆
        heapify(arr, i, 0);
    }
}

5. 冒泡排序

原理

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

步骤

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码实现（Java）

public 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]) {
                // 交换 arr[j] 和 arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

6. 快速排序

原理

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

步骤

1. 从数组中挑出一个元素作为基准（pivot）。
2. 重新排列数组，所有比基准值小的摆放在基准前面，所有比基准值大的摆放在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数组的中间位置。这个称为分区（partition）操作。
3. 递归地将小于基准值元素的子数组和大于基准值元素的子数组排序。

代码实现（Java）

public int partition(int[] arr, int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为基准
    int i = (low - 1); // 指向比基准小的元素的最后一个位置

    for (int j = low; j <= high - 1; j++) {
        // 如果当前元素小于或等于基准
        if (arr[j] <= pivot) {
            i++; // 增加小于基准的元素的计数
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return (i + 1);
}

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

7. 归并排序

原理

归并排序是一种分治算法，它将数组分成两半，分别对它们进行排序，然后将排序好的两半合并在一起。这个过程递归地进行，直到数组完全排序。

步骤

1. 将数组分成两半，直到每个子数组只有一个元素。
2. 将这些子数组两两合并，如果左子数组的当前元素小于右子数组的当前元素，则将左子数组的元素添加到结果数组中，并移动左子数组的指针；否则，将右子数组的元素添加到结果数组中，并移动右子数组的指针。
3. 重复步骤2，直到所有元素都合并到结果数组中。

代码实现（Java）

public void merge(int[] arr, int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;

    // 创建临时数组
    int[] L = new int[n1];
    int[] R = new int[n2];

    // 复制数据到临时数组
    System.arraycopy(arr, left, L, 0, n1);
    System.arraycopy(arr, mid + 1, R, 0, n2);

    // 合并临时数组回原数组
    int i = 0, j = 0;
    int k = left;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // 复制剩余的L[]数组元素
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    // 复制剩余的R[]数组元素
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

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

8. 计数排序

原理

计数排序是一种线性时间复杂度的排序算法，适用于整数且范围不是很大。它通过统计每个整数在数组中出现的次数，然后根据这些计数来将整数放到数组的适当位置。

步骤

1. 找出数组中的最大值和最小值。
2. 创建一个新的数组，长度为最大值和最小值之差加1。
3. 遍历原数组，统计每个元素出现的次数，存储在新数组中。
4. 遍历新数组，按照计数将元素放回原数组的适当位置。

代码实现（Java）

public void countingSort(int[] arr) {
    int max = Arrays.stream(arr).max().getAsInt();
    int min = Arrays.stream(arr).min().getAsInt();
    int range = max - min + 1;

    // 创建计数数组
    int[] count = new int[range];
    for (int num : arr) {
        count[num - min]++;
    }

    // 重构原数组
    int i = 0;
    for (int val : count) {
        while (val > 0) {
            arr[i++] = min + val - 1;
            val--;
        }
    }
}

9. 桶排序

原理

桶排序是一种分布式排序算法，它通过将元素分布到有限数量的桶里，每个桶再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序），最后将各个桶中的元素合并。

步骤

1. 确定桶的数量。
2. 将数组中的每个元素分配到一个桶中。
3. 对每个桶中的元素进行排序。
4. 按顺序将桶中的元素放回原数组。

代码实现（Java）

public void bucketSort(int[] arr) {
    int n = arr.length;
    int max = Arrays.stream(arr).max().getAsInt();
    int min = Arrays.stream(arr).min().getAsInt();
    int range = max - min + 1;
    int bucketSize = (int) Math.ceil((double) range / n);

    // 初始化桶
    int[][] buckets = new int[n][bucketSize];

    // 分配元素到桶
    for (int num : arr) {
        int index = (num - min) / bucketSize;
        buckets[index][num - min]++;
    }

    // 收集桶中的元素
    int i = 0;
    for (int[] bucket : buckets) {
        for (int j = 0; j < bucket.length; j++) {
            if (bucket[j] > 0) {
                arr[i] = j + min;
                i++;
                bucket[j]--;
            }
        }
    }
}

10. 基数排序

原理

基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较排序。基数排序适用于整数，特别适用于位数较多的整数。

步骤

1. 确定数组的最大值，找到最大值的位数。
2. 从最低位开始，对数组中的每个元素按照该位的数值进行桶排序。
3. 重复步骤2，直到所有位数都被排序。

代码实现（Java）

public void radixSort(int[] arr) {
    int max = Arrays.stream(arr).max().getAsInt();
    int maxDigit = (int) Math.log10(max) + 1; // 最大位数

    // 从最低位开始，逐位进行桶排序
    for (int i = 1; i <= maxDigit; i++) {
        countingSortByDigit(arr, i);
    }
}

public void countingSortByDigit(int[] arr, int digit) {
    int n = arr.length;
    int[] output = new int[n];
    int[] count = new int[10];

    // 计算频率
    for (int j = 0; j < n; j++) {
        int digitPlace = (arr[j] / (int) Math.pow(10, digit - 1)) % 10;
        count[digitPlace]++;
    }

    // 累计频率
    for (int j = 1; j < 10; j++) {
        count[j] += count[j - 1];
    }

    // 根据频率排序
    for (int j = n - 1; j >= 0; j--) {
        int digitPlace = (arr[j] / (int) Math.pow(10, digit - 1)) % 10;
        output[count[digitPlace] - 1] = arr[j];
        count[digitPlace]--;
    }

    // 复制回原数组
    System.arraycopy(output, 0, arr, 0, n);
}

以上就是十大经典排序算法的详细介绍和代码实现。掌握这些算法的原理和实现，将有助于你在算法面试中展现出色的表现。记住，理解算法的工作原理和适用场景比死记硬背代码更为重要。不断练习和应用这些算法，你将能够更加熟练地解决实际问题。