【算法】经典的八大排序算法

点击链接 可视化排序 动态演示各个排序算法来加深理解,大致如下

一,冒泡排序(Bubble Sort)

原理

  • 冒泡排序(Bubble Sort)是一种简单的排序算法,它通过多次比较和交换相邻元素的方式,将最大(或最小)的元素逐步冒泡到数组的一端。每一轮冒泡将会将未排序部分中最大(或最小)的元素“浮”到正确的位置。

算法步骤

  1. 从数组的第一个元素开始,依次比较相邻的两个元素。
  2. 如果前一个元素比后一个元素大(或小,取决于排序顺序),则交换这两个元素。
  3. 继续向后遍历,对每一对相邻元素重复步骤 2。
  4. 重复步骤 1 到 3,直到没有元素需要交换,整个数组就是有序的。

算法实现

#include <iostream>
#include <vector>// 冒泡排序
void bubbleSort(std::vector<int>& arr) {int n = arr.size();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]);}}}
}

性能分析

  • 时间复杂度:
    • 冒泡排序的时间复杂度在最坏和平均情况下都为 O(n^2),其中 n 是待排序元素的数量。每次遍历需要进行 n-1 次比较,而需要执行 n-1 次遍历。
    • 最好情况下,如果列表本身已经有序,冒泡排序仍然需要进行 n-1 次遍历,但由于没有发生交换,每次遍历只需要进行 n-1、n-2、...、2、1 次比较,时间复杂度为 O(n)。
  • 空间复杂度:
    • 冒泡排序的空间复杂度为 O(1),只需要常数级别的额外空间。
  • 稳定性:
    • 冒泡排序是稳定的排序算法,因为它在相邻元素比较时仅在必要时才进行交换。

二,选择排序(Selection Sort)

原理

  • 选择排序(Selection Sort)是一种简单的排序算法,它将待排序数组分为已排序和未排序两部分,然后从未排序部分选择最小(或最大)的元素,与已排序部分的最后一个元素交换位置。每次交换都会将一个元素归位,直到整个数组有序。

算法步骤

  1. 初始时,将整个序列分为已排序和未排序两部分,已排序为空,未排序包含所有元素。
  2. 在未排序部分中,找到最小(或最大)的元素。
  3. 将找到的最小元素与未排序部分的第一个元素交换位置,将其放到已排序部分的末尾。
  4. 重复执行步骤 2 和 3,直到未排序部分为空,整个序列变得有序。

算法实现

#include <iostream>
#include <vector>// 选择排序
void selectionSort(std::vector<int>& arr) {int n = arr.size();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]);}
}

性能分析

  • 时间复杂度:
    • 选择排序的时间复杂度在最好、最坏和平均情况下都是 O(n^2),其中 n 是待排序元素的数量。
  • 空间复杂度:
    • 选择排序的空间复杂度为 O(1),只需要常数级别的额外空间。
  • 稳定性:
    • 选择排序是不稳定的排序算法,因为在选择最小(或最大)元素的过程中,相同值的元素可能会交换位置。

三,插入排序(Insertion Sort)

原理

  • 插入排序(Insertion Sort)是一种简单的排序算法,它将待排序数组分为已排序和未排序两部分,然后逐个将未排序部分的元素插入到已排序部分的正确位置,使得已排序部分始终保持有序。

算法步骤

  1. 初始时,将第一个元素视为已排序部分,其余元素视为未排序部分。
  2. 从未排序部分中取出一个元素,将其插入到已排序部分的适当位置,使得插入后的已排序部分仍然保持有序。
  3. 重复步骤 2,直到未排序部分为空,整个序列变得有序。

算法实现

