【轻松掌握数据结构与算法】排序算法-优快云博客

排序算法是计算机科学中最基本且重要的算法之一。它们用于将数据元素按照特定顺序排列，通常是升序或降序。本章将详细介绍各种排序算法，包括它们的工作原理、时间复杂度和适用场景。

什么是排序？

排序是将一系列数据元素按照特定顺序排列的过程。排序算法可以分为内部排序和外部排序。内部排序在内存中完成，而外部排序需要使用外部存储设备。

为什么需要排序？

排序在许多应用中都非常有用，例如：

数据库查询优化
搜索算法的加速
数据分析和处理

排序算法的分类

排序算法可以根据不同的标准进行分类，例如：

基于比较的排序算法（如冒泡排序、选择排序、插入排序）
非比较排序算法（如计数排序、基数排序、桶排序）

其他分类

排序算法还可以根据其他特性进行分类，例如：

稳定性（是否保持相等元素的原始顺序）
适应性（是否对已排序数据有优化）

冒泡排序

冒泡排序是一种简单的排序算法，通过重复遍历要排序的数列，比较每对相邻元素，如果它们的顺序错误就把它们交换过来。

代码示例

void bubbleSort(int arr[], int n) {
    int i, j, temp;
    for (i = 0; i < n-1; i++) {
        for (j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

输入输出示例

假设我们有以下数组：

5 3 8 4 2

排序后：

2 3 4 5 8

选择排序

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

代码示例

void selectionSort(int arr[], int n) {
    int i, j, min_idx, temp;
    for (i = 0; i < n-1; i++) {
        min_idx = i;
        for (j = i+1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }
        temp = arr[min_idx];
        arr[min_idx] = arr[i];
        arr[i] = temp;
    }
}

输入输出示例

假设我们有以下数组：

64 34 25 12 22 11 90

排序后：

11 12 22 25 34 64 90

插入排序

插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

代码示例

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

输入输出示例

假设我们有以下数组：

12 11 13 5 6

排序后：

5 6 11 12 13

希尔排序

希尔排序是插入排序的一种改进版本，它通过比较距离一定间隔的元素来工作，然后逐步减小间隔。

代码示例

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

输入输出示例

假设我们有以下数组：

9 8 3 7 5 6 4 1

排序后：

1 3 4 5 6 7 8 9

归并排序

归并排序是一种有效的排序算法，采用分治法的思想。它将数组分成两半，分别排序，然后合并。

代码示例

void merge(int arr[], int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;

    int L[n1], R[n2];

    for (i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];

    i = 0;
    j = 0;
    k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

输入输出示例

假设我们有以下数组：

38 27 43 3 9 82 10

排序后：

3 9 10 27 38 43 82

堆排序

堆排序是一种基于堆数据结构的排序算法。它首先将数组构建成一个最大堆，然后逐步将堆顶元素与最后一个元素交换，然后重新调整堆。

代码示例

void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2*i + 1;
    int r = 2*i + 2;

    if (l < n && arr[l] > arr[largest])
        largest = l;

    if (r < n && arr[r] > arr[largest])
        largest = r;

    if (largest != i) {
        int swap = arr[i];
        arr[i] = arr[largest];
        arr[largest] = swap;

        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    for (int i = n-1; i >= 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;

        heapify(arr, i, 0);
    }
}

输入输出示例

假设我们有以下数组：

12 11 13 5 6 7

排序后：

5 6 7 11 12 13

快速排序

快速排序是一种高效的排序算法，采用分治法的思想。它选择一个元素作为基准，然后将数组分为两部分，一部分包含比基准小的元素，另一部分包含比基准大的元素。

代码示例

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++;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    int temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return (i + 1);
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);

        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

输入输出示例

假设我们有以下数组：

10 7 8 9 1 5

排序后：

1 5 7 8 9 10

树排序

树排序是一种基于二叉搜索树的排序算法。它首先将数组元素插入到二叉搜索树中，然后进行中序遍历以获取排序后的数组。

代码示例

typedef struct TreeNode {
    int data;
    struct TreeNode *left, *right;
} TreeNode;

TreeNode* createTreeNode(int data) {
    TreeNode *newNode = (TreeNode*)malloc(sizeof(TreeNode));
    newNode->data = data;
    newNode->left = newNode->right = NULL;
    return newNode;
}

TreeNode* insertTreeNode(TreeNode *root, int data) {
    if (root == NULL) {
        return createTreeNode(data);
    }
    if (data < root->data) {
        root->left = insertTreeNode(root->left, data);
    } else if (data > root->data) {
        root->right = insertTreeNode(root->right, data);
    }
    return root;
}

void inorderTraversal(TreeNode *root, int arr[], int *index) {
    if (root != NULL) {
        inorderTraversal(root->left, arr, index);
        arr[(*index)++] = root->data;
        inorderTraversal(root->right, arr, index);
    }
}

void treeSort(int arr[], int n) {
    TreeNode *root = NULL;
    for (int i = 0; i < n; i++) {
        root = insertTreeNode(root, arr[i]);
    }
    int index = 0;
    inorderTraversal(root, arr, &index);
}

输入输出示例

假设我们有以下数组：

7 4 1 8 5 2 9

排序后：

1 2 4 5 7 8 9

比较排序算法

不同的排序算法有不同的性能特点。以下是一些常见排序算法的比较：

算法	最佳时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
冒泡排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
插入排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
希尔排序	O(n log n)	O(n(log n)^2)	O(n(log n)^2)	O(1)	不稳定
归并排序	O(n log n)	O(n log n)	O(n log n)	O(n)	稳定
堆排序	O(n log n)	O(n log n)	O(n log n)	O(1)	不稳定
快速排序	O(n log n)	O(n log n)	O(n^2)	O(log n)	不稳定
树排序	O(n log n)	O(n log n)	O(n^2)	O(n)	稳定

线性排序算法

线性排序算法的时间复杂度为 O(n)，适用于特定类型的数据。常见的线性排序算法包括计数排序、基数排序和桶排序。

计数排序

计数排序适用于整数排序，通过计数每个整数出现的次数来排序。

代码示例

void countingSort(int arr[], int n, int exp) {
    int output[n];
    int i, count[10] = {0};

    for (i = 0; i < n; i++)
        count[ (arr[i]/exp)%10 ]++;

    for (i = 1; i < 10; i++)
        count[i] += count[i - 1];

    for (i = n - 1; i >= 0; i--) {
        output[count[ (arr[i]/exp)%10 ] - 1] = arr[i];
        count[ (arr[i]/exp)%10 ]--;
    }

    for (i = 0; i < n; i++)
        arr[i] = output[i];
}

void radixsort(int arr[], int n) {
    int max1 = arr[0];
    for (int i = 1; i < n; i++)
        if (arr[i] > max1)
            max1 = arr[i];

    for (int exp = 1; max1/exp > 0; exp *= 10)
        countingSort(arr, n, exp);
}

输入输出示例

假设我们有以下数组：

170 45 75 90 802 24 2 66

排序后：

2 24 45 66 75 90 170 802

基数排序

基数排序适用于整数排序，通过按位排序来排序。

代码示例

void countingSort(int arr[], int n, int exp) {
    int output[n];
    int i, count[10] = {0};

    for (i = 0; i < n; i++)
        count[ (arr[i]/exp)%10 ]++;

    for (i = 1; i < 10; i++)
        count[i] += count[i - 1];

    for (i = n - 1; i >= 0; i--) {
        output[count[ (arr[i]/exp)%10 ] - 1] = arr[i];
        count[ (arr[i]/exp)%10 ]--;
    }

    for (i = 0; i < n; i++)
        arr[i] = output[i];
}

void radixsort(int arr[], int n) {
    int max1 = arr[0];
    for (int i = 1; i < n; i++)
        if (arr[i] > max1)
            max1 = arr[i];

    for (int exp = 1; max1/exp > 0; exp *= 10)
        countingSort(arr, n, exp);
}

输入输出示例

假设我们有以下数组：

170 45 75 90 802 24 2 66

排序后：

2 24 45 66 75 90 170 802

桶排序

桶排序适用于浮点数排序，通过将数据分配到不同的桶中来排序。

代码示例

void bucketSort(float arr[], int n) {
    float max_val = arr[0];
    for (int i = 1; i < n; i++)
        if (arr[i] > max_val)
            max_val = arr[i];

    int bucket[n];
    for (int i = 0; i < n; i++)
        bucket[i] = 0;

    for (int i = 0; i < n; i++)
        bucket[(int)(n*arr[i]/(max_val+1))]++;

    int index = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < bucket[i]; j++)
            arr[index++] = i*(max_val+1)/n;
}

输入输出示例

假设我们有以下数组：

0.897 0.565 0.656 0.1234 0.665 0.3434

排序后：

0.1234 0.3434 0.565 0.656 0.665 0.897

外部排序

外部排序用于处理无法全部加载到内存中的大规模数据。常见的外部排序算法包括多路平衡归并排序和置换-选择排序。

多路平衡归并排序

多路平衡归并排序将大规模数据分成多个小文件，对每个小文件进行内部排序，然后进行多路归并。

置换-选择排序

置换-选择排序通过选择最小的元素并将其移动到前面来排序。

排序算法的问题与解决方案

问题 1：如何选择合适的排序算法？

解决方案：选择排序算法时需要考虑以下因素：

数据规模
数据的初始状态（是否部分排序）
内存使用情况
稳定性要求

问题 2：如何优化排序算法？

解决方案：可以通过以下方式优化排序算法：

使用更高效的数据结构
减少不必要的比较和交换操作
利用多线程或并行计算

问题 3：如何处理大规模数据排序？

解决方案：对于大规模数据，可以使用外部排序算法，如多路平衡归并排序。具体步骤如下：

将数据分成多个小文件。
对每个小文件进行内部排序。
进行多路归并。

代码示例

void externalSort(char* filename, int memorySize) {
    FILE *file = fopen(filename, "r");
    if (file == NULL) {
        printf("无法打开文件\n");
        return;
    }

    // 读取数据并分成多个小文件
    int fileSize = getFileSize(file);
    int numFiles = fileSize / memorySize + 1;
    FILE **tempFiles = (FILE**)malloc(numFiles * sizeof(FILE*));
    for (int i = 0; i < numFiles; i++) {
        char tempFilename[100];
        sprintf(tempFilename, "temp%d.txt", i);
        tempFiles[i] = fopen(tempFilename, "w");
        if (tempFiles[i] == NULL) {
            printf("无法创建临时文件\n");
            return;
        }
    }

    int buffer[memorySize];
    int bufferIndex = 0;
    int value;
    while (fscanf(file, "%d", &value) != EOF) {
        buffer[bufferIndex++] = value;
        if (bufferIndex == memorySize) {
            qsort(buffer, memorySize, sizeof(int), compare);
            for (int i = 0; i < memorySize; i++) {
                fprintf(tempFiles[bufferIndex / memorySize], "%d\n", buffer[i]);
            }
            bufferIndex = 0;
        }
    }
    if (bufferIndex > 0) {
        qsort(buffer, bufferIndex, sizeof(int), compare);
        for (int i = 0; i < bufferIndex; i++) {
            fprintf(tempFiles[numFiles - 1], "%d\n", buffer[i]);
        }
    }

    // 关闭文件
    fclose(file);
    for (int i = 0; i < numFiles; i++) {
        fclose(tempFiles[i]);
    }

    // 多路归并
    FILE *outputFile = fopen("sorted.txt", "w");
    if (outputFile == NULL) {
        printf("无法创建输出文件\n");
        return;
    }

    int *fileBuffers = (int*)malloc(numFiles * memorySize * sizeof(int));
    int *fileBufferIndices = (int*)malloc(numFiles * sizeof(int));
    for (int i = 0; i < numFiles; i++) {
        tempFiles[i] = fopen(tempFilename, "r");
        for (int j = 0; j < memorySize; j++) {
            if (fscanf(tempFiles[i], "%d", &fileBuffers[i * memorySize + j]) == EOF) {
                break;
            }
            fileBufferIndices[i]++;
        }
    }

    while (1) {
        int minIndex = -1;
        int minValue = INT_MAX;
        for (int i = 0; i < numFiles; i++) {
            if (fileBufferIndices[i] > 0 && fileBuffers[i * memorySize + fileBufferIndices[i] - 1] < minValue) {
                minIndex = i;
                minValue = fileBuffers[i * memorySize + fileBufferIndices[i] - 1];
            }
        }
        if (minIndex == -1) {
            break;
        }
        fprintf(outputFile, "%d\n", minValue);
        fileBufferIndices[minIndex]--;
        if (fileBufferIndices[minIndex] == 0) {
            for (int j = 0; j < memorySize; j++) {
                if (fscanf(tempFiles[minIndex], "%d", &fileBuffers[minIndex * memorySize + j]) == EOF) {
                    break;
                }
                fileBufferIndices[minIndex]++;
            }
        }
    }

    // 关闭文件
    fclose(outputFile);
    for (int i = 0; i < numFiles; i++) {
        fclose(tempFiles[i]);
        remove(tempFilename);
    }

    free(tempFiles);
    free(fileBuffers);
    free(fileBufferIndices);
}