将数组分为两个部分，一个是有序部分，一个是无序部分。从无序部分中依次取出元素插入到有序部分中。过程就是遍历有序部分，实现起来比较简单。

在这里插入图片描述

  1. #include <stdio.h>
  3. void insertion_sort(int arr[], int array_length) {
  4.     for (int i = 0; i < array_length; ++i) {
  5.         int data = arr[i];
  6.         int j = 0;
  7.         while (arr[j] < arr[i]) {
  8.             j++;
  9.         }
  10.         for (int k = i; k >= j + 1; k--) {
  11.             arr[k] = arr[k - 1];
  12.         }
  13.         arr[j] = data;
  14.     }
  15. }
  17. void print_array(int arr[], int array_length) {
  18.     for (int i = 0; i < array_length; ++i) {
  19.         printf("%d ", arr[i]);
  20.     }
  21.     printf("\n");
  22. }
  24. int main() {
  25.     int arr[7] = {8, 2, 6, 0, 5, 7, 4};
  26.     insertion_sort(arr, 7);
  27.     print_array(arr, 7);
  28.     return 0;
  29. }

折半插入再直接插入上有改进，用折半搜索替换遍历数组，在数组长度大时能够提升查找性能。其本质还是从无序部分取出元素插入到有序部分中。

  1. #include <stdio.h>
  3. void binary_insertion_sort(int arr[], int array_length) {
  4.     int i, j, low = 0, high = 0, mid;
  5.     int temp = 0;
  6.     for (i = 1; i < array_length; i++) {
  7.         low = 0;
  8.         high = i - 1;
  9.         temp = arr[i];
  10.         while (low <= high) {
  11.             mid = (low + high) / 2;
  12.             if (arr[mid] > temp) {
  13.                 high = mid - 1;
  14.             } else {
  15.                 low = mid + 1;
  16.             }
  17.         }
  18.         for (j = i; j > low; j--) {
  19.             arr[j] = arr[j - 1];
  20.         }
  21.         arr[low] = temp;
  22.     }
  23. }
  25. void print_array(int arr[], int array_length) {
  26.     for (int i = 0; i < array_length; ++i) {
  27.         printf("%d ", arr[i]);
  28.     }
  29.     printf("\n");
  30. }
  32. int main() {
  33.     int brr[5] = {2, 6, 0, 5, 7};
  34.     binary_insertion_sort(brr, 5);
  35.     print_array(brr, 5);
  36.     return 0;
  37. }

希尔排序的核心就是根据步长分组，组内进行插入排序。关于步长的选取，第一次步长取元素的个数，后面每次取原来步长的一半。

希尔排序属于插入排序的一种。

在这里插入图片描述

  1. #include <stdio.h>
  3. void shell_sort(int arr[], int array_length) {
  4.     int step = array_length / 2;
  5.     while (step >= 1) {
  6.         for (int i = 0; i < array_length; i += step) {
  7.             int data = arr[i];
  8.             int j = 0;
  9.             while (arr[j] < arr[i]) {
  10.                 j++;
  11.             }
  12.             for (int k = i; k >= j + 1; k--) {
  13.                 arr[k] = arr[k - 1];
  14.             }
  15.             arr[j] = data;
  16.         }
  17.         step = step / 2;
  18.     }
  19. }
  21. void print_array(int arr[], int array_length) {
  22.     for (int i = 0; i < array_length; ++i) {
  23.         printf("%d ", arr[i]);
  24.     }
  25.     printf("\n");
  26. }
  28. int main() {
  29.     int crr[10] = {73, 22, 93, 43, 55, 14, 28, 65, 39, 81};
  30.     shell_sort(crr, 10);
  31.     print_array(crr, 10);
  32.     return 0;
  33. }

冒泡的特点是两两交换。通过交换把最大的元素交换到后面去了，每次循环遍历都把无序部分最大的“沉”到后面去。小数上“浮”和大数下“沉”其实没有差别，都能实现冒泡。

在这里插入图片描述

  1. #include <stdio.h>
  3. void bubble_sort(int arr[], int array_length) {
  4.     for (int i = 0; i < array_length - 1; ++i) {
  5.         for (int j = 0; j < array_length - i - 1; ++j) {
  6.             if (arr[j] > arr[j + 1]) {
  7.                 int temp = arr[j];
  8.                 arr[j] = arr[j + 1];
  9.                 arr[j + 1] = temp;
  10.             }
  11.         }
  12.     }
  13. }
  15. void print_array(int arr[], int array_length) {
  16.     for (int i = 0; i < array_length; ++i) {
  17.         printf("%d ", arr[i]);
  18.     }
  19.     printf("\n");
  20. }
  22. int main() {
  23.     int drr[7] = {8, 2, 6, 0, 5, 7, 4};
  24.     bubble_sort(drr, 7);
  25.     print_array(drr, 7);
  26.     return 0;
  27. }