#include <iostream>
#include <vector>// 插入排序
void insertionSort(std::vector<int>& arr) {int n = arr.size();for (int i = 1; i < n; ++i) {int current = arr[i]; // 当前要插入的元素int j = i - 1; // 已排序部分的末尾索引// 将元素插入到正确位置while (j >= 0 && arr[j] > current) {arr[j + 1] = arr[j];j--;}arr[j + 1] = current;}
}

性能分析

  • 时间复杂度:
    • 插入排序的时间复杂度在最好情况下是 O(n),最坏和平均情况下是 O(n^2),其中 n 是待排序元素的数量。
  • 空间复杂度:
    • 插入排序的空间复杂度为 O(1),只需要常数级别的额外空间。
  • 稳定性:
    • 插入排序是稳定的排序算法,因为它在插入元素时相同值的元素不会改变相对顺序。

四,希尔排序(Shell Sort)

原理

  • 希尔排序(Shell Sort)是一种改进的插入排序算法,它通过将数组分成多个子序列来排序,然后逐步缩小子序列的间隔,最终将整个数组排序。希尔排序的核心思想是使数组中任意间隔 h 的元素都是有序的,当 h 逐步减小到 1 时,整个数组变为有序。

算法步骤

  1. 选择一个增量序列(通常为递减的整数序列),例如 [n/2, n/4, n/8, ...],其中 n 是数组的长度。
  2. 对每个增量进行迭代,将数组分成多个子数组,每个子数组中的元素间隔为增量。
  3. 对每个子数组进行插入排序,将子数组中的元素插入到已排序部分的适当位置。
  4. 重复步骤 2 和 3,不断减小增量,直到增量为 1,此时整个数组被视为一个子数组,进行最后一次插入排序。

算法实现

#include <iostream>void shellSort(int arr[], int n) {for (int gap = n / 2; gap > 0; gap /= 2) {// 使用插入排序对子数组进行排序for (int i = gap; i < n; ++i) {int temp = arr[i];int j = i;// 移动元素,寻找插入位置while (j >= gap && arr[j - gap] > temp) {arr[j] = arr[j - gap];j -= gap;}arr[j] = temp; // 将元素插入到合适的位置}}
}

性能分析

  • 时间复杂度:
    • 希尔排序的时间复杂度依赖于所选的增量序列。最好的已知增量序列的时间复杂度是 O(n^1.3),平均情况下的时间复杂度较难分析,但它通常优于 O(n^2) (介于 O(n log n) 和 O(n^2) 之间)的插入排序。具体取决于增量序列的选择。
  • 空间复杂度:
    • 希尔排序的空间复杂度为 O(1),只需要常数级别的额外空间。
  • 稳定性:
    • 希尔排序不是稳定的排序算法,因为在交换元素的过程中可能会改变相同值元素的相对顺序。

五,归并排序(Merge Sort)

原理

  • 归并排序(Merge Sort)是一种分治策略的排序算法,它将待排序数组不断划分为两个子数组,然后将这些子数组逐步合并成一个有序数组。归并排序的核心思想是将两个有序的子数组合并成一个有序的数组,这样逐步合并,最终得到整个数组有序。

算法步骤

  1. 分割:将待排序数组递归地分割成较小的子数组,直到每个子数组只包含一个元素。
  2. 合并:将两个有序的子数组合并成一个有序数组。合并过程中,分别从两个子数组中取出较小的元素,放入结果数组中。

算法实现

#include <iostream>
#include <vector>// 合并两个有序子数组
void merge(std::vector<int>& arr, int left, int mid, int right) {int leftCount = mid - left + 1;    // 左边子数组大小int rightCount = right - mid;      // 右边子数组大小// 创建临时数组存放两个子数组的元素std::vector<int> leftArr(leftCount), rightArr(rightCount);for (int i = 0; i < leftCount; ++i)leftArr[i] = arr[left + i];for (int i = 0; i < rightCount; ++i)rightArr[i] = arr[mid + 1 + i];// 合并两个子数组int i = 0, j = 0, k = left;while (i < leftCount && j < rightCount) {if (leftArr[i] <= rightArr[j]) {arr[k++] = leftArr[i++];} else {arr[k++] = rightArr[j++];}}// 将剩余的元素拷贝到结果数组中while (i < leftCount) {arr[k++] = leftArr[i++];}while (j < rightCount) {arr[k++] = rightArr[j++];}
}// 归并排序
void mergeSort(std::vector<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);}
}

性能分析

  • 时间复杂度:
    • 归并排序的时间复杂度是稳定的,无论数据的分布如何,都是 O(n log n),其中 n 是待排序元素的数量。
  • 空间复杂度:
    • 归并排序需要额外的空间来存储临时数组,因此其空间复杂度是 O(n)。
  • 稳定性:
    • 归并排序是稳定的排序算法,因为在合并两个子数组时,相同值的元素不会改变相对顺序。

六,快速排序(Quick Sort)

原理

  • 快速排序(Quick Sort)是一种基于分治思想的排序算法,它通过选择一个基准元素,将数组划分为小于基准和大于基准的两部分,然后递归地对这两部分进行排序。在每一次划分后,基准元素会被放置在最终的正确位置上。

