目录
插入排序
插入排序是一种简单的排序算法,它的工作原理类似于打扑克牌整理顺序。在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)
。该算法相比于堆排序和快速排序,其主要的优点是:当记录表中含有值相同的记录时,排序前和排序后在表中的相对位置不会改变。