std中稳定排序算法_八大经典排序算法

### C++ 中八大排序算法的实现 #### 1. 插入排序 插入排序是一种简单直观的排序算法，它的工作原理类似于人们整理手中的扑克牌。每次从未排序部分取出一个元素，在已排序部分找到合适的位置将其插入。 ```cpp void insertionSort(std::vector<int>& arr) { for (size_t i = 1; i < arr.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; } } ``` #### 2. 冒泡排序 冒泡排序通过重复遍历要排序的列表来工作，依次比较相邻项，并按需交换位置直到整个数组变得有序为止[^1]。 ```cpp void bubbleSort(std::vector<int>& arr) { bool swapped; for (size_t i = 0; i < arr.size() - 1; ++i) { swapped = false; for (size_t j = 0; j < arr.size() - i - 1; ++j) { if (arr[j] > arr[j + 1]) { std::swap(arr[j], arr[j + 1]); swapped = true; } } // 如果没有发生任何交换，则说明已经完成排序 if (!swapped) break; } } ``` #### 3. 简单选择排序 该方法首先找出最小（或最大）元素并与第一个元素互换；接着在剩下的未处理区域继续寻找次小值并移动到第二个位置...以此类推直至全部记录都有序[^3]。 ```cpp void selectionSort(std::vector<int>& arr) { for (size_t i = 0; i < arr.size() - 1; ++i) { size_t minIndex = i; for (size_t j = i + 1; j < arr.size(); ++j) { if (arr[j] < arr[minIndex]) minIndex = j; } if (minIndex != i) std::swap(arr[i], arr[minIndex]); } } ``` #### 4. 希尔排序 希尔排序是对直接插入排序的一种改进版本，其基本思想是在待排序列上构建间隔逐渐减小的子序列来进行排序操作，最后当增量降为1时即完成了最终的一轮完整的插入排序过程[^5]。 ```cpp void shellSort(std::vector<int>& arr) { for (int gap = arr.size() / 2; gap > 0; gap /= 2) { for (size_t i = gap; i < arr.size(); ++i) { int temp = arr[i]; int j; for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) { arr[j] = arr[j - gap]; } arr[j] = temp; } } } ``` #### 5. 快速排序 快速排序采用分治策略，选取一个基准元素将原始数组划分为两部分——小于等于基准的部分位于左侧而大于它的则置于右侧，之后递归地对这两边应用相同的操作，直到所有区间都被完全划分完毕[^2]。 ```cpp void quickSort(std::vector<int>& arr, int low, int high) { if (low < high) { int pi = partition(arr, low, high); quickSort(arr, low, pi - 1); // 对左半区进行快排 quickSort(arr, pi + 1, high); // 对右半区进行快排 } } int partition(std::vector<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; } ``` #### 6. 堆排序 堆排序利用了二叉堆这种特殊的数据结构特性，先建立最大(小)根堆再逐个删除堆顶节点从而达到升序或者降序的效果。 ```cpp void heapify(std::vector<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(std::vector<int>& arr) { int n = arr.size(); 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); } } ``` #### 7. 归并排序 归并排序也是一种基于分治原则的经典排序技术，主要思路就是把原表不断分割成较小规模的问题求解后再逐步合并回原来大小的过程。 ```cpp void merge(std::vector<int>& arr, int const left, int const mid, int const right) { auto subArrayOne = mid - left + 1; auto subArrayTwo = right - mid; std::vector<int> leftArray(subArrayOne), rightArray(subArrayTwo); for (auto i = 0; i < subArrayOne; i++) leftArray[i] = arr[left + i]; for (auto j = 0; j < subArrayTwo; j++) rightArray[j] = arr[mid + 1 + j]; int indexOfSubArrayOne = 0, indexOfSubArrayTwo = 0; int indexOfMergedArray = left; while (indexOfSubArrayOne < subArrayOne && indexOfSubArrayTwo < subArrayTwo) { if (leftArray[indexOfSubArrayOne] <= rightArray[indexOfSubArrayTwo]) { arr[indexOfMergedArray] = leftArray[indexOfSubArrayOne++]; } else { arr[indexOfMergedArray] = rightArray[indexOfSubArrayTwo++]; } indexOfMergedArray++; } while (indexOfSubArrayOne < subArrayOne) { arr[indexOfMergedArray++] = leftArray[indexOfSubArrayOne++]; } while (indexOfSubArrayTwo < subArrayTwo) { arr[indexOfMergedArray++] = rightArray[indexOfSubArrayTwo++]; } } void mergeSort(std::vector<int>& arr, int const begin, int const end) { if (begin >= end) return; auto mid = begin + (end - begin) / 2; mergeSort(arr, begin, mid); mergeSort(arr, mid + 1, end); merge(arr, begin, mid, end); } ``` #### 8. 计数排序 不同于上述几种内部排序方式，计数排序属于外部排序范畴，适用于整型数据集且范围有限的情况。此算法创建了一个额外的空间用于统计输入序列中各数值出现次数的信息，进而重构出新的有序序列。 ```cpp void countSort(std::vector<int>& arr) { int maxElement = *std::max_element(arr.begin(), arr.end()); int minElement = *std::min_element(arr.begin(), arr.end()); int range = maxElement - minElement + 1; std::vector<int> count(range, 0); for(auto& num : arr){ count[num-minElement]++; } int index = 0; for(int a=0;a<range;++a){ while(count[a]>0){ arr[index++]=a+minElement; --count[a]; } } } ```