撕烂数据爆锤算法：内排序之交换算法

最新推荐文章于 2024-08-16 22:18:58 发布
最新推荐文章于 2024-08-16 22:18:58 发布
阅读量247 收藏 1
点赞数 1
分类专栏： 撕烂数据爆锤算法 文章标签： 算法 数据结构 排序算法 快速排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45714923/article/details/106145621
版权

前言：
小鑫鑫课堂开课了，孩子数据结构老差了，多半是废了，快看撕烂数据爆锤算法系列吧…撕烂数据，爆锤算法，这是你的不二选择。（请允许我的厚颜无耻，正所谓黄婆卖瓜自卖自夸嘛！）今天记录的是我在学习交换排序中一些小小总结，希望对你有所帮助啦。总之，码字不易，还望各位多多支持哦！
同是天涯码字猿，
共勉，共勉~~~
在这里插入图片描述
正文：

一、基础概述：

a.冒泡排序：从左向右扫描一个序列，只要发现两个相邻的数据元素处于逆序，则交换这两个元素的位置。以升序为例，所谓的逆序状态是指Date[i]>Date[i+1]的状态，正序是指date[i]<=Date[i+1]的状态。这样扫描一遍，被称为一趟冒泡。每趟冒泡之后，序列中的最大元素一定位于序列最后。接下来忽略这个最大元素，对剩余的部分再进行一趟冒泡。这样重复冒泡直到剩余的序列长度为1为止。长度为N的序列，最多需要N-1趟冒泡。

b.冒泡排序的改进：记下最后一次交换操作的位置flag，下次冒泡区间是Date[0…flag]而不是Date[0…n-i]。用传送代替交换。传送操作在遇到需要连续交换的情况下，会有效的减少数据移动的量。以Date[i+1],Date[i+2],Date[i+3]连续交换为例，所谓传送是指首先用temp保存Date[i]，然后将Date[i+1],Date[i+2],Date[i+3]依次向左移动一个单元，最后将temp复制到Date[i+3]上。在两个方向上对序列进行冒泡，压缩冒泡区间。

c.快速排序：是对冒泡法排序的一种改进。快速排序算法的基本思想是：将所要进行排序的数分为左右两个部分，其中一部分的所有数据都比另外一 部分的数据小，然后将所分得的两部分数据进行同样的划分，重复执行以上的划分操作，直 到所有要进行排序的数据变为有序为止。

二、时间（或空间）复杂度：

a.冒泡排序：最坏情况和平均时间复杂度是O(n^2)，最好情况下的时间复杂度为O(n)。

b.快速排序：理想情况下时间复杂度为O(N*log(2)N)，最坏情况下时间复杂度为O(n^2)。

三、代码实现：

一、直接插入排序

1.定义头文件：

#include<stdio.h>
#define MAXSIZE 100
void TraverseDate(int Date[],int n);         //遍历元素
void InitDate(int Date[],int &n);            //初始化待排元素
void SortDate(int Date[],int n);             //简单冒泡排序
int main();                                  //主函数

2.遍历元素：

void TraverseDate(int Date[],int n)           //遍历元素
{
 int i;
 for(i=1;i<=n;i++)
  printf("%4d",Date[i]);
 putchar(10);
    putchar(10);
 return;
}

3.初始化待排元素：

void InitDate(int Date[],int &n)           //初始化待排元素
{
 int i;
 printf("\n请输入待排元素个数:");
 scanf("%d",&n);
 putchar(10);
 for(i=1;i<=n;i++)
 {
  printf("\n请输入待排元素:");
  scanf("%d",&Date[i]);
 }
 putchar(10);
 printf("\n待排元素为:");
 TraverseDate(Date,n);
 return;
}

4.冒泡排序（核心）：

void SortDate(int Date[],int n)           //冒泡排序
{
 int i,j,t,flag;
 for(i=1;i<=n;i++)                     
 {
  flag=1;                           //flag作为标志，用来判断经过一趟交换后，序列是否变为有序
  for(j=1;j<=n-i;j++)    //因为每一趟得到一个较前面元素大的元素，交换至每一趟的末位，故末位序列元素已经有序，不用进行比较
  {
   if(Date[j]>Date[j+1])         //相邻两元素进行比较，若前一元素大于后一元素，两元素进行交换
   {
    t=Date[j];
    Date[j]=Date[j+1];
    Date[j+1]=t;
    flag=0;
   }
  }
  if(flag==1)
   break;
 }
 printf("\n排序结果为:");
 TraverseDate(Date,n);
 return;
}

