C++排序算法概览

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

冒泡排序（Bubble Sort）：

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

cpp 复制代码

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

插入排序（Insertion Sort）：

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

cpp 复制代码

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

选择排序（Selection Sort）：

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

cpp 复制代码

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

快速排序（Quick Sort）：

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

cpp 复制代码

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

归并排序（Merge Sort）：

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

cpp 复制代码

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++程序示例。根据实际需求和数据规模的不同，可以选择适合的排序算法来提高排序效率。