直接插入排序（顺序存储、链式存储），折半插入排序（顺序存储），希尔排序（顺序存储）

最新推荐文章于 2024-08-08 14:24:19 发布
最新推荐文章于 2024-08-08 14:24:19 发布
阅读量4.8k 收藏 66
点赞数 14
分类专栏： 顺序表 文章标签： 链表 数据结构 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45821218/article/details/109775471
版权

直接插入排序（顺序存储、链式存储），折半插入排序（顺序存储），希尔排序（顺序存储）

插入排序

直接插入排序
  ​将元素插入L[i]插入到已有序的子序列L[i-1]中。其基本思想是每次将一个待排序的记录按其关键字大小插入到前面已排好序的子序列中，直到全部记录插入完成。基本步骤如下：
1）查找出L[i]在L[1]~L[i-1]中要插入的位置K；
2）将L[i]的值复制到L[0]；
3）将L[K]~L[i-1]中的所有元素依次后移一个位置；
4）将L[0]的值复制到L[K]；
空间复杂度：O(1)
最好时间复杂度（全部有序）：O(n)
最坏时间复杂度（全部逆序）：O(n^2)
平均时间复杂度：O(n2)
算法稳定性：稳定

折半插入排序
  ​顺序存储的线性表可以用折半查找来实现。用折半查找来确定待插入的位置后，就可以统一的向后移动元素。基本步骤如下：
1）当 low>high 时折半查找停止，应将 [low, i-1] 内的元素全部右移，并将 A[0] 复制到 low 所指位置；
2）当 A[mid]==A[0] 时，为了保证算法的“稳定性”，应继续在 mid 所指位置右边寻找插⼊位置。
空间复杂度：O(1)
时间复杂度：移动元素的次数变少了，但是关键字对比的次数依然是O(n2) 数量级，整体来看时间复杂度依然是O(n^2)
算法稳定性：不稳定

顺序存储结构

/*
Project:InsertSort(直接插入排序)
Data:2020/11/18
Author:F&S&L
InitList(SqList &L) 参数：顺序表L
CreateList(SqList &L,int n) 参数：顺序表L，顺序表中元素个数n
InitList(SqList &L) 参数：顺序表L
Create(SqList &L) 参数：顺序表L
InsertSort(SqList &L) 参数：顺序表L
HalfInsertSort(SqList &L) 参数：顺序表L
*/ 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#define MaxSize 100
#define ElemType int
#define Status int
using namespace std;

//顺序表数据结构
typedef struct
{
	ElemType data[MaxSize];
	int length;
} SqList;
//初始化顺序表函数，构造一个空的顺序表
Status InitList(SqList &L)
{
 	memset(L.data,0,sizeof(L));
 	L.length=0;
 	return 0;
} 
//打印输出顺序表
void PrintList(SqList L)
{
	for(int i=1;i<L.length+1;i++)
	{
		printf("%d ",L.data[i]);
	}
	printf("\n");
} 
//初始化顺序表函数
bool CreateList(SqList &L,int n)
{
	if(n<0||n>MaxSize)false;
	for(int i=1;i<n+1;i++)
	{
		scanf("%d",&L.data[i]);
		L.length++;
	}
	return true;
} 
//创建顺序表函数
void Create(SqList &L)
{
	int n;
	bool flag;
	printf("请输入要创建的顺序表长度（>1）:");
	scanf("%d",&n);
	printf("请输入%d个数（空格隔开）：",n);
	flag=CreateList(L,n);
	if(flag)
	{
		printf("创建成功后的元素：");
		PrintList(L);
	}
	else printf("输入长度非法！！！\n");
 } 
//直接插入排序 ，升序排序 
void InsertSort(SqList &L)
{
	int i,j;
	for (i=2;i<L.length+1;i++)
	{
		if(L.data[i]<L.data[i-1])
		{
			L.data[0]=L.data[i];
			L.data[i]=L.data[i-1];
			for(j=i-2;L.data[0]<L.data[j];j--)
			{
				L.data[j+1]=L.data[j];
			}
			L.data[j+1]=L.data[0];
		}
	}
	printf("直接插入排序后的元素：") ;
	PrintList(L);
} 
//折半插入排序
void HalfInsertSort(SqList &L)
{
	int i,j,low,high,mid;
	for(i=2;i<L.length+1;i++)
	{
		L.data[0]=L.data[i];
		low=1;
		high=i-1;
		while(low<=high)
		{
			mid=(low+high)/2;
			if(L.data[mid]>L.data[0])high=mid-1;
			else low=mid+1;
		}
		for(j=i-1;j>=high+1;j--)
		{
			L.data[j+1]=L.data[j];
		 } 
		L.data[high+1]=L.data[0];
	}
	printf("折半插入排序后的元素：");
	PrintList(L); 
}
//主函数 
int main()
{
 	SqList L;
 	InitList(L);
 	Create(L);
 	InsertSort(L);
 	HalfInsertSort(L);
 }