快排的精髓在于选定一个标准（通常选数组的第一个元素），然后将所有元素根据标准分为小于和大于两个部分，然后这两个部分再选取标准，继续递归下去，不难想象最终排序结果是整体有序的。

在这里插入图片描述

  1. #include <stdio.h>
  3. int getStandard(int arr[], int low, int high) {
  4.     int flag = arr[low];
  5.     while (low < high) {
  6.         while (low < high && arr[high] >= flag) {
  7.             high--;
  8.         }
  9.         if (low < high) {
  10.             arr[low] = arr[high];
  11.         }
  12.         while (low < high && arr[low] <= flag) {
  13.             low++;
  14.         }
  15.         if (low < high) {
  16.             arr[high] = arr[low];
  17.         }
  18.     }
  19.     arr[low] = flag;
  20.     return low;
  21. }
  23. void quick_sort(int arr[], int low, int high) {
  24.     if (low < high) {
  25.         int pos = getStandard(arr, low, high);
  26.         quick_sort(arr, low, pos - 1);
  27.         quick_sort(arr, pos + 1, high);
  28.     }
  29. }
  31. void print_array(int arr[], int array_length) {
  32.     for (int i = 0; i < array_length; ++i) {
  33.         printf("%d ", arr[i]);
  34.     }
  35.     printf("\n");
  36. }
  38. int main() {
  39.     int err[10] = {73, 22, 93, 43, 55, 14, 28, 65, 39, 81};
  40.     quick_sort(err, 0, 9);
  41.     print_array(err, 10);
  42.     return 0;
  43. }

如其名，直接选择一个最小的放到最前面，但是遍历往往导致效率较低。

在这里插入图片描述

  1. #include <stdio.h>
  3. void select_sort(int arr[], int array_length) {
  4.     for (int i = 0; i < array_length; ++i) {
  5.         int min_pos = i;
  6.         for (int j = i; j < array_length; ++j) {
  7.             if (arr[min_pos] > arr[j])
  8.                 min_pos = j;
  9.         }
  10.         int temp = arr[min_pos];
  11.         arr[min_pos] = arr[i];
  12.         arr[i] = temp;
  13.     }
  14. }
  16. void print_array(int arr[], int array_length) {
  17.     for (int i = 0; i < array_length; ++i) {
  18.         printf("%d ", arr[i]);
  19.     }
  20.     printf("\n");
  21. }
  23. int main() {
  24.     int frr[7] = {8, 2, 6, 0, 5, 7, 4};
  25.     select_sort(frr, 7);
  26.     print_array(frr, 7);
  27.     return 0;
  28. }

将数组转换为一颗完全二叉树。任意一个父节点大于它的子节点，这样的完全二叉树叫做大顶堆；与之相反的，任意一个父节点小于它的子节点，这样的完全二叉树叫做小顶堆。

堆排序的精华就在于把元素个数为n的完全二叉树转换为大顶堆，然后把堆顶和最后一个元素交换，此时产生了一个元素个数为n-1的完全二叉树，然后再转换为大顶堆，继续把堆顶和最后一个元素交换。循环往复就实现了排序。其实质还是选择排序，每次选出一个最大的，和最后一个交换，不过完全二叉树中选最大元素比遍历数组会快很多。

在这里插入图片描述

  1. #include <stdio.h>
  3. void heap_adjust(int arr[], int n) {
  4.     for (int i = n / 2; i >= 1; i--) {
  5.         if (arr[i - 1] < arr[2 * i - 1]) {
  6.             int temp = arr[i - 1];
  7.             arr[i - 1] = arr[2 * i - 1];
  8.             arr[2 * i - 1] = temp;
  9.         }
  10.         if (arr[i - 1] < arr[2 * i] && (2 * i) < n) {
  11.             int temp = arr[i - 1];
  12.             arr[i - 1] = arr[2 * i];
  13.             arr[2 * i] = temp;
  14.         }
  15.     }
  16. }
  18. void heap_sort(int arr[], int array_length) {
  19.     int n = array_length;
  20.     do {
  21.         heap_adjust(arr, n);
  22.         int temp = arr[0];
  23.         arr[0] = arr[n - 1];
  24.         arr[n - 1] = temp;
  25.     } while (n--);
  26. }
  28. void print_array(int arr[], int array_length) {
  29.     for (int i = 0; i < array_length; ++i) {
  30.         printf("%d ", arr[i]);
  31.     }
  32.     printf("\n");
  33. }
  35. int main() {
  36.     int grr[7] = {8, 2, 6, 0, 5, 7, 4};
  37.     heap_sort(grr, 7);
  38.     print_array(grr, 7);
  39.     return 0;
  40. }

