1. PingCode智库首页
  2. 百科

c语言如何实现分别排序

Edit2 • • 百科

c语言如何实现分别排序

C语言实现分别排序的方法有多种，常见的包括：选择排序、插入排序、冒泡排序、快速排序、归并排序。 其中，快速排序是最常用且高效的一种排序算法，在大多数情况下，表现出色。下面将详细介绍如何使用快速排序进行分别排序，并探讨其他排序算法的实现及适用场景。

一、快速排序

快速排序（Quicksort）是一种基于分治法的高效排序算法，它的基本思想是通过一个“基准”元素将数组分成两个子数组，然后递归地对这两个子数组进行排序。快速排序的平均时间复杂度为O(n log n)，在最坏情况下为O(n^2)。

1.1 快速排序的基本步骤

  1. 选择一个基准元素（通常选择第一个元素或最后一个元素）。
  2. 重新排列数组，使所有小于基准值的元素排在基准值之前，所有大于基准值的元素排在基准值之后。
  3. 递归地对基准值左边的子数组和右边的子数组进行排序。

代码实现

#include <stdio.h>


void swap(int* a, int* b) {


    int temp = *a;


    *a = *b;


    *b = temp;


}


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


    }


}


void printArray(int arr[], int size) {


    for (int i = 0; i < size; i++)


        printf("%d ", arr[i]);


    printf("n");


}


int main() {


    int arr[] = {10, 7, 8, 9, 1, 5};


    int n = sizeof(arr) / sizeof(arr[0]);


    quickSort(arr, 0, n - 1);


    printf("Sorted array: n");


    printArray(arr, n);


    return 0;


}

1.2 快速排序的优缺点

优点：

  • 平均时间复杂度为O(n log n)，在多数情况下表现优异。
  • 原地排序，不需要额外的内存空间。

缺点：

  • 在最坏情况下，时间复杂度为O(n^2)（当每次选择的基准都是最大或最小值时）。
  • 对于较小的数据集，可能不如插入排序高效。

二、选择排序

选择排序（Selection Sort）是一种简单直观的排序算法。它的基本思想是每次从未排序部分选出最小（或最大）的元素，并将其放到已排序部分的末尾。

2.1 选择排序的基本步骤

  1. 从未排序部分中找到最小（或最大）元素。
  2. 将该元素与未排序部分的第一个元素交换。
  3. 重复以上步骤，直到所有元素均已排序。

代码实现

#include <stdio.h>


void selectionSort(int arr[], int n) {


    int i, j, min_idx;


    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;


        swap(&arr[min_idx], &arr[i]);


    }


}


void printArray(int arr[], int size) {


    for (int i = 0; i < size; i++)


        printf("%d ", arr[i]);


    printf("n");


}


int main() {


    int arr[] = {64, 25, 12, 22, 11};


    int n = sizeof(arr) / sizeof(arr[0]);


    selectionSort(arr, n);


    printf("Sorted array: n");


    printArray(arr, n);


    return 0;


}

2.2 选择排序的优缺点

优点：

  • 简单易懂，易于实现。
  • 对于小规模数据集表现良好。

缺点：

  • 时间复杂度为O(n^2)，性能较差。
  • 不稳定排序，元素间相对顺序可能改变。

三、插入排序

插入排序（Insertion Sort）是一种基于扑克牌整理方式的排序算法。它的基本思想是将每个元素插入到已排序部分的适当位置。

3.1 插入排序的基本步骤

  1. 从第二个元素开始，依次将每个元素插入到前面已排序部分的适当位置。
  2. 重复以上步骤，直到所有元素均已排序。

代码实现

#include <stdio.h>


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;


    }


}


void printArray(int arr[], int size) {


    for (int i = 0; i < size; i++)


        printf("%d ", arr[i]);


    printf("n");


}


int main() {


    int arr[] = {12, 11, 13, 5, 6};


    int n = sizeof(arr) / sizeof(arr[0]);


    insertionSort(arr, n);


    printf("Sorted array: n");


    printArray(arr, n);


    return 0;


}

3.2 插入排序的优缺点

优点：

  • 简单易懂，易于实现。
  • 对于小规模数据集和基本有序的数据集表现良好，时间复杂度接近O(n)。

缺点：

  • 时间复杂度为O(n^2)，性能较差。
  • 适用于小规模数据集和基本有序的数据集。

四、冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法。它的基本思想是通过重复遍历数组，将相邻元素进行比较并交换，从而使得每次遍历后最大（或最小）的元素“冒泡”到数组的末尾。

4.1 冒泡排序的基本步骤

  1. 从数组的第一个元素开始，依次比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们。
  2. 重复以上步骤，直到数组末尾。
  3. 继续遍历数组，直到没有元素需要交换。

代码实现

#include <stdio.h>