在这里插入图片描述
链式存储结构

 /*
Project:LinkInsertSort(直接插入排序)
Data:2020/11/18
Author:F&S&L
InitList(LinkList &L) 参数：链表L
ListLength(LinkList L) 参数：链表L
InsertList(LinkList &L,ElemType e) 参数：链表L，待插入元素e
PrintList(LinkList L) 参数：链表L
Sort(LinkList &L) 参数：链表L
*/ 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
#define Status int
#define ElemType int

//单链表数据结构 
typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;
//初始化一个带头结点的空链表 
Status InitList(LinkList &L) 
{
	L=new LNode;
	L->next=NULL;
	return 1;
}
//获取单链表长度，头结点无数据，不算
int ListLength(LinkList L)
{
	LinkList p=L;
	int sum=0;
	while(p)
	{
		sum++;
		p=p->next;
	}
	return sum-1;
}
// 按升序插入函数 
bool InsertList(LinkList &L,ElemType e)
{
	LNode* s;
	LinkList r=L,p=L->next;
	s=new LNode;
	s->data=e;
	while(p)              //当结点p不为空 
	{
		if(p->data<e)
		{
			r=r->next;
			p=p->next;
		}
		else
		{
			s->next=p;
			r->next=s;
			break; 
		}
	}
	s->next=p;
	r->next=s;
	return true;
}
//打印输出函数 
void PrintList(LinkList L)
{
	LinkList p=L->next;
	if(ListLength(L))
	{
		while(p)
		{
			printf("%d ",p->data);
			p=p->next;
		}
		printf("\n");
	}
	else
	{
		printf("当前单链表已空！！！\n");
	}
 }
//排序实现函数 ，调用InsertList 
void Sort(LinkList &L)
{
	int flag;
	ElemType e;
	printf("请输入要插入的元素:");
	scanf("%d",&e);
	flag=InsertList(L,e);
	if(flag)
	{
		printf("排序后的元素：");
		PrintList(L);
	 } 
}
//菜单 
void menu()
{
	printf("***************1.插入           2.退出***************\n");
}
//主函数 
int main()
{
	LinkList L;
	InitList(L);
	int choice;
	while(1)
	{
		menu();
		printf("请输入菜单号：");
		scanf("%d",&choice);
		if(choice==2)
			break;
		switch(choice)
		{
			case 1:Sort(L);break;
			default:printf("输入错误！！！\n");
		}
	}
	return 0;
}

在这里插入图片描述
希尔排序
  ​先将待排序表分割成若干形如 L[i, i + d, i + 2d,…, i + kd] 的“特殊”子表，对各个子表分别进行直接插⼊排序。缩小增量d，重复上述过程，直到d=1为止。仅适用于顺序表，不适用于链表。
空间复杂度：O(1)
时间复杂度：和增量序列 d1, d2, d3… 的选择有关，目前无法用数学手段证明确切的时间复杂度 最坏时间复杂度为 O(n^2)，当n在某个范围内时，可达O(n1.3)
稳定性：不稳定

/*
Project:ShellSort(希尔排序)
Data:2020/11/18
Author:F&S&L
InitList(SqList &L) 参数：顺序表L
CreateList(SqList &L,int n) 参数：顺序表L，顺序表中元素个数n
PrintList(SqList L) 参数：顺序表L
Create(SqList &L) 参数：顺序表L
ShellSort(SqList &L) 参数：顺序表L
*/ 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#define MaxSize 100
#define ElemType int
#define Status int
using namespace std;

//顺序表数据结构
typedef struct
{
	ElemType data[MaxSize];
	int length;
}SqList;
//初始化顺序表函数，构造一个空的顺序表
Status InitList(SqList &L)
{
	memset(L.data,0,sizeof(L));
	L.length=0;
	return 1;
}
//初始化顺序表函数
bool CreateList(SqList &L,int n)
{
	if(n<0||n>MaxSize)false;
	printf("请依次输入%d个元素(空格隔开)：",n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&L.data[i]);
		L.length++;
	}
	return true;
}
//打印输出函数  
void PrintList(SqList L)
{
	for(int i=1;i<=L.length;i++)
	{
		printf("%d ",L.data[i]);
	}
	printf("\n"); 
}
//创建顺序表实现函数，调用 CreateList
void Create(SqList &L)
{
	int n;
	bool flag;
	printf("请输入要创建的顺序表长度：");
	scanf("%d",&n);
	flag=CreateList(L,n);
	if(flag)
	{
		printf("顺序表为：");
		PrintList(L);
	}
}
//希尔排序函数 
void ShellSort(SqList &L)
{
	int d,i,j;
	for(d=L.length/2;d>=1;d=d/2)
	{
		for(i=d+1;i<=L.length;i++)
		{
			if(L.data[i]<L.data[i-d])
			{
				L.data[0]=L.data[i];
				for(j=i-d;j>0&&L.data[j]>L.data[0];j-=d)L.data[j+d]=L.data[j];
				L.data[j+d]=L.data[0];
			}
		}
	}
	printf("希尔排序后的顺序表：");
	PrintList(L);	
}
//主函数 
int main()
{
	SqList L;
	InitList(L);
	Create(L);
	ShellSort(L);
}