5.主函数：

int main()                                   //主函数
{
 int n,Date[MAXSIZE];
 InitDate(Date,n);
 SortDate(Date,n);
 return 0;
}

6.运行结果：
在这里插入图片描述
二、冒泡排序的改进

1.定义头文件：

#include<stdio.h>
#define MAXSIZE 100
void TraverseDate(int Date[],int n);         //遍历元素
void InitDate(int Date[],int &n);            //初始化待排元素
void Sort(int Date[],int n);                  //冒泡排序
void SortDate(int Date[],int n);             //冒泡排序接口
int main();                                  //主函数

2.遍历元素：

void TraverseDate(int Date[],int n)           //遍历元素
{
 int i;
 for(i=1;i<=n;i++)
  printf("%4d",Date[i]);
 putchar(10);
    putchar(10);
 return;
}

3.初始化待排元素：

void InitDate(int Date[],int &n)             //初始化待排元素
{
 int i;
 printf("\n请输入待排元素个数:");
 scanf("%d",&n);
 putchar(10);
 for(i=1;i<=n;i++)
 {
  printf("\n请输入待排元素:");
  scanf("%d",&Date[i]);
 }
 putchar(10);
 printf("\n待排元素为:");
 TraverseDate(Date,n);
 return;
}

4.冒泡排序（核心）：

void Sort(int Date[],int n)                     //冒泡排序
{
 int low,high,flag,i,j,temp;    //high,low用来标识冒泡区域
 high=n;                        //如果flag是1,表示已经有序，否则flag是一个方向冒泡区间的终点，又是另一个冒泡区间的起点
 low=1;                     
 flag=1;                        //从左向右方向上，冒泡区间初始值为1，终点是n
 while(low<high)   //从左开始冒泡   
 {                            
  low=flag;          //冒泡区间被标识为Date[low...high]
  i=low;
  flag=1;            //假定未发生交换  
  while(i<high)
  {
   if(Date[i]>Date[i+1])         //发现逆序，执行传送操作
   {
    temp=Date[i];              //保存Date[i]
    while(i<high&&temp>Date[i+1])
    {                                //将比temp小的元素向左移动
     Date[i]=Date[i+1];
     i++;
    }
    Date[i]=temp;              //将temp传送到正确的位置
    flag=i-1;                  //如果这是最后一次传送，那么flag就是新冒泡区间的终点
   }
   i++;
  }
  if(flag==1)                        //未发生交换，Date已经有序，跳出
   break;                         //开始自右往左冒泡
  high=flag;                         //设定新的冒泡起点
  j=high;
  flag=1;                            //假定未发生冒泡
  while(j>low)
  {
   if(Date[j]<Date[j-1])          //发现逆序，执行传送操作
   {
    temp=Date[j];
    while(j>low&&temp<Date[j-1]) 
    {
     Date[j]=Date[j-1];
     j--;
    }
    Date[j]=temp;
    flag=j+1;              //如果这是最后一次传送，那么flag就是新冒泡区间的起点
   } 
   j--;
  }
  if(flag==1)                    //未发生交换，Date已经有序，跳出
   break;
 }
 return;
}

5.冒泡排序接口：

void SortDate(int Date[],int n)                  //冒泡排序接口
{
 Sort(Date,n);
 printf("\n排序结果为:");
 TraverseDate(Date,n);
 return;
}

6.主函数：

int main()                                       //主函数
{
 int n,Date[MAXSIZE];
 InitDate(Date,n);
 SortDate(Date,n);
 return 0;
}

7.运行结果：
在这里插入图片描述

三、快速排序

1.定义头文件：

#include<stdio.h>
#define MAXSIZE 100
void TraverseDate(int Date[],int n);         //遍历元素
void InitDate(int Date[],int &n);            //初始化待排元素
void Sort(int Date[],int n);                  //快速排序
void SortDate(int Date[],int n);             //快速排序接口
int main();                                  //主函数

2.遍历元素：

void TraverseDate(int Date[],int n)          //遍历元素
{
 int i;
 for(i=1;i<=n;i++)
  printf("%4d",Date[i]);
 putchar(10);
    putchar(10);
 return;
}

3.初始化待排元素：