算法步骤

  1. 选择基准元素:从数组中选择一个基准元素,通常选择第一个或最后一个元素。
  2. 分区:将数组划分为小于基准和大于基准的两部分,使得基准元素位于正确的位置上。
  3. 递归排序:对小于基准和大于基准的两部分分别递归地应用快速排序算法。
  4. 合并:不需要合并步骤,因为在分区过程中已经将数组划分为有序的部分。

算法实现

#include <iostream>
#include <vector>// 分区函数,返回基准元素的正确位置
int partition(std::vector<int>& arr, int low, int high) {int pivot = arr[low]; // 选择第一个元素作为基准while (low < high){while (low<high && arr[high]>=pivot)--high;arr[low] = arr[high];   // 将小于基准的元素移到左边while (low<high && arr[low]<=pivot)++low;arr[high] = arr[low];   // 将大于基准的元素移到右边}// 将基准元素放到正确的位置上arr[low] = pivot;return low; // 返回存放基准的最终位置
}// 快速排序
void quickSort(std::vector<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);}
}

性能分析

  • 时间复杂度:
    • 平均情况下,快速排序的时间复杂度是 O(n log n),其中 n 是待排序元素的数量。
    • 在最坏情况下(数组已经有序或接近有序),快速排序的时间复杂度可能退化到 O(n^2)。
  • 空间复杂度:
    • 快速排序的空间复杂度主要取决于递归调用的栈空间,通常为 O(log n)。
    • 在最坏情况下,递归栈的深度可能达到 n,空间复杂度为 O(n)。
  • 稳定性:
    • 快速排序是不稳定的排序算法,因为在分区过程中可能改变相同元素的相对顺序。

七,堆排序(Heap Sort)

原理

  • 堆排序(Heap Sort)是一种基于二叉堆的排序算法。它将待排序数组构建成一个二叉堆,然后不断从堆顶取出最大(或最小)元素,将其放置到已排序部分的末尾,直到整个数组有序。

算法步骤

  1. 构建最大堆:将待排序数组看作完全二叉树,从最后一个非叶子节点开始,逐步向上调整,使得每个节点都大于其子节点。
  2. 不断从堆顶取出最大元素:每次将堆顶元素与堆末尾元素交换,然后将堆的大小减一,再进行堆化操作,将最大元素移至正确位置。
  3. 重复步骤 2,直到堆中只剩一个元素,此时整个数组有序。

算法实现

#include <iostream>
#include <vector>// 交换元素
void swap(int& a, int& b) {a = a + b;b = a - b;a = a - b;
}// 对以 root 为根的子树进行堆化
void heapify(std::vector<int>& arr, int n, int root) {int largest = root; // 初始化最大元素为根节点while (largest < n) {int left = 2 * root + 1; // 左子节点索引int right = 2 * root + 2; // 右子节点索引// 找到左右子节点中较大的元素索引if (left < n && arr[left] > arr[largest]) {largest = left;}if (right < n && arr[right] > arr[largest]) {largest = right;}// 如果最大元素不是根节点,则交换元素if (largest != root) {swap(arr[root], arr[largest]);root = largest; // 继续向下调整} else {break; // 堆结构已经满足,退出循环}}
}// 堆排序
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) {swap(arr[0], arr[i]); // 将堆顶元素移至已排序部分的末尾heapify(arr, i, 0); // 对剩余的部分进行堆化}
}

性能分析

  • 时间复杂度:
    • 堆排序的时间复杂度在最好、最坏和平均情况下都是 O(n log n),其中 n 是待排序元素的数量。
  • 空间复杂度:
    • 堆排序的空间复杂度为 O(1),只需要常数级别的额外空间。
  • 稳定性:
    • 堆排序通常是不稳定的,因为堆化操作可能改变相同元素的相对顺序。然而,通过一些额外的操作可以实现稳定性。

八,基数排序(Counting Sort)

原理

  • 基数排序(Radix Sort)是一种非比较的整数排序算法,它根据数字的每个位上的值来对元素进行排序。基数排序可以看作是桶排序的扩展,它先按照最低位进行排序,然后逐步移到更高位,直到所有位都考虑完毕。

算法步骤

  1. 找到最大数的位数:首先,找到待排序数组中最大数的位数,这将决定排序的轮数。
  2. 按位排序:从低位到高位,依次对每一位进行计数排序(或桶排序),将元素分配到不同的桶中。
  3. 合并桶:将每一轮排序后的桶中的元素按顺序合并成一个新的数组。
  4. 重复步骤 2 和 3,直到所有位都考虑完毕,得到有序数组。

算法实现

