• C语言实现各类排序算法

    排序算法是计算机科学中的一个重要概念,它是一种将一个无序的数列重新排列成有序的方法。常见的排序算法有:

    选择排序（Selection Sort）

    选择排序是一种简单直观的排序演算法。它的工作原理:首先在未排序序列中找到最小(大)元素，存放到排序序列的起始位置，然后,，再從剩餘未排序元素中继续寻找最小(大)元素，然后放到已排序序列的末尾。以上步骤反复执行，直到所有数据元素均排序完毕。

    1. #include 
    2.  
    3. void selection_sort(int arr[], int n)
    4. {
    5.     int i, j, min_idx;
    6.     for (i = 0; i < n-1; i++) {
    7.         min_idx = i;
    8.         for (j = i+1; j < n; j++) {
    9.             if (arr[j] < arr[min_idx]) {
    10.                 min_idx = j;
    11.             }
    12.         }
    13.         int temp = arr[i];
    14.         arr[i] = arr[min_idx];
    15.         arr[min_idx] = temp;
    16.     }
    17. }
    18.  
    19. int main()
    20. {
    21.     int arr[] = {64, 34, 25, 12, 22, 11, 90};
    22.     int n = sizeof(arr) / sizeof(arr[0]);
    23.  
    24.     selection_sort(arr, n);
    25.  
    26.     printf("Sorted array is:\n");
    27.     for (int i = 0; i < n; i++)
    28.         printf("%d ", arr[i]);
    29.     printf("\n");
    30.  
    31.     return 0;
    32. }

    冒泡排序（Bubble Sort）：

    最简单的排序算法，通过重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

    1. #include 
    2.  
    3. void bubbleSort(int arr[], int n)
    4. {
    5.     int i, j;
    6.     for (i = 0; i < n-1; i++) {
    7.         for (j = 0; j < n-i-1; j++) {
    8.             if (arr[j] > arr[j+1]) {
    9.                 int temp = arr[j];
    10.                 arr[j] = arr[j+1];
    11.                 arr[j+1] = temp;
    12.             }
    13.         }
    14.     }
    15. }
    16.  
    17. int main()
    18. {
    19.     int arr[] = {64, 34, 25, 12, 22, 11, 90};
    20.     int n = sizeof(arr) / sizeof(arr[0]);
    21.  
    22.     bubbleSort(arr, n);
    23.  
    24.     printf("Sorted array is:\n");
    25.     for (int i = 0; i < n; i++)
    26.         printf("%d ", arr[i]);
    27.     printf("\n");
    28.  
    29.     return 0;
    30. }

    插入排序（Insertion Sort）：

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

    1. #include 
    2.  
    3. void insertionSort(int arr[], int n)
    4. {
    5.     int i, j;
    6.     for (i = 1; i < n; i++) {
    7.         int temp = arr[i];
    8.         j = i - 1;
    9.         while (j >= 0 && arr[j] > temp) {
    10.             arr[j + 1] = arr[j];
    11.             j--;
    12.         }
    13.         arr[j + 1] = temp;
    14.     }
    15. }
    16.  
    17. int main()
    18. {
    19.     int arr[] = {64, 34, 25, 12, 22, 11, 90};
    20.     int n = sizeof(arr) / sizeof(arr[0]);
    21.  
    22.     insertionSort(arr, n);
    23.  
    24.     printf("Sorted array is:\n");
    25.     for (int i = 0; i < n; i++)
    26.         printf("%d ", arr[i]);
    27.     printf("\n");
    28.  
    29.     return 0;
    30. }

    希尔排序（Shell Sort）：

    希尔排序是一种插入排序的改进版本。希尔排序的基本思想是使数组中的元素像是在一个具有各种尺寸的篮子里进行排序。希尔排序通过设定一个步长，将数组分为若干个子序列，然后对这些子序列分别进行插入排序。当步长为1时，希尔排序就退化为插入排序。希尔排序的步长可以选择不同的值，通常选择2的幂次方，比如1，2，4，8，16，32等。

    1. #include 
    2.  
    3. void shellSort(int arr[], int n)
    4. {
    5.     int i, j, gap;
    6.     for (gap = n/2; gap > 0; gap /= 2) {
    7.         for (i = gap; i < n; i++) {
    8.             int temp = arr[i];
    9.             for (j = i-gap; j >= 0 && arr[j] > temp; j -= gap) {
    10.                 arr[j+gap] = arr[j];
    11.             }
    12.             arr[j+gap] = temp;
    13.         }
    14.     }
    15. }
    16.  
    17. int main()
    18. {
    19.     int arr[] = {64, 34, 25, 12, 22, 11, 90};
    20.     int n = sizeof(arr) / sizeof(arr[0]);
    21.  
    22.     shellSort(arr, n);
    23.  
    24.     printf("Sorted array is:\n");
    25.     for (int i = 0; i < n; i++)
    26.         printf("%d ", arr[i]);
    27.     printf("\n");
    28.  
    29.     return 0;
    30. }

    归并排序（Merge Sort）：

    是建立在归并操作上的一种有效的排序算法，该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。

    1. #include 
    2. #include 
    3.  
    4. void merge(int arr[], int l, int m, int r)
    5. {
    6.     int i, j, k, n1, n2;
    7.     int L[m-l+1], R[r-m];
    8.  
    9.     n1 = m - l + 1;
    10.     n2 = r - m;
    11.  
    12.     for (i = 0; i < n1; i++)
    13.         L[i] = arr[l + i];
    14.     for (j = 0; j < n2; j++)
    15.         R[j] = arr[m + 1 + j];
    16.  
    17.     i = 0;
    18.     j = 0;
    19.     k = l;
    20.     while (i < n1 && j < n2) {
    21.         if (L[i] <= R[j]) {
    22.             arr[k] = L[i];
    23.             i++;
    24.         }
    25.         else {
    26.             arr[k] = R[j];
    27.             j++;
    28.         }
    29.         k++;
    30.     }
    31.  
    32.     while (i < n1) {
    33.         arr[k] = L[i];
    34.         i++;
    35.         k++;
    36.     }
    37.  
    38.     while (j < n2) {
    39.         arr[k] = R[j];
    40.         j++;
    41.         k++;
    42.     }
    43. }
    44.  
    45. void mergeSort(int arr[], int l, int r)
    46. {
    47.     if (l < r) {
    48.         int m = (l + r) / 2;
    49.         mergeSort(arr, l, m);
    50.         mergeSort(arr, m + 1, r);
    51.         merge(arr, l, m, r);
    52.     }
    53. }
    54.  
    55. int main()
    56. {
    57.     int arr[] = {64, 34, 25, 12, 22, 11, 90};
    58.     int n = sizeof(arr) / sizeof(arr[0]);
    59.  
    60.     mergeSort(arr, 0, n-1);
    61.  
    62.     printf("Sorted array is:\n");
    63.     for (int i = 0; i < n; i++)
    64.         printf("%d ", arr[i]);
    65.     printf("\n");
    66.  
    67.     return 0;
    68. }

    快速排序（Quick Sort）：

    快速排序是一种高效的排序算法，基于分治法(Divide and Conquer)的一个策略。将要排序的数组分为两个子数组，一个包含相应的元素，一个包含其他的元素。

    1. #include 
    2.  
    3. void quickSort(int arr[], int left, int right)
    4. {
    5.     if (left < right) {
    6.         int pivot = arr[(left + right) / 2];
    7.         int i = left, j = right;
    8.         while (i <= j) {
    9.             while (arr[i] < pivot) i++;
    10.             while (arr[j] > pivot) j--;
    11.             if (i <= j) {
    12.                 int temp = arr[i];
    13.                 arr[i] = arr[j];
    14.                 arr[j] = temp;
    15.                 i++;
    16.                 j--;
    17.             }
    18.         }
    19.         quickSort(arr, left, j);
    20.         quickSort(arr, i, right);
    21.     }
    22. }
    23.  
    24. int main()
    25. {
    26.     int arr[] = {64, 34, 25, 12, 22, 11, 90};
    27.     int n = sizeof(arr) / sizeof(arr[0]);
    28.  
    29.     quickSort(arr, 0, n-1);
    30.  
    31.     printf("Sorted array is:\n");
    32.     for (int i = 0; i < n; i++)
    33.         printf("%d ", arr[i]);
    34.     printf("\n");
    35.  
    36.     return 0;
    37. }

    堆排序（Heap Sort）：

    是一种比较高效的选择排序，无论原址排序还是非原址排序都有其实现。

    1. #include 
    2. #include 
    3.  
    4. void max_heapify(int arr[], int n, int i)
    5. {
    6.     int largest = i;
    7.     int l = 2*i + 1;
    8.     int r = 2*i + 2;
    9.  
    10.     if (l < n && arr[l] > arr[largest])
    11.         largest = l;
    12.  
    13.     if (r < n && arr[r] > arr[largest])
    14.         largest = r;
    15.  
    16.     if (largest!= i) {
    17.         int temp = arr[i];
    18.         arr[i] = arr[largest];
    19.         arr[largest] = temp;
    20.  
    21.         max_heapify(arr, n, largest);
    22.     }
    23. }
    24.  
    25. void heap_sort(int arr[], int n)
    26. {
    27.     for (int i = n/2 - 1; i >= 0; i--)
    28.         max_heapify(arr, n, i);
    29.  
    30.     for (int i = n-1; i >= 0; i--) {
    31.         int temp = arr[0];
    32.         arr[0] = arr[i];
    33.         arr[i] = temp;
    34.  
    35.         max_heapify(arr, i, 0);
    36.     }
    37. }
    38.  
    39. int main()
    40. {
    41.     int arr[] = {64, 34, 25, 12, 22, 11, 90};
    42.     int n = sizeof(arr) / sizeof(arr[0]);
    43.  
    44.     heap_sort(arr, n);
    45.  
    46.     printf("Sorted array is:\n");
    47.     for (int i = 0; i < n; i++)
    48.         printf("%d ", arr[i]);
    49.     printf("\n");
    50.  
    51.     return 0;
    52. }

    桶排序：

    桶排序是计算机科学中的一种排序算法，工作原理是将要排序的元素划分到不同的桶，然后分别对每个桶中的元素进行排序，最后将每个桶中的元素合并成一个有序的序列。

    1. #include 
    2.  
    3. void bucketSort(int arr[], int n, int maxValue) {
    4.     int i, j;
    5.     int count[maxValue+1];
    6.     int output[n];
    7.  
    8.     for (i = 0; i <= maxValue; i++)
    9.         count[i] = 0;
    10.  
    11.     for (i = 0; i < n; i++)
    12.         count[arr[i]]++;
    13.  
    14.     for (i = 1; i <= maxValue; i++)
    15.         count[i] += count[i - 1];
    16.  
    17.     for (i = n - 1; i >= 0; i--) {
    18.         output[count[arr[i]] - 1] = arr[i];
    19.         count[arr[i]]--;
    20.     }
    21.  
    22.     for (i = 0; i < n; i++)
    23.         arr[i] = output[i];
    24. }
    25.  
    26. int main() {
    27.     int arr[] = {37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54};
    28.     int n = sizeof(arr) / sizeof(arr[0]);
    29.     int maxValue = 100;
    30.  
    31.     bucketSort(arr, n, maxValue);
    32.  
    33.     printf("Sorted array: \n");
    34.     for (int i = 0; i < n; i++)
    35.         printf("%d ", arr[i]);
    36.  
    37.     return 0;
    38. }

    计数排序：

    计数排序是一种线性时间复杂度的排序算法，这种算法对输入的数据有一定的限制，如它们都是非负整数。计数排序是一种非比较排序算法，其核心思想是将输入的数据值转化为键存储在额外开辟的数组空间中。当输入数据是非负整数时，计数排序是一个线性时间排序算法。

    1. #include 
    2.  
    3. void countSort(int arr[], int n) {
    4.     int max = arr[0];
    5.     int min = arr[0];
    6.  
    7.     // 找到数组中的最大和最小值
    8.     for (int i = 1; i < n; i++) {
    9.         if (arr[i] > max)
    10.             max = arr[i];
    11.         if (arr[i] < min)
    12.             min = arr[i];
    13.     }
    14.  
    15.     // 初始化计数数组
    16.     int range = max - min + 1;
    17.     int count[range];
    18.     for (int i = 0; i < range; i++)
    19.         count[i] = 0;
    20.  
    21.     // 计算每个元素的数量
    22.     for (int i = 0; i < n; i++)
    23.         count[arr[i] - min]++;
    24.  
    25.     // 修改计数数组,使得每个元素的值表示该元素在数组中的位置
    26.     for (int i = 1; i < range; i++)
    27.         count[i] += count[i - 1];
    28.  
    29.     // 创建一个结果数组,每个元素的位置由计数数组决定
    30.     int output[n];
    31.     for (int i = n - 1; i >= 0; i--) {
    32.         output[count[arr[i] - min] - 1] = arr[i];
    33.         count[arr[i] - min]--;
    34.     }
    35.  
    36.     // 将结果数组复制到原数组
    37.     for (int i = 0; i < n; i++)
    38.         arr[i] = output[i];
    39. }
    40.  
    41. int main() {
    42.     int arr[] = {10, 20, 7, 8, 9, 1, 5};
    43.     int n = sizeof(arr) / sizeof(arr[0]);
    44.     countSort(arr, n);
    45.     printf("Sorted array: \n");
    46.     for (int i = 0; i < n; i++)
    47.         printf("%d ", arr[i]);
    48.     return 0;
    49. }

    基数排序：

    基数排序是一种非比较整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。通常适用于对小范围整数的排序。将整个整数(例如名字或日期)中的每个数字或字母类似于排序每个单独的数字。

    1. #include 
    2.  
    3. void countingSort(int arr[], int n, int exp) {
    4.     int output[n]; 
    5.     int i;
    6.     int count[10] = {0}; 
    7.  
    8.     for (i = 0; i < n; i++)
    9.         count[(arr[i] / exp) % 10]++;
    10.  
    11.     for (i = 1; i < 10; i++)
    12.         count[i] += count[i - 1];
    13.  
    14.     for (i = n - 1; i >= 0; i--) {
    15.         output[count[(arr[i] / exp) % 10] - 1] = arr[i];
    16.         count[(arr[i] / exp) % 10]--;
    17.     }
    18.  
    19.     for (i = 0; i < n; i++)
    20.         arr[i] = output[i];
    21. }
    22.  
    23. void radixsort(int arr[], int n) {
    24.     int m = getMax(arr, n);
    25.  
    26.     for (int exp = 1; m / exp > 0; exp *= 10)
    27.         countingSort(arr, n, exp);
    28. }
    29.  
    30. int getMax(int arr[], int n) {
    31.     int mx = arr[0];
    32.     for (int i = 1; i < n; i++)
    33.         if (arr[i] > mx)
    34.             mx = arr[i];
    35.     return mx;
    36. }
    37.  
    38. void print(int arr[], int n) {
    39.     for (int i = 0; i < n; i++)
    40.         printf("%d ", arr[i]);
    41.     printf("\n");
    42. }
    43.  
    44. int main() {
    45.     int arr[] = {170, 45, 75, 90, 802, 24, 2, 66};
    46.     int n = sizeof(arr) / sizeof(arr[0]);
    47.     radixsort(arr, n);
    48.     print(arr, n);
    49.     return 0;
    50. }

    斐波那契排序：

    这是一个对冒泡排序的改进，通过引入斐波那契数列的概念，减少了比较的次数。工作原理是通过两层循环，外层循环控制整个排序过程，内层循环控制每一轮的排序。如果前一个元素大于后一个元素，就交换它们的位置。这样一轮比较下来，最大的元素就会移动到它应该在的位置上。

    1. #include 
    2.  
    3. void swap(int *a, int *b) {
    4.     int temp = *a;
    5.     *a = *b;
    6.     *b = temp;
    7. }
    8.  
    9. void fbSort(int arr[], int n) {
    10.     int i, j;
    11.     for (i = 0; i < n-1; i++) {
    12.         for (j = 0; j < n-i-1; j++) {
    13.             if (arr[j] > arr[j+1]) {
    14.                 swap(&arr[j], &arr[j+1]);
    15.             }
    16.         }
    17.     }
    18. }
    19.  
    20. int main() {
    21.     int arr[] = {5, 8, 1, 3, 9, 6};
    22.     int n = sizeof(arr)/sizeof(arr[0]);
    23.     fbSort(arr, n);
    24.     printf("Sorted array: \n");
    25.     for (int i=0; i
    26.         printf("%d ", arr[i]);
    27.     }
    28.     return 0;
    29. }

    哈夫曼排序: 

    哈夫曼排序是一种优先队列排序,它的基本思想是将待排序的序列看作是一棵完全二叉树,然后从上到下和从左到右进行排序。

    1. #include
    2. #include
    3.  
    4. typedef struct Node {
    5.     int data;
    6.     int freq;
    7.     struct Node *left, *right;
    8. } Node;
    9.  
    10. Node* newNode(int data, int freq) {
    11.     Node* node = (Node*)malloc(sizeof(Node));
    12.     node->data = data;
    13.     node->freq = freq;
    14.     node->left = node->right = NULL;
    15.     return node;
    16. }
    17.  
    18. int isLeaf(Node* node) {
    19.     return (!node->left && !node->right);
    20. }
    21.  
    22. int max(Node *a, Node *b) {
    23.     return (a->freq > b->freq)? a->freq : b->freq;
    24. }
    25.  
    26. Node *decodeHuff(Node* root, string s, int i) {
    27.     if (root == NULL) return root;
    28.     if (isLeaf(root)) return root;
    29.     if (s[i] == '0') {
    30.         return decodeHuff(root->left, s, i+1);
    31.     }
    32.     else return decodeHuff(root->right, s, i+1);
    33. }
    34.  
    35. void printCodes(Node* root, string s) {
    36.     if (root == NULL) return;
    37.     if (isLeaf(root)) {
    38.         printf("%c : ", root->data);
    39.         printf("%s\n", s);
    40.         return;
    41.     }
    42.     printCodes(root->left, strcat(s, "0"));
    43.     printCodes(root->right, strcat(s, "1"));
    44. }
    45.  
    46. int main() {
    47.     string s = "aabcccccaaa";
    48.     int freq[256];
    49.     memset(freq, 0, sizeof(freq));
    50.     for (int i=0; i
    51.     Node* root = NULL;
    52.     for (int i=0; i<256; i++)
    53.         if (freq[i] > 0)
    54.             root = insertNode(root, newNode(i, freq[i]));
    55.     printCodes(root, "");
    56.     return 0;
    57. }

  • 相关阅读:
    Java8 Lambda.stream.sorted() 方法使用浅析分享
    【7月12日活动预告】现代数据栈峰会
    11、IOC 之使用 JSR 330 标准注释
    基因组学重点整理
    服务器怎么启动vue3 构建的dist 服务
    【每天学习一点新知识】浏览器的同源策略
    [C++数据结构](23)哈希：位图，布隆过滤器，哈希切割
    MMPretrain
    聊聊HuggingFace如何处理大模型下海量数据集
    malloc与free
  • 原文地址：https://blog.csdn.net/ZHAOJUNWEI08/article/details/136374127