排序算法——直接插入排序和希尔排序

已于 2022-07-24 23:29:33 修改
阅读量548 收藏 26
点赞数 31
分类专栏： 基础数据结构 文章标签： 排序算法 算法 数据结构
于 2022-07-24 22:58:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57154303/article/details/125964534
版权

排序算法——直接插入排序和希尔排序

文章目录

1直接插入排序

1.1直接插入排序的思想

  • 每一趟将待续序列中的第一个值，插入到已经排列好的序列中，从而得到一个元素个数加一的新有序序列，就像打牌摸牌时候将新揭来的牌排序一样，按顺序插入到合适位置即可。
    在这里插入图片描述
  • 如果是降序排列：对于已经排列好的有序序列来说，从右往左，依次将值和待插入值进行比较，如果小于待排序值，就向右挪动一位，接着进行比较，直到找到一个大于或等于待插入值的数值或者触底，这时将待排序数值插入进来即可。
  • 在这里插入图片描述

1.2 排序过程

在这里插入图片描述

1.3 源代码

void Insert_Sort(int *arr, int len)
{
	//for(int i=0; i<len-1; i++)
	for(int i=1; i<len; i++)//控制需要跑多少趟len-1  
	{
		int tmp = arr[i];
		int j;
		for(j=i-1; j>=0; j--)//控制在已排序好序列中，找到待排序值 可以插入的合适的位置
		{
			if(arr[j] > tmp)
			{
				arr[j+1] = arr[j];
			}
			else//arr[j] <= tmp
			{
				//arr[j+1] = tmp; //找到一个小于或者等于tmp的值
				break;
			}
		}
		arr[j+1] = tmp; //触底之后的处理规则
	}
}

1.4直接插入法性能分析

  • 时间复杂度：O(n^2)
  • 空间复杂度O(1)
  • 稳定性：稳定
    在这里插入图片描述

1.5 直接插入法的优缺点

  • 优点：
    1.如果n较小，那么n^2也不会太大（当数据量较小时，可以直接使用直接插入法）
    2.较为稳定
  • 缺点
    时间复杂度过高（n^2）

1.6 思考（直接插入法的优化）

  • 如果数据量特别少，或者数据量较为有序，直接插入法效率极高，关键点就是如何让待排序列数量降低
  • 下面的希尔排序就是直接插入法的优化

2.希尔排序

  • 希尔排序是第一个时间复杂度打破n^2的算法

2.1希尔排序的思想

关键点就是如何让待排序序列数量降低

  • 解决方案：分割待排序序列，将其分割成很多子序列

假设有15个数字

分割方法1：从前向后33均分成5组（没有变的更加有序）
在这里插入图片描述

分割方法2：跳跃分割，分割成5组，一个组三个数，每个值之间距离三个数

在这里插入图片描述

2.2希尔排序的增量数组

希尔排序也叫最小增量排序，有一个最重要的标志——增量数组

  • 增量数组一般取 [5,3,1],数组数据从小到大排列，尽可能里面的值互素，并且==最后一个增量一定是1 ==（只有最后以增量为1排序一次，才能保证数据全部有序）
    在这里插入图片描述
    在这里插入图片描述

2.3 希尔排序的过程

在这里插入图片描述

2.4 希尔排序的性能分析

  • 希尔排序是基于直接插入排序的优点进行优化的