#include <iostream>
#include <vector>
#include <queue>// 找到数组中的最大数
int findMax(std::vector<int>& arr) {int max = arr[0];for (int num : arr) {if (num > max) {max = num;}}return max;
}// 基数排序
void radixSort(std::vector<int>& arr) {int n = arr.size();int max = findMax(arr);int exp = 1; // 用于获取每个位数的值while (max / exp > 0) {// 创建桶队列,每个桶用于存放某个位数上的元素std::vector<std::queue<int>> buckets(10);   // 使用10个桶,每个桶代表一个数字(0到9)// 将元素分配到桶中for (int i = 0; i < n; ++i) {int bucketIndex = (arr[i] / exp) % 10; // 计算当前位数的值,作为桶的索引buckets[bucketIndex].push(arr[i]); // 将元素放入对应的桶中}// 从桶中取回元素到原数组int index = 0;for (int i = 0; i < 10; ++i) {while (!buckets[i].empty()) {arr[index++] = buckets[i].front(); // 取出队列头部元素,放入原数组buckets[i].pop(); // 弹出队列头部元素}}exp *= 10; // 移到下一个位数}
}

性能分析

  • 时间复杂度:
    • 基数排序的时间复杂度取决于位数和基数的大小。对于位数为 k,基数为 r 的情况,时间复杂度为 O(k * (n + r))。
  • 空间复杂度:
    • 基数排序的空间复杂度为 O(n + r),其中 n 是待排序元素的数量,r 是基数的大小。
  • 稳定性:
    • 基数排序是稳定的排序算法,因为在同一位数上的排序时,相同值元素的相对顺序不会改变。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/58981.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

springcloud-nacos简述

Spring Cloud alibaba: nacos服务注册中心&#xff0c;配置中心 服务注册中心 1.项目父工程添加springcloudalibaba依赖 <dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-alibaba-dependencies</artifactId><ve…

Ubuntu20以上高版本如何安装低版本GCC

安装了Ubuntu 20.04之后&#xff0c;通过命令行 sudo apt-get install build-essential安装gcc&#xff0c;再通过命令行 gcc -v可查看gcc版本为gcc13 如果想用低版本的gcc&#xff0c;比如gcc4.8&#xff0c;尝试输入命令 sudo apt-get install gcc-4.8会提示找不到gcc4.8的…

context.WithCancel()的使用

“ WithCancel可以将一个Context包装为cancelCtx,并提供一个取消函数,调用这个取消函数,可以Cancel对应的Context Go语言context包-cancelCtx[1] 疑问 context.WithCancel()取消机制的理解[2] 父母5s钟后出门&#xff0c;倒计时&#xff0c;父母在时要学习&#xff0c;父母一走…

hadoop学习:mapreduce入门案例二:统计学生成绩

这里相较于 wordcount&#xff0c;新的知识点在于学生实体类的编写以及使用 数据信息&#xff1a; 1. Student 实体类 import org.apache.hadoop.io.WritableComparable;import java.io.DataInput; import java.io.DataOutput; import java.io.IOException;public class Stude…

mac电脑屏幕录制Berrycast Mac屏幕录制软件

Berrycast是一款为Mac设计的优秀屏幕录制软件&#xff0c;它让屏幕录制变得简单而高效。以下是Berrycast的一些主要特点&#xff1a; 简单的用户界面&#xff1a;Berrycast拥有直观和简洁的用户界面&#xff0c;使得用户可以轻松上手。高质量的视频输出&#xff1a;Berrycast能…

浅析SAS协议:链路层

文章目录 概述原语通用原语连接管理原语连接通信原语 地址帧IDENTIFY地址帧OPEN地址帧 链路复位Link ResetHard ResetSATA的Link Reset 连接管理建立连接连接仲裁 流量控制SSP流控Credit Advance SMP流控 相关参考 概述 SAS链路层用于定义原语、地址帧以及连接相关的内容&…

ATF(TF-A)安全通告 TFV-3 (CVE-2017-7563)

安全之安全(security)博客目录导读 ATF(TF-A)安全通告汇总 目录 一、ATF(TF-A)安全通告 TFV-3 (CVE-2017-7563) 二、CVE-2017-7563 一、ATF(TF-A)安全通告 TFV-3 (CVE-2017-7563) Title RO内存始终在AArch64 Secure EL1下可执行 CVE ID CVE-2017-7563 Date 06 Apr 2017 …

springcloud-gateway简述

