C++排序算法概览

几种常见的排序算法概览：

1. 冒泡排序（Bubble Sort）：

   • 优点：实现简单，代码易于理解和实现。
   • 缺点：时间复杂度较高，平均时间复杂度为O(n^2)。

   void bubbleSort(int arr[], int size) {
      for(int i = 0; i < size - 1; i++) {
         for(int j = 0; j < size - i - 1; j++) {
            if(arr[j] > arr[j + 1]) {
               std::swap(arr[j], arr[j + 1]);
            }
         }
      }
   }
   

2. 插入排序（Insertion Sort）：

   • 优点：对于小规模数据或基本有序的数据效果好，原地排序，不需要额外的空间。
   • 缺点：平均时间复杂度为O(n^2)。

   void insertionSort(int arr[], int size) {
      for(int i = 1; i < size; 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;
      }
   }
   

3. 选择排序（Selection Sort）：

   • 优点：简单，对于小规模数据或者要求不稳定排序的场景较为合适。
   • 缺点：平均时间复杂度为O(n^2)。

   void selectionSort(int arr[], int size) {
      for(int i = 0; i < size - 1; i++) {
         int minIndex = i;
         for(int j = i + 1; j < size; j++) {
            if(arr[j] < arr[minIndex]) {
               minIndex = j;
            }
         }
         std::swap(arr[minIndex], arr[i]);
      }
   }
   

4. 快速排序（Quick Sort）：

   • 优点：平均情况下性能良好，时间复杂度为O(nlogn)，适用于大规模数据排序。
   • 缺点：最坏情况下可能退化为O(n^2)，对于近乎有序的数据性能较差。

   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++;
            std::swap(arr[i], arr[j]);
         }
      }
      std::swap(arr[i + 1], arr[high]);
      return i + 1;
   }
   
   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);
      }
   }
   

5. 归并排序（Merge Sort）：

   • 优点：稳定的排序算法，时间复杂度为O(nlogn)。
   • 缺点：需要额外的空间来存储临时数组。

   void merge(int arr[], int l, int m, int r) {
      int n1 = m - l + 1;
      int n2 = r - m;
      int L[n1], R[n2];
      
      for(int i = 0; i < n1; i++) {
         L[i] = arr[l + i];
      }
      
      for(int j = 0; j < n2; j++) {
         R[j] = arr[m + 1 + j];
      }
      
      int i = 0;
      int j = 0;
      int 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);
      }
   }
   

以上是对几种排序算法的优缺点分析以及对应的C++程序示例。根据实际需求和数据规模的不同，可以选择适合的排序算法来提高排序效率。