数组的插入、选择、快速、归并、计数排序

最新推荐文章于 2024-04-25 00:00:00 发布

RecruitmentHacks

最新推荐文章于 2024-04-25 00:00:00 发布

阅读量254

点赞数

分类专栏： C/C++ 文章标签： c语言 c++ 开发语言数据结构算法

本文链接：https://blog.csdn.net/RecruitmentHacks/article/details/130453351

版权

C/C++ 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

本文介绍了四种常见的排序算法：插入排序、选择排序、快速排序和归并排序，以及非比较算法——计数排序。这些算法的时间复杂度从O(n^2)到O(nlogn)不等，适用于不同的场景。插入排序和选择排序的时间复杂度为O(n^2)，而快速排序和归并排序为O(nlogn)，计数排序则为O(n+k)。

摘要由CSDN通过智能技术生成

插入排序（Insertion Sort）：将数组分为已排序和未排序两个部分，每次将未排序部分的第一个元素插入到已排序部分的正确位置上。它的基本思想是将一个待排序的序列分成两部分，一部分是已经排序好的序列，另一部分是未排序的序列。然后依次将未排序的元素插入到已排序的序列中，直到所有元素都被插入完毕。插入排序的时间复杂度为O(n^2)。
```
void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; 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;
    }
}
```
这里的 arr 是待排序的数组，n 是数组长度。首先将数组中的第一个元素作为已排序的序列，然后从第二个元素开始遍历整个数组。在每次遍历中，将当前元素存储到 key 变量中，将其前面的元素向右移动，直到找到一个位置，使得当前元素可以被插入到已排序的序列中。最后将 key 插入到已排序的序列中。
选择排序（Selection Sort）：从数组中选出最小的元素，与数组的第一个元素交换位置，然后从剩余的元素中选出最小的元素，与数组的第二个元素交换位置，以此类推。它的基本思想是每次选择数组中最小的元素，然后将其放置在已排序的序列的末尾。选择排序的时间复杂度为O(n^2)。
```
void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[min_idx];
        arr[min_idx] = temp;
    }
}
```
这里的 arr 是待排序的数组，n 是数组长度。首先遍历整个数组，每次找到未排序的部分中最小的元素的下标，并将其与已排序的部分的末尾元素交换。最终，数组将被排序。
快速排序（Quick Sort）：通过分治的思想，将一个数组分成两个子数组，其中一个子数组的所有元素都比另一个子数组的所有元素小，然后对这两个子数组分别进行快速排序，递归执行该过程，直到子数组长度为 1。它的基本思想是通过分治法将一个待排序的序列分成两部分，一部分是小于基准元素的序列，另一部分是大于等于基准元素的序列。然后分别对这两部分进行递归排序，最终得到整个序列的有序排列。快速排序的时间复杂度为O(nlogn)。
```
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);
    }
}

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
```
这里的 arr 是待排序的数组，low 和 high 分别是序列的起始位置和结束位置。首先在序列中选择一个基准元素，然后将整个序列分成两部分，使得左边的序列元素都小于等于基准元素，右边的序列元素都大于基准元素。然后分别对左边和右边的序列进行递归排序。在实现中，我们使用 partition 函数将数组分成两部分，并返回基准元素的下标。在 partition 函数中，我们使用 i 来记录左部分序列的末尾元素的下标，然后遍历序列中除了基准元素外的所有元素，将小于基准元素的元素交换到左部分序列的末尾。最后，将基准元素交换到左右两部分序列的中间位置。
归并排序（Merge Sort）：将一个数组分成两个子数组，然后对这两个子数组分别进行归并排序，最后将两个有序的子数组合并成一个有序的数组。是一种基于分治思想的排序算法，它将待排序的序列递归地分成两个子序列，对每个子序列进行排序，然后再将它们合并成一个有序序列。归并排序的时间复杂度为O(nlogn)。
```
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);
    }
}

void merge(int arr[], int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;
    int L[n1], R[n2];
    for (int i = 0; i < n1; i++) {
        L[i] = arr[left + i];
    }
    for (int j = 0; j < n2; j++) {
        R[j] = arr[mid + 1 + j];
    }
    int i = 0, j = 0, k = left;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k++] = L[i++];
        } else {
            arr[k++] = R[j++];
        }
    }
    while (i < n1) {
        arr[k++] = L[i++];
    }
    while (j < n2) {
        arr[k++] = R[j++];
    }
}
```
这里的 arr 是待排序的数组，left 和 right 分别是序列的起始位置和结束位置。首先在 mergeSort 函数中将数组分成两个子序列，然后分别对左边和右边的子序列进行递归排序，最后将它们合并成一个有序序列。在实现中，我们使用 merge 函数将两个有序子序列合并成一个有序序列。在 merge 函数中，我们首先计算出两个子序列的长度，并创建两个临时数组 L 和 R 来存储这两个子序列。然后使用两个指针 i 和 j 分别遍历这两个子序列，将它们合并成一个有序序列。最后将有序序列中剩余的元素添加到数组中。
计数排序（Counting Sort）：对于一个给定的数组，计算出每个元素出现的次数，然后按照元素大小从小到大的顺序，依次将元素输出到结果数组中。是一种非比较排序算法，用于排序由整数组成的数组。它的基本思想是，针对待排序的数据中每个元素的值，确定出小于它的元素的个数，从而确定它在有序序列中的位置。计数排序的时间复杂度为 O(n+k)，其中 k 表示数据中的最大值和最小值的差值加 1。
```
#include <stdio.h>
#include <stdlib.h>

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

    int *count = (int*)calloc(max + 1, sizeof(int));

    for (int i = 0; i < n; i++) {
        count[arr[i]]++;
    }

    int j = 0;
    for (int i = 0; i <= max; i++) {
        while (count[i]-- > 0) {
            arr[j++] = i;
        }
    }

    free(count);
}

int main() {
    int arr[] = {5, 2, 9, 5, 2, 3, 10, 1, 7, 8};
    int n = sizeof(arr) / sizeof(arr[0]);

    countingSort(arr, n);

    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    return 0;
}
```
在这个例子中，我们首先找到了待排序数组中的最大值，然后创建了一个大小为最大值加 1 的计数数组 count。接着，我们遍历了待排序数组，对每个元素在 count 数组中进行计数。最后，我们将计数数组中的元素按顺序输出到待排序数组中，从而得到排序后的数组。