目录
插入排序
插入排序是一种简单的排序算法，它的工作原理类似于打扑克牌整理顺序。在C++中，插入排序的基本步骤如下：
- 假设 数组的第一个元素已经排序了。
- 遍历 从第二个元素开始，对于每个未排序的元素（称为当前元素）： a. 比较 当前元素与已排序部分的最大元素。 b. 移动 如果当前元素小于最大元素，将最大元素向右移一位，直到找到合适的位置并插入当前元素。 c. 重复 直到所有元素都被插入到适当位置。
代码
#include <iostream>
#include <vector>
using namespace std;
void insertionSort(vector<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;//如果比前面的有序数组的最大元素还大，直接放到数组尾部
}
}
int main() {
vector<int> arr = { 9, 5, 2, 6, 3 };
int len = arr.size();
cout << "Before sorting:\n";
for (int i : arr) {
std::cout << i << " ";
}
insertionSort(arr, len);
std::cout << "\nAfter sorting:\n";
for (int i : arr) {
std::cout << i << " ";
}
return 0;
}
复杂度分析：O（)
选择排序
选择排序是一种简单直观的排序算法，它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据排完。
代码
#include <iostream>
#include <vector>
using namespace std;
void selectionSort(vector<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;//更新最小值的下标
}
}
// 将找到的最小值放到已排序部分的末尾
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
int main() {
vector<int> arr = { 9, 5, 2, 6, 3 };
int len = arr.size();
cout << "Before sorting:\n";
for (int i : arr) {
std::cout << i << " ";
}
selectionSort(arr, len);
std::cout << "\nAfter sorting:\n";
for (int i : arr) {
std::cout << i << " ";
}
return 0;
}
冒泡排序
通过一趟趟的比较，一个个的“最大值”被找到并移动到相应位置，直到检测到表中数据已经有序，或者比较次数等同于表中含有记录的个数，排序结束，这就是起泡排序。
代码
#include <iostream>
#include <vector>
#include <string>
using namespace std;
class sort {
public:
void swap(int& a, int& b) {
int temp;
temp = a;
a = b;
b = temp;
}
vector<int> bubble_sort(vector<int> arr) {
int len = arr.size();
int flag;
for (int i = 0; i < len; i++) {
flag = 0;
for (int j = 0; j + 1 < len - i; j++) {
if (arr[j] > arr[j + 1]) {
flag = 1;
swap(arr[j], arr[j + 1]);
}
}
if (flag == 0) {
break;
}
}
return arr;
}
};
int main() {
vector<int> nums;
int num;
while(cin >> num) {
nums.push_back(num);
}
sort a;
vector<int> result;
result = a.bubble_sort(nums);
for (int x : result)
cout << x << " ";
}总结
使用起泡排序算法，其时间复杂度同实际表中数据的无序程度有关。若表中记录本身为正序存放，则整个排序过程只需进行 n-1（n 为表中记录的个数）次比较，且不需要移动记录；若表中记录为逆序存放（最坏的情况），则需要 n-1趟排序，进行 n(n-1)/2 次比较和数据的移动。所以该算法的时间复杂度为O()。
快速排序
通过一次排序将整个无序表分成相互独立的两部分，其中一部分中的数据都比另一部分中包含的数据的值小，然后继续沿用此方法分别对两部分进行同样的操作，直到每一个小部分不可再分，所得到的整个序列就成为了有序序列。
代码
#include <stdio.h>
#include <iostream>
#include <math.h>
#include <algorithm>
#include <vector>
using namespace std;
int part(vector<int>& r, int low, int hight) //划分函数，引用作为参数
{
int i = low, j = hight, pivot = r[low]; //基准元素
while (i < j)
{
while (i<j && r[j]>pivot) //从右向左开始找一个 小于等于 pivot的数值
{
j--;//8 6 4
}
if (i < j)
{
swap(r[i++], r[j]); //r[i]和r[j]交换后 i 向右移动一位
}
while (i < j && r[i] <= pivot) //从左向右开始找一个 大于 pivot的数值
{
i++;
}
if (i < j)
{
swap(r[i], r[j--]); //r[i]和r[j]交换后 i 向左移动一位
}
}
return i; //返回最终划分完成后基准元素所在的位置
}
void Quicksort(vector<int>& r, int low, int hight)//引用作为参数
{
int mid;
if (low < hight)
{
mid = part(r, low, hight); // 返回基准元素位置
Quicksort(r, low, mid - 1); // 左区间递归快速排序
Quicksort(r, mid + 1, hight); // 右区间递归快速排序
}
}
int main()
{
vector<int>nums;
int num;
while (cin >> num) {
nums.push_back(num);
}
Quicksort(nums, 0, nums.size() - 1);
cout << "排序后的序列为： " << endl;
for (int x:nums)
{
cout << x << " ";
}
cout << endl;
return 0;
}总结
快速排序算法的时间复杂度为O(nlogn)，是所有时间复杂度相同的排序方法中性能最好的排序算法。
堆排序
在学习堆排序之前，首先需要了解堆的含义：在含有 n 个元素的序列中，如果序列中的元素满足下面其中一种关系时，此序列可以称之为堆。
- ki ≤ k2i 且 ki ≤ k2i+1（在 n 个记录的范围内，第 i 个关键字的值小于第 2*i 个关键字，同时也小于第 2*i+1 个关键字）
- ki ≥ k2i 且 ki ≥ k2i+1（在 n 个记录的范围内，第 i 个关键字的值大于第 2*i 个关键字，同时也大于第 2*i+1 个关键字）
对于堆的定义也可以使用完全二叉树来解释，因为在完全二叉树中第 i 个结点的左孩子恰好是第 2i 个结点，右孩子恰好是 2i+1 个结点。如果该序列可以被称为堆，则使用该序列构建的完全二叉树中，每个根结点的值都必须不小于（或者不大于）左右孩子结点的值。
通过将无序表转化为堆，可以直接找到表中最大值或者最小值，然后将其提取出来，令剩余的记录再重建一个堆，取出次大值或者次小值，如此反复执行就可以得到一个有序序列，此过程为堆排序。
将数组[2 8 6 1 10 15 3 12 11]转化为堆的步骤：
代码
#include <iostream>
#include <vector>
using namespace std;
class solution {
public:
void maxHeapify(vector<int>& a, int i, int heapSize) {
int l = i * 2 + 1, r = i * 2 + 2, largest = i;
if (l < heapSize && a[l] > a[largest]) {
largest = l;
}
if (r < heapSize && a[r] > a[largest]) {
largest = r;
}
if (largest != i) {
swap(a[i], a[largest]);
maxHeapify(a, largest, heapSize);
}
}
void buildMaxHeap(vector<int>& a, int heapSize) {
for (int i = heapSize / 2; i >= 0; --i) {
maxHeapify(a, i, heapSize);
}
}
vector<int> sort_heap(vector<int>& heap) {
int size = heap.size();
buildMaxHeap(heap, size);
return heap;
}
};
//15 12 6 11 10 2 3 1 8
int main() {
vector<int> nums;
int num;
while (cin >> num) {
nums.push_back(num);
}
solution a;
a.sort_heap(nums);
for (int x : nums) {
cout << x << " ";
}
}
初始化：将前n/2个元素按照最大堆规则填充，也就是每个父节点值大于或等于其子节点的值。
//for(int i = n / 2 - 1; i >= 0; i--)
// heapify(i, heap_size);
//
添加元素（插入操作）：通常在堆的末尾添加新元素，然后上移调整堆形，直到满足最大堆条件。
//void insert(int value) {
// heap[heap_size] = value;
// heapify(heap_size, heap_size);
// heap_size++;
//}
删除最大元素（提取最大元素并调整堆）：删除根节点，将其最后一个元素移动到根位置，然后对新的根进行调整，保证仍然满足最大堆。
//int extractMax() {
// int max_value = heap;
// heap = heap[heap_size - 1];
// heap_size--;
// heapify(0, heap_size);
// return max_value;
//}
总结
堆排序在最坏的情况下，其时间复杂度仍为 O(nlogn)。这是相对于快速排序的优点所在。同时堆排序相对于树形选择排序，其只需要一个用于记录交换（rc）的辅助存储空间，比树形选择排序的运行空间更小。
归并排序
归并排序是一种基于分治策略的高效排序算法。它的基本思想是将待排序序列不断二分，然后对两个有序部分进行合并，直到整个序列有序。
代码
#include <iostream>
#include <vector>
// 合并函数
void merge(std::vector<int>& arr, int left, int mid, int right) {
std::vector<int> temp(right - left + 1);
int i = left, j = mid + 1, k = 0;
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
}
else {
temp[k++] = arr[j++];
}
}
// 将剩余元素添加到结果数组
while (i <= mid) {//将左边有序部分的剩余元素添加到临时数组temp后面
temp[k++] = arr[i++];
}
while (j <= right) {//将右边有序部分剩余的元素添加到临时数组；
temp[k++] = arr[j++];
}
// 把临时数组的内容复制回原数组
for (i = left; i <= right; i++) {
arr[i] = temp[i - left];
}
}
// 归并排序主函数
void mergeSort(std::vector<int>& arr, int low, int high) {
if (low < high) {
int mid = low + (high - low) / 2;
mergeSort(arr, low, mid); // 对左半部分排序
mergeSort(arr, mid + 1, high); // 对右半部分排序
merge(arr, low, mid, high); // 合并两个已排序的部分
}
}
int main() {
std::vector<int> numbers = { 9, 7, 5, 11, 12, 2, 14, 3 };
int n = numbers.size();
mergeSort(numbers, 0, n - 1);
std::cout << "Sorted array: ";
for (auto num : numbers) {
std::cout << num << " ";
}
return 0;
}
总结
归并排序算法的时间复杂度为O(nlogn)。该算法相比于堆排序和快速排序，其主要的优点是：当记录表中含有值相同的记录时，排序前和排序后在表中的相对位置不会改变。
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