Spring Cloud Gateway 是一个用于构建 API 网关的项目&#xff0c;它是 Spring Cloud 生态系统中的一部分&#xff0c;旨在为微服务架构提供动态路由、负载均衡、安全性和监控等功能。 网关工程对应pom文件 <?xml version"1.0" encoding"UTF-8"?>…

无涯教程-分类算法 - 朴素贝叶斯

朴素贝叶斯算法是一种基于应用贝叶斯定理的分类技术&#xff0c;其中强烈假设所有预测变量彼​​此独立。简而言之&#xff0c;假设是某个类中某个要素的存在独立于同一类中其他任何要素的存在。 在贝叶斯分类中&#xff0c;主要的兴趣是找到后验概率&#xff0c;即给定某些观…

使用Spring Boot和Kafka实现消息发送和订阅

文章目录 一&#xff0c;新建Spring Boot1&#xff0c;Maven配置2&#xff0c;无法识别为SpringBoot项目3&#xff0c;无效的源发行版4&#xff0c;无法访问SpringApplication5&#xff0c;运行直接Finish6&#xff0c;服务运行成功 二&#xff0c;安装启动Kafka1&#xff0c;下…

工厂方法模式的概述和使用

目录 一、工厂方法模式概述1. 定义2. 使用动机 二、工厂方法模式结构1. 模式结构2. 时序图 三、工厂方法模式的使用实例四、工厂方法模式的优缺点五、工厂方法模式在Java中应用 原文链接 一、工厂方法模式概述 1. 定义 工厂方法模式(Factory Method Pattern)又称为工厂模式&…

【卷积神经网络】MNIST 手写体识别

LeNet-5 是经典卷积神经网络之一&#xff0c;1998 年由 Yann LeCun 等人在论文 《Gradient-Based Learning Applied to Document Recognition》中提出。LeNet-5 网络使用了卷积层、池化层和全连接层&#xff0c;实现可以应用于手写体识别的卷积神经网络。TensorFlow 内置了 MNI…

2023年智慧政务一网通办云平台顶层设计与建设方案PPT

导读:原文《2023年智慧政务一网通办云平台顶层设计与建设方案PPT》(获取来源见文尾),本文精选其中精华及架构部分,逻辑清晰、内容完整,为快速形成售前方案提供参考。 部分内容:

汽车3D HMI图形引擎选型指南【2023】

推荐&#xff1a;用 NSDT编辑器 快速搭建可编程3D场景 2002年&#xff0c;电影《少数派报告》让观众深入了解未来。 除了情节的核心道德困境之外&#xff0c;大多数人都对它的技术着迷。 我们看到了自动驾驶汽车、个性化广告和用户可以无缝交互的 3D 计算机界面。 令人惊讶的是…

基于PID优化和矢量控制装置的四旋翼无人机(MatlabSimulink实现)

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…

使用GoLand进行远程调试

对部署进行配置 在此配置远程服务器地址&#xff0c;映射&#xff0c;是否自动上传(更新)等 选择SFTP类型 选择上传 另外给自动上传选项打钩 此时在本地修改某个文件&#xff0c;远程机器相应目录的文件&#xff0c;也会被同步修改 对远程调试进行配置 远程机器需要安装delve 而…

时间范围选择时选中日期所使用的当日内具体时刻 如00:00:00= 23:59:59

<el-form-item label"审核时间&#xff1a;"><el-date-pickerv-model"auditTime"type"datetimerange"range-separator"至"value-format"yyyy-MM-dd HH:mm:ss"start-placeholder"开始日期"end-placeholde…

无意间发现这款可以免费制作3D翻页电子画册的网站

在博主努力的搜寻下&#xff0c;无意间发现这个网站&#xff0c;可以免费制作3D翻页电子画册。使用这个网站非常简单&#xff0c;只需上传你想要展示的图片和添加相应的文字&#xff0c;然后选择合适的模板和风格。接下来&#xff0c;就会自动转化成漂亮的3D翻页画册 工具嘛&am…

用idea查看sqlite数据库idea sqlite

1、安装Database Navigator插件 2、导入数据库并查看 3、删除数据库连接 在此做个笔记

ceph中PGLog处理流程

ceph的PGLog是由PG来维护&#xff0c;记录了该PG的所有操作&#xff0c;其作用类似于数据库里的undo log。PGLog通常只保存近千条的操作记录(默认是3000条&#xff0c; 由osd_min_pg_log_entries指定)&#xff0c;但是当PG处于降级状态时&#xff0c;就会保存更多的日志&#x…