归并的思想在于对复杂问题的分治，打散到最小长度后然后再进行合并操作。假设有两个数组A、B，指针i指向A的头部，指针j指向B的头部，两边同时进行遍历，找到一个小的就放到数组里面，对应指针后移一位，这样就能够保证合并后的数组是有序的。

在这里插入图片描述

  1. #include <stdio.h>
  2. #include <malloc.h>
  4. void merge(int arr[], int start, int mid, int end) {
  5.     int *new_array = (int *) malloc(sizeof(int) * (end - start + 1));
  6.     int i = start;
  7.     int j = mid + 1;
  8.     int k = 0;
  9.     while (i <= mid && j <= end) {
  10.         if (arr[i] < arr[j]) {
  11.             new_array[k++] = arr[i++];
  12.         } else {
  13.             new_array[k++] = arr[j++];
  14.         }
  15.     }
  16.     while (i <= mid) {
  17.         new_array[k++] = arr[i++];
  18.     }
  19.     while (j <= end) {
  20.         new_array[k++] = arr[j++];
  21.     }
  22.     for (int l = 0; l < k; ++l) {
  23.         arr[start + l] = new_array[l];
  24.     }
  25.     free(new_array);
  26. }
  28. void merge_sort(int arr[], int start, int end) {
  29.     int mid = (start + end) / 2;
  30.     if (start >= end) {
  31.         return;
  32.     }
  33.     merge_sort(arr, start, mid);
  34.     merge_sort(arr, mid + 1, end);
  35.     merge(arr, start, mid, end);
  36. }
  38. void print_array(int arr[], int array_length) {
  39.     for (int i = 0; i < array_length; ++i) {
  40.         printf("%d ", arr[i]);
  41.     }
  42.     printf("\n");
  43. }
  45. int main() {
  46.     int hrr[10] = {73, 22, 93, 43, 55, 14, 28, 65, 39, 81};
  47.     merge_sort(hrr, 0, 9);
  48.     print_array(hrr, 10);
  49.     return 0;
  50. }

先按照个位排序将所有数字分配到0-9这10个桶里面，然后再按照桶的顺序收集起来；再按照十位排序，同样的步骤……

基础排序的本质是对每一位进行排序，对每一位进行排序后就能保证这一个数整体的大小是按照顺序排列的。

在这里插入图片描述

  1. #include <stdio.h>
  2. #include <malloc.h>
  4. int get_num(int number, int pos) {
  5.     int num = 0;
  6.     while (pos--) {
  7.         num = number % 10;
  8.         number = number / 10;
  9.     }
  10.     return num;
  11. }
  13. void radix_sort(int arr[], int array_length) {
  14.     int *bucket[10];
  15.     for (int i = 0; i < 10; ++i) {
  16.         bucket[i] = (int *) malloc(sizeof(int) * array_length + 1);
  17.         bucket[i][0] = 0;//桶的第一位保存桶中元素个数
  18.     }
  19.     for (int b = 1; b <= 31; ++b) {
  20.         for (int i = 0; i < array_length; ++i) {
  21.             int num = get_num(arr[i], b);//计算每个位上的数字（个位、十位、百位...）
  22.             int index = ++bucket[num][0];//计算下标
  23.             bucket[num][index] = arr[i];//保存到桶中
  24.         }
  25.         for (int i = 0, k = 0; i < 10; i++) {
  26.             for (int j = 1; j <= bucket[i][0]; ++j) {
  27.                 arr[k++] = bucket[i][j];//从桶里面按顺序取出来
  28.             }
  29.             bucket[i][0] = 0;//下标清零
  30.         }
  31.     }
  32. }
  34. void print_array(int arr[], int array_length) {
  35.     for (int i = 0; i < array_length; ++i) {
  36.         printf("%d ", arr[i]);
  37.     }
  38.     printf("\n");
  39. }
  41. int main() {
  42.     int irr[10] = {73, 22, 93, 43, 55, 14, 28, 65, 39, 81};
  43.     radix_sort(irr, 10);
  44.     print_array(irr, 10);
  45.     return 0;
  46. }

版权声明：本文为hexstudio原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/hexstudio/p/14277954.html