在这里插入图片描述

  • 时间复杂度：可以认为O(n^1.3 ~ n^1.7)，比较有争议没有明确的答案，一般认为在n ^ 1.6左右
  • 空间复杂度：O(1)
  • 稳定性：不稳定
  • 希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小， 插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比O(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

2.5 希尔排序源代码

void Shell(int *arr, int len, int gap)
{
	//假设gap=5，则认为前5个值已经有序，则让i直接指向第一个组的第二个值下标
	for(int i=gap; i<len; i++)//这里修改了
	{
		int tmp = arr[i];
		int j;
		for(j=i-gap; j>=0; j=j-gap)//这里修改了
		{
			if(arr[j] > tmp)
			{
				arr[j+gap] = arr[j];//这里修改了
			}
			else
			{
				break;
			}
		}
		arr[j+gap] = tmp; //这里修改了
	}
}

//希尔排序 时间复杂度可以认为O(n^1.3 ~ n^1.7)  空间复杂度O(1) 稳定性：不稳定
void Shell_Sort(int *arr, int len)
{
	int gap[] = {5,3,1};
	for(int i=0; i<sizeof(gap)/sizeof(gap[0]); i++)
	{
		Shell(arr, len, gap[i]);
	}
}

3.测试结果

int main()
{
	int arr[] = { -43,57,-71,47,3,30,-85,6,60,-59,0,-46,-40,-73,53,68,-82,-54,88,73,20,-89,-22,39,55,-26,95,-87,-57,-86,28,-37,43,-27,-24,-88,-35,82,-3,39,-85,-46,37,45,-24,35,-49,-27,-96,89,87,-62,85,-44,64,78,14,59,-55,-10,0,98,50,-75,11,97,-72,85,-68,-76,44,-12,76,76,8,-75,-64,-57,29,-24,27,-3,-45,-87,48,10,-13,17,94,-85,11,-42,-98,89,97,-66,66,88,-89,90,-68,-62,-21,2,37,-15,-13,-24,-23,3,-58,-9,-71,0,37,-28,22,52,-34,24,-8,-20,29,-98,55,4,36,-3,-9,98,-26,17,82,23,56,54,53,51,-50,0,-15,-50,84,-90,90,72,-46,-96,-56,-76,-32,-8,-69,-32,-41,-56,69,-40,-25,-44,49,-62,36,-55,41,36,-60,90,37,13,87,66,-40,40,-35,-11,31,-45,-62,92,96,8,-4,-50,87,-17,-64,95,-89,68,-51,-40,-85,15,50,-15,0,-67,-55,45,11,-80,-45,-10,-8,90,-23,-41,80,19,29,7 };
	Insert_sort(arr, sizeof(arr) / sizeof(int));
	shell_sort(arr, sizeof(arr) / sizeof(int));
	show(arr, sizeof(arr) / sizeof(int));
	return 0;
}

运行结果如下：
在这里插入图片描述

4.总结

希尔排序是直接插入排序的优化，两者关系十分密切，但是要记住希尔排序不稳定，直接插入排序是稳定的

  • ✨ 原 创 不 易 ， 还 希 望 各 位 大 佬 支 持 一 下
  • 👍 点 赞 ， 你 的 认 可 是 我 创 作 的 动 力 ！
  • ⭐️ 收 藏 ， 你 的 青 睐 是 我 努 力 的 方 向 ！
  • ✏️ 评 论 ， 你 的 意 见 是 我 进 步 的 财 富 ！
我是大学渣
关注
  • 31
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 33
    评论
专栏目录
排序算法---插入排序&希尔排序
everthing willl be ok
04-02 162
一、直接插入排序 直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。 在讲解直接插入排序之前，先让我们脑补一下我们打牌的过程。 先拿一张5在手里， 摸到一张4，比5小，插到5前面， 摸到一张6，比5大，插到5后面， 摸到一张8，比6大，插到6后面， 这就是一个关于直接...
排序算法之直接插入排序、二分插入排序和希尔排序
春风来不来的博客
06-25 1088
下列所有排序都默认是升序，从小到大。 插入排序 有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部
各种排序 冒泡 快速 堆 希尔 基数等九种
05-28
#include #include #define MAXSIZE 10 #define MAX_BIT 8 // 关键字最大位数 #define RADIX 10 // 关键字基数 ，此时是十进制整数的基数 #define MAX_SPACE 8 // 分配的存储空间的大小 typedef char KeyType;// define the keyType is the int typedef int InfoType; typedef struct { KeyType key; InfoType otherinfo;// 其他数据项 }RedType; typedef struct { RedType r[MAXSIZE+1];// r[0] is for the guard int length; }SqList; // Radix Sorting struct SLNode { KeyType key[MAX_BIT]; // the key InfoType otheritems; // 其他数据项 int next; //下一个节点的下标位置 }; // 静态链表中的节点类型 struct SList { struct SLNode r[MAX_SPACE]; // 静态链表中各节点，其中r[0]为头结点 int keybit; // 关键字的位数 int recnum; // 静态链表中记录的个数 }; // 静态链表的类型 // 函数声明 void Insert_Sort ( SqList &L);// the Straight Insertion Sort void BInsert_Sort(SqList &L);// the Binary Insertion Sort void Shell_Sort(SqList &L);// Shell Sort int Partition ( SqList &L,int low,int high ); void Quick_Sort(SqList &L,int low,int high);// Quick Sort void Bubble_Sort(SqList &L); void Select_Sort( SqList &L); void Heap_Sort(SqList &L); void Merge_Sort(SqList &L);// Merging Sort void display(SqList L);// 输出显示 void main() { SqList L; L.length=MAXSIZE; int i,msg; char ch; do { system("cls"); // 清屏 cout<<"please input the data:"<<endl; for (i=1;i>L.r[i].key; } cout<<"1、直接插入排序"<<"\t"; cout<<"2、折半插入排序"<<endl; cout<<"3、希尔排序"<<"\t"; cout<<"4、冒泡排序"<<endl; cout<<"5、快速排序"<<"\t"; cout<<"6、直接选择排序"<<endl; cout<<"7、堆排序"<<"\t"; cout<<"8、归并排序"<<endl; cout<>msg; switch (msg) { case 1: Insert_Sort(L); display(L); break; case 2: BInsert_Sort(L); display(L); break; case 3: Shell_Sort(L); display(L); break; case 4: Bubble_Sort(L); display(L); break; case 5: Quick_Sort(L,1,L.length); display(L); break; case 6: Select_Sort(L); display(L); break; case 7: Heap_Sort(L); display(L); break; case 8: Merge_Sort(L); display(L); break; default: cout<<"please input 1至 8"<>msg; } cout<>ch; } while(ch=='Y'||ch=='y'); } // 直接插入排序 void Insert_Sort(SqList &L) { int i,j; for (i=2; i<=L.length; i++) { if (L.r[i].key<L.r[i-1].key)// if '<' insert the sort order { L.r[0] = L.r[i]; // see as a guard L.r[i]=L.r[i-1]; for ( j=i-2; L.r[0].key<L.r[j].key; j--)// try to find the right position { L.r[j+1]=L.r[j];// back } L.r[j+1]=L.r[0]; } } } //折半插入排序 void BInsert_Sort(SqList &L) { int i,j,low,high; for (i=2;i<=L.length; ++i) { L.r[0] = L.r[i];// access the SqList for the time being low=1; high=i-1; while ( low<=high ) { int m=( low+high )/2; if (L.r[0].key =high+1; --j) { L.r[j+1]=L.r[j]; } L.r[high+1] = L.r[0]; // insert it } } // 希尔排序 void Shell_Sort(SqList &L)// the ascending order { int d = L.length,i; while ( d>=1 ) { d=d/2; for (i = 1+d; i<=L.length; i++) if (L.r[i].key 0&&L.r[0].key <L.r[j].key; j-=d) { L.r[j+d]=L.r[j];// 将r[j]之前所有大于它的元素都后移 } L.r[j+d]=L.r[0];// 将r[i] 插入到正确位置 } } } // quick sort 快速排序 void Quick_Sort(SqList &L,int low,int high) { int pivotloc; if (low<high) { pivotloc=Partition(L,low,high);// One order divides into two Quick_Sort(L,low,pivotloc-1); Quick_Sort(L,pivotloc+1,high); } } int Partition ( SqList &L,int low,int high ) { // 对L.r[low]——L.r[high] 子序列进行一趟快速排序，返回分界线位置，即枢轴 L.r[0]=L.r[low]; int pivotkey=L.r[0].key; while (low<high ) { while (low=pivotkey) { high--; } L.r[low]=L.r[high];// while(False) while (low<high && L.r[low].key<=pivotkey) { low++; } L.r[high]=L.r[low];// while (false ) } L.r[low] =L.r[0]; return low; } void Bubble_Sort(SqList &L)// it's coming up 冒泡排序（上浮） { int i,j; int flag=1; // to flag the record whethe needs to exchange ,1 is need. i=1; while ( i<=L.length && flag==1) { flag=0; for (j=1; jL.r[j+1].key) { L.r[0]=L.r[j+1]; L.r[j+1]=L.r[j]; L.r[j]=L.r[0]; flag=1; } } i++; } } void Select_Sort( SqList &L)// 直接选择排序 { int i,j,min; for (i=1; i<= L.length; i++) { min=i; for (j=i+1; jL.r[j].key) { min=j; } } if (min!=i) { L.r[0]=L.r[i]; L.r[i]=L.r[min]; L.r[min]=L.r[0]; } } } void Heap_Adjust(SqList &L,int s, int m)// 堆调整 { // 在L.r[s...m]中记录的关键字除L.r[s].key 之外均满足堆的定义，本函数调整L.r[s]的关键字，使L.r[s...m]成为一个大顶堆 int j; L.r[0]=L.r[s]; for ( j=2*s; j<=m; j*=2 ) { // 沿key较大的孩子节点向下筛选 if (j<m &&L.r[j].key=L.r[j].key) { break; } else// 将三者中的最大值放入到根节点的位置，并用s记录此位置 { L.r[s]=L.r[j]; s=j; } } L.r[s]=L.r[0]; } void Heap_Sort(SqList &L) // 堆排序 { int i; for (i=L.length/2; i>0; i--)// build the heap { Heap_Adjust(L,i,L.length); } for (i=L.length; i>1; i--) { L.r[0]=L.r[i];// 将 堆顶记录和当前未经排序子队列（1——i）中 的 最后一个记录 交换 L.r[i]=L.r[1]; L.r[1]=L.r[0]; Heap_Adjust(L,1,i-1);// 将（1——i-1）重新调整为一个大堆 } } void Merge( RedType S[], RedType T[], int i,int m,int n) { // 将有序的S前一部分和后一部分归并为有序的T int j,k; for (j=m+1,k=i;i<=m && j<=n; ++k)// 将S中记录由小到大并入到T中 { if (S[i].key<=S[j].key) { T[k]=S[i++]; } else T[k] = S[j++]; } while(i<=m)// 将剩余的S[i...m]复制到T中 T[k++]=S[i++]; while(j<=n)// 将剩余的S[j...n]复制到T T[k++]=S[j++]; } void MSort(RedType S[],RedType T1[],int s,int t ) { // 将S[s...t]归并为T[s...t]MAXSIZE+1 RedType T2[MAXSIZE+1]; int m; if ( s==t )// 只有一个记录 { T1[s] = S[s]; } else { m=(s+t)/2; // 将S 分为2份 MSort(S,T2,s,m);// 将S归并为有序的T2 MSort(S,T2,m+1,t); // 将S归并为有序的T2 Merge(T2, T1,s,m,t); // 将T1和T2归并到T1中 } } void Merge_Sort(SqList &L)// 归并排序 { // 对顺序表L作归并排序 MSort(L.r,L.r,1,L.length); } // for Radix Sorting // 基数排序中一趟分配的算法 void Distribute (SLNode *r,int i,int f[RADIX],int e[RADIX]) { // 静态链表中的r域中记录已按key[0]——key[i-1]有序 // 本算法按关键字的第i位建立RADIX个链队列，使在同一链队列中关键字的第i位的数值相等； // f、e均为长度为RADIX的指针数组,分别指向各链队列的第一条和最后一条记录 int j,p; for (j=0; j<RADIX; j++) { f[j]=e[j]=0;// 各链队列初始化为空 } for (p=r[0].next; p; p=r[p].next ) { // p总是指向静态链表中的当前节点 j=r[p].key[i]; if (!f[j]) { f[j]=p; } else r[e[j]].next=p; e[j]=p; // 根据r[p]的关键字的第i位的值，将其归入相应的链队列，并修改相应的f、e指针 } } // 基数排序中的一趟收集的算法 void collect ( SLNode *r,int i,int f[RADIX],int e[RADIX] ) { // 本算法按关键字的第i位自小到大地将指针f[0]——f[RADIX-1] 所指向的各 链队列依次 链接成一个静态链表 int j; for ( j=0; !f[j]; j++) { r[0].next=f[j];// r[0].next 指向第一个非空链队列中的第一个节点 } int temp=e[j]; while ( j<RADIX ) { for ( j++; j<RADIX-1 && !f[j]; j++) // 找下一个非空链队列 { if (f[j]) // 链接二个队列 { r[temp].next=f[j]; temp=e[j]; } } } r[temp].next=0; // 将最后一个节点的next域设置为空，完成一趟收集 } void Radix_Sort(SList &L)// 基数排序(链式) { // 定义静态链表L，对L进行基数排序（L.r[0] 为头结点） int i; int e[RADIX],f[RADIX]; for (i=0; i<L.recnum; i++) { L.r[i].next=i+1;// 定义各节点的next 域，使之成为一个前后相连的静态链表 } L.r[L.recnum].next=0;// 定义最后一个结点的next域，使整个静态链表有效终止 for (i=0; i<L.keybit; i++) { // 按最低位优先依次对各关键字进行分配和收集 Distribute( L.r, i, f, e);// 第i躺分配 collect(L.r, i, f, e); // 第i躺收集 } } void display(SqList L) { cout<<"after the sort:"<<endl; for (int i=1;i<=L.length; i++ ) { cout<<L.r[i].key<<"\t"; if (i%5==0 ) { cout<<"\n"; } } }
java算法——希尔排序
06-13
按下标的一定增量分组，对每组使用直接插入算法排序；随着增量 * 逐渐减少，每组包含的关键字越来越多，当增量减至1时，整个文件恰 * 好被分成一组，算法便终止。 * 8,9,1,7,2,3,5,4,6,0 * //初始增量 gap=length/2=5,向下取整， 分为5组，下标[i]和[i+5]进行比较 * 3,5,1,6,0,8,9,4,7,2 * //缩小增量 gap=5/2=2，分为2组,下标[i],[i+2],[i+4],[i+6],[i+8] * 0,2,1,4,3,5,7,6,9,8 * //在缩小增量gap=2/2=1,分为1组 * 0,1,2,3,4,5,6,7,8,9
直接插入排序、希尔排序、选择排序、快速排序
06-03
本实验含有四部分内容——直接插入排序、希尔排序、选择排序、快速排序，在上述内容的基础上，将所有排序算法整合在一个程序中。学生可参考教材中的伪代码。鼓励学生自创新思路，新算法。
内部排序算法性能比较———c++
07-29
五种内部排序算法性能比较， 1.直接插入排序算法。 2.简单选择排序。 3.希尔排序。 4.归并排序。5.快速排序。分别对交换次数，比较次数，移动次数，时长，时间复杂度进行性能比较。给出十万到百万级数据量的统计结果。以c语言控制台画出的表格形式呈现。
各种主要排序算法的C++实现
01-21
包含了所有主要排序算法： 1 插入类——插入排序（链接法，普通数组法，二分插入法）、希尔排序 2 选择类——直接选择排序、堆排序 3 分配类——基数排序 4 交换类——冒泡排序、快速排序 5 归并排序
排序算法 —— 希尔排序（图文超详细）
热门推荐
超烦豆先森
10-29 5万+
java 实现希尔排序
希尔排序详解(Shell Sort)
武梓龙 廊坊师范学院信息技术提高班 十七期
05-29 1万+
直接插入排序是由两层嵌套循环组成的。外层循环标识并决定待比较的数值。内层循环为待比较数值确定其最终位置。直接插入排序将待比较的数值与它的前一个数值进行比较，所以外层循环是从第二个数值开始的。当前一数值比待比较数值大的情况下继续循环比较，直到找到比待比较数值小的并将待比较数值置入其后一位置，结束该次循环。
“希尔”排序
weixin_70056514的博客
04-04 5736
希尔排序法又称缩小增量法。 希尔排序法的基本思想是：先选定一个整数gap，把待排序文件中所有元素分成gap组，即所有距离为gap的分在同一组内，并对每一组内的元素进行直接插入排序（本质是进行预排序，使数组更接近有序，目的是使最后一次直接插入排序提高效率）。然后取gap=gap/2或者gap=gap/3+1重复上述分组和排序的工作。当gap到达1时，数组是已经接近有序的，而对于直接插入排序在顺序有序或者接近顺序有序的数组内的时间复杂度为O(N)，效率极高。
数据结构与算法之希尔排序
努力让自己发光，对的人才能迎着光而来
09-12 2万+
希尔排序概念 代码实现 时间复杂度
关于常见排序的一些细节的理解
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
01-15 1118
关于一些继承排序的异或答疑
数据结构课程设计五——排序算法综合分析.doc
06-03
该资源涵盖了多种排序算法，包括直接插入排序、希尔排序、快速排序、冒泡排序、堆排序和归并法排序等。 首先，资源定义了一个排序表的结构体 SqList，包括一个整型数组 elemword 来存储数据元素的关键字，一个整型...
产生N个随机数，使用插入排序，对随机数进行排序
apqop的博客
08-11 1949
#include <time.h> #include <stdio.h> #include <stdlib.h> #define N 100 //数据个数 #define U 1000 //数据范围 int data[N];//存放数据的数组 int comp_count = 0; // 数据比较次数 int swap_count = 0; // 数据交换次数 //添加随机数到数组 void add_data(int *data) { srand(time(N..
【希尔排序——ShellSort】 不稳定排序
piano_diano的博客
11-20 374
希尔排序是插入排序的改进版本（插入排序类） 核心思想：原本插入排序是对一整个数组的数据进行逐个比较的，而希尔排序是将整个数组划分为若干部分，然后分别进行插入排序，形成基本有序的序列（小的基本在前面，大的基本在后面），最后对整个数组再用一次插入排序。 希尔排序的时间复杂度：O(n) 例如： 以下是对数组进行间隔增量increment为2的分组，然后分别进行插入排序，最后再进行一次插入排序 ...
直接插入排序
qq_45946710的博客
12-12 333
直接插入排序 1.基本思想 将待排数据元素插入到已经排好序的有数组中，从而得到一个新的有序数组。 对于一个具有n个数据元素的数组，进行直接插入排序具体过程是： （1）将第1个数组元素看作一个已经排好序的有序数组。 （2）将第i(2 <= i <= n)个数据元素的值依次与其前面数据元素的值进行比较，将所有值大于i的值的数据元素依次向后移动一个位置，直到某个数据元素j的值小于或等于i的值...
直接插入排序和希尔排序的实现
m0_62229058的博客
04-15 128
关于直接插排和希尔排序的分析与实现
理解希尔排序的不稳定性
xiaolangmin的博客
03-13 1万+
希尔排序是插入排序的改进 先按一定的间隔将待排序的序列分组，每组进行插入排序 缩小间隔 希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小， 插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比O(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同...
排序算法——希尔排序
XXXTENTAC1ON的博客
11-17 2290
希尔排序什么是希尔排序为什么不直接使用插入排序希尔排序代码实现 什么是希尔排序 希尔排序也叫做：缩小增量排序。 分组（分组的组数需要循环递减，直到减为1）排序。 先将待排序序列分成若干组，然后使用直接插入排序在组内排序。循环着将分组数减小，执行以上过程。直到分组减为1. 所有的分组数都互质。 分组可为任意数字，且每次分组数都比上一次分组要小，直至分组数为1。 为什么不直接使用插入排序 相比较插入排序，希尔排序输入直接插入排序的一种，但是在两种算法的比较上 希尔排序: 就是直接插入排序的优化， 数据
排序算法——冒泡排序（c语言）
最新发布
09-14
冒泡排序是一种简单的排序算法，它重复地遍历待排序的元素，比较相邻元素的大小，如果顺序错误就交换它们，直到没有需要交换的元素为止。下面是冒泡排序的C语言实现： ```c void bubbleSort(int arr[], int n) { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 33
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值