void InitDate(int Date[],int &n)              //初始化待排元素
{
 int i;
 printf("\n请输入待排元素个数:");
 scanf("%d",&n);
 putchar(10);
 for(i=1;i<=n;i++)
 {
  printf("\n请输入待排元素:");
  scanf("%d",&Date[i]);
 }
 putchar(10);
 printf("\n待排元素为:");
 TraverseDate(Date,n);
 return;
}

4.快速排序（核心）：

void Sort(int Date[],int left,int right)         //快速排序
{
 int i,j,temp,t;
 if(left>right)
  return;
 i=left;                           //区间起始值
 j=right;                          //区间末位值
 temp=Date[left];                  //存储选定的起始值
 while(i<j)
 {
  while(i<j&&Date[j]>=temp)      //在temp右边找到比temp小的元素1
   j--;
  while(i<j&&Date[i]<=temp)      //在temp右边找到比temp小的元素2
   i++;
  if(i<j)                        //交换元素1与元素2的位置
  {
   t=Date[i];
   Date[i]=Date[j];
   Date[j]=t;
  }
 }
 Date[left]=Date[i];                 //交换Date[left](起始值)与中间元素Date[i]位置
 Date[i]=temp;
 Sort(Date,left,i-1);                //排序i(也就是此时起始值所在)的左边部分
 Sort(Date,i+1,right);               //排序i(也就是此时起始值所在)的右边部分
 return;
}

5.快速排序接口：

void SortDate(int Date[],int n)          //快速排序接口
{
 Sort(Date,1,n);
 printf("\n排序结果为:");
 TraverseDate(Date,n);
 return;
}

6.主函数：

int main()                                //主函数
{
 int n,Date[MAXSIZE];
 InitDate(Date,n);
 SortDate(Date,n);
 return 0;
}

7.运行结果：
在这里插入图片描述

尾言：
看完这<撕烂数据爆锤算法：内排序之交换算法>，是否还意犹未尽，那么就跟着我进入推荐环节吧（恬不知耻的我，死活都要自荐一翻，哈哈）。
小小推荐：
撕烂数据爆锤算法系列：
撕烂数据爆锤算法：内排序之插入算法
撕烂数据爆锤算法：循环链表
撕烂数据爆锤算法：单链表

感谢浏览，你们的支持就是我的动力，下次再见喽~~~