void bubbleSort(int arr[], int n) {


    int i, j;


    for (i = 0; i < n - 1; i++)


        for (j = 0; j < n - i - 1; j++)


            if (arr[j] > arr[j + 1])


                swap(&arr[j], &arr[j + 1]);


}


void printArray(int arr[], int size) {


    for (int i = 0; i < size; i++)


        printf("%d ", arr[i]);


    printf("n");


}


int main() {


    int arr[] = {64, 34, 25, 12, 22, 11, 90};


    int n = sizeof(arr) / sizeof(arr[0]);


    bubbleSort(arr, n);


    printf("Sorted array: n");


    printArray(arr, n);


    return 0;


}

4.2 冒泡排序的优缺点

优点：

  • 简单易懂，易于实现。
  • 适用于小规模数据集。

缺点：

  • 时间复杂度为O(n^2)，性能较差。
  • 对于大规模数据集效率低下。

五、归并排序

归并排序（Merge Sort）是一种基于分治法的稳定排序算法。它的基本思想是将数组分成两个子数组，递归地对这两个子数组进行排序，然后将排序好的子数组合并成一个有序数组。

5.1 归并排序的基本步骤

  1. 将数组分成两个子数组。
  2. 递归地对这两个子数组进行排序。
  3. 将排序好的子数组合并成一个有序数组。

代码实现

#include <stdio.h>


#include <stdlib.h>


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


    }


}


void printArray(int arr[], int size) {


    for (int i = 0; i < size; i++)


        printf("%d ", arr[i]);


    printf("n");


}


int main() {


    int arr[] = {12, 11, 13, 5, 6, 7};


    int arr_size = sizeof(arr) / sizeof(arr[0]);


    printf("Given array is n");


    printArray(arr, arr_size);


    mergeSort(arr, 0, arr_size - 1);


    printf("nSorted array is n");


    printArray(arr, arr_size);


    return 0;


}

5.2 归并排序的优缺点

优点：

  • 时间复杂度为O(n log n)，性能稳定。
  • 稳定排序，元素间相对顺序不会改变。

缺点：

  • 需要额外的内存空间，空间复杂度为O(n)。
  • 实现较为复杂。

六、总结

在C语言中实现分别排序的方法有多种，常见的包括选择排序、插入排序、冒泡排序、快速排序和归并排序。每种排序算法都有其优缺点和适用场景。快速排序是最常用且高效的一种排序算法，适用于大多数情况。选择排序和插入排序简单易懂，适用于小规模数据集。冒泡排序虽简单，但效率较低。归并排序性能稳定，但需要额外内存空间。

在实际应用中，选择合适的排序算法可以根据数据集的规模和特点进行。例如，对于较小的数据集或基本有序的数据集，插入排序可能是一个较好的选择；对于大规模数据集，快速排序和归并排序则更为适用。此外，开发者还可以结合多种排序算法的优点，设计出更为高效的排序方法。

在项目管理中，如果涉及到排序算法的实现和优化，可以使用研发项目管理系统PingCode和通用项目管理软件Worktile来进行项目的规划和跟踪。这些工具可以帮助团队更好地协作，提高项目的执行效率。

相关问答FAQs：

1. C语言中如何实现升序排序？

在C语言中，可以使用多种算法来实现升序排序，如冒泡排序、插入排序、选择排序等。其中最常用的是冒泡排序。冒泡排序的思想是通过相邻元素之间的比较和交换，将较大的元素逐渐移到数组的末尾。具体实现方法可以参考以下代码：

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

2. C语言中如何实现降序排序？

要实现降序排序，可以在排序算法的基础上稍作修改，将比较操作改为arr[j] < arr[j+1]。这样就可以将较大的元素逐渐移到数组的前面，实现降序排序。以下是使用冒泡排序实现降序排序的示例代码：

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

3. C语言中如何实现按照特定条件排序？

如果要按照特定条件进行排序，可以使用自定义的比较函数。在C语言中，可以使用标准库函数qsort来进行排序。qsort函数需要传入一个比较函数，用于指定排序的条件。比较函数需要返回一个整数值，表示两个元素的大小关系。以下是一个示例代码，实现按照数组元素的绝对值进行排序：

#include <stdlib.h>

int compare(const void *a, const void *b) {
   int num1 = abs(*(int*)a);
   int num2 = abs(*(int*)b);
   if (num1 < num2) return -1;
   if (num1 > num2) return 1;
   return 0;
}

int main() {
   int arr[] = { -4, 2, -7, 5, -1 };
   int n = sizeof(arr) / sizeof(arr[0]);
   qsort(arr, n, sizeof(int), compare);
   return 0;
}

以上是三个关于C语言实现不同排序方式的常见问题的解答，希望能对您有所帮助！如果有其他问题，请随时提问。

原创文章，作者：Edit2，如若转载，请注明出处：https://docs.pingcode.com/baike/1030033

赞 (0)
Edit2Edit2
上一篇 2024年8月27日 下午2:22
下一篇 2024年8月27日 下午2:22
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部