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

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

冒泡排序（Bubble Sort）：通过不断交换相邻的元素，将最大的元素逐渐向数组的末尾冒泡。时间复杂度为O(n^2)。
插入排序（Insertion Sort）：将待排序元素插入已排序子数组中的正确位置。时间复杂度为O(n^2)，但对于小规模的数组或部分有序的数组，具有较好的性能。
选择排序（Selection Sort）：每次从未排序部分选择最小的元素，并将其与未排序部分的首元素交换位置。时间复杂度为O(n^2)，不论原始数组是否有序，都需要进行相同数量的比较和交换操作。
快速排序（Quick Sort）：通过选择一个枢轴元素，将数组划分为左右两个子数组，并在子数组中递归地进行排序。时间复杂度为O(nlogn)，但在最坏情况下可能达到O(n^2)。
归并排序（Merge Sort）：将数组递归地分成两半，分别进行排序，然后将排序后的子数组进行合并。时间复杂度为O(nlogn)，且具有稳定性。
堆排序（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);
}
}