C++排序算法概览

发布时间:2024年01月09日

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

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

文章来源:https://blog.csdn.net/joe_g12345/article/details/135490333
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。