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

1. 插入排序（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 插入到已排序的序列中。

2. 选择排序（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 是数组长度。首先遍历整个数组，每次找到未排序的部分中最小的元素的下标，并将其与已排序的部分的末尾元素交换。最终，数组将被排序。

3. 快速排序（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 来记录左部分序列的末尾元素的下标，然后遍历序列中除了基准元素外的所有元素，将小于基准元素的元素交换到左部分序列的末尾。最后，将基准元素交换到左右两部分序列的中间位置。

4. 归并排序（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 分别遍历这两个子序列，将它们合并成一个有序序列。最后将有序序列中剩余的元素添加到数组中。

5. 计数排序（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 数组中进行计数。最后，我们将计数数组中的元素按顺序输出到待排序数组中，从而得到排序后的数组。