在这里插入图片描述

F&S&L
关注
专栏目录
【排序】插入类排序—(折半)插入排序、希尔排序
bigsai
11-15 1万+
前言 在数据结构和算法中，排序是非常重要的一环，并且排序也是渗透编程的方方面面。 你或许在写一个sql的order by按照某组进行排序，又或者你在刷一道题时候、常常遇到贪心+自定义排序求解的思路题，或者变态的面试官让你手写快排，又或者是app的姓氏升降序列 - - - 然而在实际的排序算法的实现上，方式是众多的，不同算法对不同的特征数据的效率也是不同的，并且不同算法的时间复杂度、空间复杂度也不同...
排序——直接插入排序&&折半插入排序
weixin_47924016的博客
09-17 240
排序的基本概念数据结构稳定排序数据结构不稳定排序排序的种类排序的代码直接插入排序算法定义：将数据表调整为按关键字从小到大或从大到小的次序排列的过程排序的分类：增排序，减排序，内部排序，外部排序稳定排序：在排序过程中，如果关键字相同的两个元素的相对次序不变，则称为稳定的排序不稳定的排序：当相同的关键字的领先关系在排序过程中不发生变化者，则称所用的排序方法是不稳定的算法的稳定性：排序中两个元素相等，排序后位置不发生变化说明算法稳定，主要是对算法性质的描述，不能衡量算法优劣。
链式直接插入排序
博客
11-19 4879
2016年7月27日18:13:11 假设用户数据为:[22,6,17,8] 数据的存贮:pHead->[22]->[6]->[17]->[8] 链式存贮结构来保存待排序的数据,首先创建一个链表,将待排序的所有元素存贮到链表中去,将待排序的链表分为两部分 :有序子集和待排序子集,初始时有序子集中没有元素,令pSort->pNext = NULL,指针pCur指向待排序的
链式存储结构设计直接插入排序算法
qq_63378602的博客
12-06 1815
链式存储结构设计直接插入排序算法
【C++】在链式存储结构上设计简单选择排序和直接插入排序算法
最新发布
qq_53406271的博客
08-08 117
#include <iostream> using namespace std; typedef struct LNode{ int data; struct LNode* next; }LNode,*LinkList; void creatLinkList(LinkList &head,int len){//头插法 head=new LNode; head->next=NULL; for(int i=0;i<len;i++){ LinkList node=
C++ 链表直接插入排序
HarvestWu的博客
07-24 1724
#include&lt;bits/stdc++.h&gt; /* * Created by HarvestWu on 2018/07/24. */ using namespace std; typedef int ElemType; typedef int Status; typedef struct LNode { ElemType data; struct LNode *next...
链式存储实现直接插入排序算法
qq_42396029的博客
12-09 2500
void fun(linklist *&head){ if(headNULL||head->nextNULL) return ; linklist *p=head->next,*pre,*r; head->next=NULL; while§{ r=p->next; pre=head; if(p->datadata){ //如果小于头结点，则插到前面 p->next=head; head=p; }else{ while(pre->next!=NULL&amp
在链式结构上实现直接插入排序算法
weixin_45207880的博客
04-29 2642
void insertionSortList(ListNode &L) { if(L == null) return null; ListNode helper = (ListNode)malloc(sizeof(LNode));//构建新的辅助节点 ListNode pre = helper;//pre永远指向辅助节点 ListNode p = L;//p为工作节点,指向当前需要被插入节点 while(p!=null) {
吃透排序——直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、堆排序、归并排序、基数排序、外部排序（包括详细代码、排序过程图解，特别的注意事项）
weixin_43914272的博客
04-15 1403
吃透排序 有个各类算法可视化的网站很不戳，对算法的执行过程不清晰地可以lou一眼，可以加深对算法的理解 网站地址：https://www.cs.usfca.edu/~galles/visualization/Algorithms.html 以排序算法为例，点开网站找到排序模块 点击任何一个排序进入，然后就可以愉快看到各种排序的动画 先上思维导图 什么是算法的稳定性？ 文绉绉地说就是排序后，能使关键字相同的元素保持原来顺序中的相对位置不变 其实 ......
简单入门排序算法（直接插入排序，折半插入排序，希尔排序，冒泡排序，堆排序，归并排序）
binge_kong的博客
06-04 1482
预备知识（排序数组的创建20，100 ，500 个随机数进行排序） “Struct.h” #pragma once #include<iostream> #include<string> using namespace std; #include<cstdlib> //C语言标准库函数，包含随机函数rand（）srand(number); #include...
8.【史上最全内部排序算法】（直接插入、折半插入、希尔） +（冒泡、快速）+（简单选择、堆{含元素的增删}）+（归并）+ （基数）排序 + 对比总结
你说的白是什么白_
08-29 1832
【史上最全内部排序算法】（直接插入、折半插入、希尔） +（冒泡、快速）+（简单选择、堆{含元素的增删}）+（归并）+ （基数）排序 + 对比总结
设计在链式结构上实现直接插入排序算法。
热门推荐
刘珂的博客
10-14 1万+
void straightinsertsort(lklist *&head) { lklist *s,*p,*q; int t; if (head==0||head->next==0) return; else{ for(q=head,p=head->next;p!=0;p=q->next) { for(s=head;s!=q->next...
插入排序——直接插入排序
qq_43016111的博客
11-04 566
#include <stdio.h> #include <stdlib.h> /* 直接插入排序可以满足链式存储结构 每一轮的排序是可以造成局部有序 最好的时间复杂度为O(n)（前提条件：在基本有序的情况下） 最坏的时间复杂度为O(n²) 平均时间复杂度为O(n²) 是一个稳定的排序算法 */ 插入排序（耿国华） 下标0的位置作为哨兵 然后每一个遍历的元素与下标为零的元素做一次比较 void InsertSort(int r[],int length) { int ...
数据结构顺序存储折半插入排序
weixin_46106870的博客
06-03 580
截图： 代码： #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 #define OVERFLOW -1 #define OK 1 typedef int KeyType; typedef int InfoType; typedef struct { KeyType key; InfoType otherinfo; }ElemType; typedef struct
基于单链表实现直接插入排序算法详解
sunnyoldboy博客
09-26 8642
插入排序属于稳定排序法，是一种常用的排序算法。直接插入排序算法可以利用静态数组来实现，也可以使用静态链表或者单链表来实现。本文给出了直接插入算法的单链表实现方法。
【算法基础】-- 插入排序篇 - 直接插入排序
风一样的少年
11-14 1187
直接插入排序，是一种最简单也是最直观的插入排序算法。 其思想是： 假设数组由有序部分和无序部分组成，前半部分为有序，后半部分为无序，假设有表 L [ N ]，在某一状态存在如图所示： 则此时，需要将 L [ i ] 插入到数组的有序部分，算法为将 L [ 0 ] 设为哨兵，从 i - 1 开始向前逐个查询，并同时交换数组元素，最终找到插入位置时，将元素插入。 算法实现 /* 直接插入排序...
直接插入排序（链表）
xiaoyao_zhang的博客
09-20 1474
typedef struct LNode { int data; struct LNode *next; }LNode; void CreateLink(LNode *&h,char R[],int n) { int i; LNode *s,*t; h=(LNode*)malloc(sizeof(LNode)); h->next=NULL; t=h; for(i=0...
数据结构与算法——直接插入排序
CreativeBoy的专栏
06-11 3788
好久没写博客了，今天就简单总结下直接插入排序。 什么是直接插入排序？ 直接插入排序就是将某一个元素与顺序表中元素进行比较，然后插入到相应的位置，使整个顺序表处于有序状态。有关数据结构的书上都会用扑克牌进行比喻说明，就跟玩扑克一样，当我们拿到几张牌时，要想整理成一个顺子，我们通常的做法就是将小的牌，插到比他大的牌的前面。具体可以看看书，想一想，还是很容易理解的。 直接插入排序的思路：每次将一个
链表 直接插入排序法
weixin_44899829的博客
12-09 552
题目：输入 10 个已经从小到大排列好的数字，并用链表存储，再输入一个数，将其插入到 10 个数之间，使得新序列仍然满足从小到大的排序。（必须用链表) #include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct Node//定义结点 { int data; struct Nod...
数据结构精讲：顺序表、链表、排序与归并
- 插入排序：分为直接插入排序和折半插入排序，基本思想是将未排序元素逐个插入已排序序列。 - 希尔排序：基于插入排序的改进，通过增量序列分组元素进行排序。 - 交换类排序：如冒泡排序，通过不断交换相邻逆序...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值