.最小生成树
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
撕烂数据爆锤算法：内排序之插入算法
qq_45714923的博客
05-10 338
前言： 嗐，很久没更新博客了，因为这几个月都在搞学习（大部分时间都在闯王者峡谷，哈哈），最近刚过了一遍数据结构与算法，所以想着趁热打铁，把一些重要的、基础的知识点整理起来，等以后复习的时候能够派上用场。于是为大家带来了撕烂数据爆锤算法系列（听起来很牛批，实际上菜的一批，哈哈)。当然作为毅力超群的我，当然会持续更新的啦。若有啥不足之处，欢迎大佬们喷一喷（手下留情啊）。最后，希望我的总结能对你们有所帮助，这将是我的荣幸！ 同是天涯码字猿， 共勉，共勉~~~ 正文： 一、基础概述： 如果N=1，则序列有序。如
撕烂数据爆锤算法：LeetCode刷题记录之链表
qq_45714923的博客
08-05 239
LeetCode刷题总结——链表前言正文一、第一题二、第二题三、第三题尾言小小推荐 前言   这里记录了有关链表知识的我不会解的和我认为值得收藏的编程题目及题解，主要是为了提高自己的编程能力。希望自己勤加练习，越做越熟练。嗯，都是用C/C++实现的。 正文 一、第一题  题目描述：   判断给定的链表中是否有环  扩展：   你能给出不利用额外空间的解法么？  题目代码： /** * Definition for
撕烂数据爆锤算法：广度、深度优先搜索例题之炸弹人
qq_45714923的博客
07-17 436
啰啰嗦嗦 理解知识最有效的方式之一就是多刷题，在解题的过程中我们可能会更加容易记忆和理解知识点，我们能够了解到其在题目中的具体运用方式。通过实打实的上手编程，带来的好处不言而喻。如果你仅限于从书中看懂或者从教学视频中听懂，而不亲手去实现它，这些知识很难被真正的掌握。当你一字一字地完整地码下来时，你会发现其实有很多错误是你平时学习的时候注意不到的。只有经过大量实战练习，你才会对自己的不足有所了解。当然，小编也是刚学习不久，若有什么不足之处，还望各位大佬海涵啦！ 题干 炸弹人小鑫拥有一个威力巨大的炸弹，它能炸
爆锤数据结构（期末复习笔记）
上山打老虎的博客
11-24 5175
目录写在前面机考篇大致内容例题无向图求割点三叉霍夫曼笔试篇 写在前面 笔者按去年实际考试内容，回忆并编写本博客。建议大家收藏，如对考试有帮助，记得回来丢个赞。如果对部分内容有疑问可以直接留言。 机考篇 大致内容 数据结构期末机考大致有5道题，难度由浅入深，根据去年实际体验，大致人均AC2~3题。 例题 这部分的两道题大概是去年机考的第四第五题（前面题记不清了），凭着回忆把题目重新写了下，又做了一遍，自己敲了标程。 无向图求割点 按输入顺序输出无向图的所有割点。（割点：在一个无向图中，如果删除某个顶点以及
Java数据结构及算法实例：选择排序 Selection Sort
09-03
虽然选择排序的交换操作次数较少，但比较次数仍然为O(N)，因此在处理大量数据时，效率不如其他更高级的排序算法如快速排序、归并排序等。然而，选择排序的一个优点是它对原始数据的顺序不敏感，即无论输入数据是否...
数组与排序算法：从基础到进阶
07-03
《数组与排序算法：从基础到进阶》是一本全面深入探讨数组基础知识和各种排序算法的实用指南。本书旨在为读者提供一个系统化的学习路径，从数组的基本概念开始，逐步深入到复杂的排序算法，帮助读者建立扎实的算法...
二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip
07-01
二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip 二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip 二叉树建立遍历冒泡排序快速排序算法：C语言...
数据与算法课程：9 排序.pdf
06-15
数据与算法课程中的第九讲主要聚焦于排序这一关键主题，它是计算机科学中不可或缺的一部分，大约占据了数据处理操作的25%。排序的目标是将杂乱无章的数据元素按照一定的规则，如递增或递减顺序，进行排列。在这个...
图解大顶堆的构建、排序过程
sagima_sdu的博客
08-12 499
开始，
排序算法之桶排序
rd_w_csdn的博客
08-12 825
桶排序（bucket sort）是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
备战秋招60天算法挑战，Day17
溜达虎的博客
08-13 367
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 671
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
代码随想录算法训练营第十七天
b1ankwall的博客
08-16 578
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
数据结构——排序（4）：归并排序+计数排序
2301_81888634的博客
08-16 631
至此我们学习了顺序表、链表、栈、队列、二叉树、排序，初阶数据结构完结~撒花！我们C++见！！
【Python】生成二维迷宫的算法
最新发布
HarryXYC的博客
08-16 170
基于Pygame和PIL的迷宫生成器
算法之递归和迭代
qq_28576837的博客
08-16 131
斐波那契数列（Fibonacci sequence），又称黄金分割数列，这个数列最早是由印度数学家提出来的。如果是用迭代，那么就是用循环从前往后计算，前两个数是固定的，先根据前两个数可以计算出第三个数，然后把第三个数和第二个数再赋值给之前的变量，再相加即可。使用递归时，如果要计算第100个数，那么要先直到第99和第98个，要知道第99个和第98个，就要分别进行递归，直到最后一层，再返回递归回来进行计算。这个序列的前几项是这样的：0,1,1,2,3,5,8,13,21,34,⋯。自然，用递归函数最容易实现。
【LeetCode】字母异位词分组
LittleFishC的博客
08-14 242
使用unordered_map（哈希表）将排序后的字符串映射到一个字符串列表中。哈希表的键是排序后的字符串，值是所有与该键对应的原始字符串组成的列表。输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]给你一个字符串数组，请你将字母异位词组合在一起。字母异位词是由重新排列源单词的所有字母得到的一个新单词。输出: [[“a”]]输出: [[“”]]
二分查找5️⃣-山脉数组的封顶索引
2202_75331338的博客
08-15 227
对于山峰来说，我们会发现封顶的值是最大，对于封顶左边来说，后一个数比前一个数大；◦ 如果 mid 位置呈现上升趋势，说明我们接下来要在 [mid + 1, right] 区间继续搜索；◦ 如果 mid 位置呈现下降趋势，说明我们接下来要在 [left, mid - 1] 区间搜索；◦ 因此，我们可以遍历数组内的每一个元素，找到某一个元素比两边的元素大即可。本题的数组不是有序数组，但我们依然可以使用二分查找，原因是因为我们发现了。输入：arr = [0,2,1,0]◦ 峰顶的特点：比两侧的元素都要大。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值