C++ 常用排序算法（冒泡排序 插入排序 选择排序 快速排序 归并排序 堆排序）

C++中常用的排序算法包括以下几种：

1. 冒泡排序（Bubble Sort）：通过不断交换相邻的元素，将最大的元素逐渐向数组的末尾冒泡。时间复杂度为O(n^2)。

2. 插入排序（Insertion Sort）：将待排序元素插入已排序子数组中的正确位置。时间复杂度为O(n^2)，但对于小规模的数组或部分有序的数组，具有较好的性能。

3. 选择排序（Selection Sort）：每次从未排序部分选择最小的元素，并将其与未排序部分的首元素交换位置。时间复杂度为O(n^2)，不论原始数组是否有序，都需要进行相同数量的比较和交换操作。

4. 快速排序（Quick Sort）：通过选择一个枢轴元素，将数组划分为左右两个子数组，并在子数组中递归地进行排序。时间复杂度为O(nlogn)，但在最坏情况下可能达到O(n^2)。

5. 归并排序（Merge Sort）：将数组递归地分成两半，分别进行排序，然后将排序后的子数组进行合并。时间复杂度为O(nlogn)，且具有稳定性。

6. 堆排序（Heap Sort）：通过构建最大堆或最小堆来进行排序。每次从堆中取出最值并调整结构，时间复杂度为O(nlogn)。

这些算法都是常见的排序算法，在实际应用中根据不同的场景和需求选择合适的算法，以达到最佳的排序效果。

以下是C++中冒泡排序、插入排序、选择排序、快速排序、归并排序和堆排序的完整示例代码：

1、冒泡排序（Bubble Sort）：
void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1])
                std::swap(arr[j], arr[j+1]);
        }
    }
}

2、插入排序（Insertion Sort）：
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;
    }
}

3、选择排序（Selection Sort）：
void selectionSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        int minIndex = i;
        for (int j = i+1; j < n; j++) {
            if (arr[j] < arr[minIndex])
                minIndex = j;
        }
        std::swap(arr[i], arr[minIndex]);
    }
}

4、快速排序（Quick Sort）：
int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
  
    for (int j = low; j < high; 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 pivotIndex = partition(arr, low, high);
        quickSort(arr, low, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, high);
    }
}

5、归并排序（Merge Sort）：
void merge(int arr[], int left, int mid, int right) {
    int len1 = mid - left + 1;
    int len2 = right - mid;
  
    int L[len1], R[len2];
  
    for (int i = 0; i < len1; i++)
        L[i] = arr[left + i];
    for (int j = 0; j < len2; j++)
        R[j] = arr[mid + 1 + j];
  
    int i = 0;
    int j = 0;
    int k = left;
  
    while (i < len1 && j < len2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
  
    while (i < len1) {
        arr[k] = L[i];
        i++;
        k++;
    }
  
    while (j < len2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}
  
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);
    }
}

6、堆排序（Heap Sort）：
void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2*i + 1;
    int r = 2*i + 2;
 
    if (l < n && arr[l] > arr[largest])
        largest = l;
 
    if (r < n && arr[r] > arr[largest])
        largest = r;
 
    if (largest != i) {
        std::swap(arr[i], arr[largest]);
 
        heapify(arr, n, largest);
    }
}
 
void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);
 
    for (int i = n - 1; i >= 0; i--) {
        std::swap(arr[0], arr[i]);
 
        heapify(arr, i, 0);
    }
}

这些示例代码展示了C++中常用的排序算法的实现，可以直接在C++程序中使用它们进行排序操作。