插入排序--直接插入排序，折半插入排序，希尔排序

最新推荐文章于 2023-11-05 14:33:19 发布
最新推荐文章于 2023-11-05 14:33:19 发布
阅读量1.6k 收藏 9
点赞数
文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75220252/article/details/131523340
版权

插入排序是一种简单直观的排序方法，其基本思想是每次将一个待排序的记录按其关键词大小插入前面已经排好的子序列，直到全部记录插入完成。

一，直接插入排序：从小到大排序

数组序号01234567
待排序列4938659776132749
第一轮3849659776132749
第二轮3849659776132749

第一轮，数组序号为1开始与前面元素进行比较，38 <49,所以将38与49交换位置

第二轮：数组序号为3开始与前面的元素进行比较，49，38都小于65，故位置不变

代码展示：

//直接插入排序，从小到大进行排列
void InsertSort(Str &L)
{
	for(int i = 1; i < L.length; ++i)//最开始从第二个元素和前面元素相比
	{
		if(L.data[i] < L.data[i-1])//如果后面的元素比前面的元素小，执行后续操作
		{	
		  int temp = L.data[i];//先将元素存储在一个定义的元素中，防止被覆盖
		  int j;
		  for(j = i-1; j >= 0 && L.data[j] > temp; --j)//从i-1的那个元素开始前面的元素都和temp的元素进行比较，如果比temp元素大，就依次往后移动
		  {
			  L.data[j+1] = L.data[j];//如果比temp元素大，就依次往后移动
		  }
		  L.data[j+1] = temp;//加入说前面元素都是比temp中元素大，那么最后当j = -1是不满足循环条件，所以j应该加1，其他位置也是同样的逻辑

		}
	}
}

结果：

 

 

二，折半插入排序

将待排序元素前面已经排序好的元素进行折半查找，找到位置后，将元素逐个往后移动，然后再将待排序元素赋值到该位置上

以下面为例讲解：13是待排元素

数组序号012345678
待排序列133849657697132749
第一次lowmidhigh
第二次

low

mid

high
第三次highlow
后移133838496576972749
1338496576972749

第一次的时候：low = 1, high = 5, mid = (low+high)/2 = 3,对应元素65>13,进行第二次

第二次的时候：low = 1, high = mid-1 = 2, mid = (low+high)/2 = 1,向下取整;mid对应元素为38>13,进行第三次

第三次的时候：low = 1; high = mid-1 = 0;此时low>high,结束

然后将元素比13大的元素全部后移，最后将数组序号为0的元素赋值到序号为low的位置

代码展示：

//折半插入排序
void Binary_InsertSort(Str &L)
{
  int i,j,low,high,mid;
  for(i = 2; i <= L.length; ++i)//从第二个元素开始，依次向后
  {
	  L.data[0] = L.data[i];//将需要和前面元素进行比较的元素放在L.data[0]中，防止被覆盖
	  low = 1;//折半插入排序中折半过程是对前面已经排序好的元素进行折半，所以最开low = 1
	  high = i-1;//i前面的元素是已经排序好的，所以high = i-1;
	  while(low <= high)//循环条件
	  {
	    mid = (low+high)/2;//中间值，向下取整
		if(L.data[mid] > L.data[0])//查找左半子表
			high = mid-1;
		else
			low = mid+1;//查找右半子表，当等于的时候也是将low = mid+1,这样就可以使数组稳定
	  }
	  for(j = i-1; j >= low; --j)
	  {
		  L.data[j+1] = L.data[j];//统一后移元素，空出插入位置
	  }
	  L.data[low] = L.data[0];//将元素插入空出来的位置
  }
}

结果：

 三，希尔排序

将待排序列分割若干的”特殊“子表，即把相隔某个”增量“（缩小增量）的记录组成一个子表，对各个子表分别进行直接插入排序，当整个表中的元素以呈”基本有序“时，再对全体记录进行一次直接插入排序。

每次将增量缩小一半，最开始为：8/2 = 4；考试中可能遇到各种增量

数组序号012345678
待排序列4938659776132749
子表14976
子表23813
子表36527
子表49749
第一趟排序结果4913274976386597

增量变为：4/2 = 2

数组序号012345678
待排序列4913274976386597
子表1

49

277665
子表213493897
排序后子表127496576
排序后1子表213384997
第二趟排序结果2713493865497697

后续增量变为：2/2 =1，变成直接插入排序

代码展示：

//希尔排序
void ShellSort(Str &L)
{
  int dk,i,j;
  for(dk = L.length/2; dk >= 1; dk = dk/2)//最开始令缩小增量dk为待排序列元素个数的一半，当dk = 1变成直接插入排序
  {
    for(i = 1; i < dk+1; ++i)//每次使用缩小变量组成子表的个数为dk,每个子表的第一个元素是从1到dk
	{
		for(j = i+dk; j <= L.length; j = j+dk)//从子表的第二个元素开始，循环
		{
			L.data[0] = L.data[j];//先将待排序元素存储到数组序号为0的位置上，以免移动时元素被覆盖无法找到
			if(L.data[j-dk] > L.data[0])//如果子表中以排序元素大于待排序元素
			{
				for(j; j > i && L.data[j-dk] > L.data[0]; j = j-dk)//j为待排序元素序号，如果已排序元素的序号大于子表第一个元素序号并且大于待排序元素，循环，从后往前，依次访问
				{
					L.data[j] = L.data[j-dk];//满足条件之后从后往前将元素依次往后移动
				}
				L.data[j] = L.data[0];//最后将数组序号为0中的元素赋值到腾出的位置，从前面可以分析出，如果子表第一个满足条件，执行循环语句之后，j就成为子表第一个元素所在序号，所以L.data[j] = L.data[0]
			}
		}
	}
  }
}

结果： 

 

 

课本上的希尔排序代码如下：

相当于几个子表循环进行元素比较移动

//课本希尔排序代码
void ShellSort(ElemType A[],int n)
{
  //A[0]只是暂存单位，不是哨兵，当j <= 0时，插入位置已到
	int dk,i,j;
	for(dk = n/2; dk >=1; dk = dk/2)
	{
	  for(i = dk+1; i <= n; ++i)
	  {
	    if(A[i] < A[i-dk])
		{
		  A[0] = A[i];
		  for(j = i-dk; j > 0 && A[0] < A[j]; j -= dk)
		  {
		    A[j+dk] = A[j];
		  }
		  A[j+dk] = A[0];
		}
	  }
	}
}
插入排序空间复杂度时间复杂度稳定性适用性
直接插入排序O(1)O(n^{2})稳定顺序存储和链式存储
折半插入排序O(1)O(n^{2})稳定顺序存储
希尔排序O(1)O(n^{2})稳定顺序存储

稳定性：待排序中有相同的元素，在进行某种算法的排序之后，若是这些相同元素的相对位置不发生改变的话，就称这种排序算法是稳定的

算法是否稳定不能够衡量一个算法的优劣，它主要对算法的性质进行描述。

完整代码：

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define Size 8

//定义动态分配内存数组
typedef struct
{
  int *data;
  int length;
}Str;

//函数说明
void CreatString(Str &L);
void CreatString1(Str &L);
void InsertSort(Str &L);
void StrPrint(Str L);
void StrPrint1(Str L);
void Binary_InsertSort(Str &L);
void ShellSort(Str &L);

int main(void)
{
  Str L;
  CreatString(L);
  printf("数组元素为：\n");
  StrPrint(L);
  InsertSort(L);
  printf("直接插入排序之后数组元素为：\n");
  StrPrint(L);
  Str L1;
  CreatString1(L1);
  printf("折半插入排序之后数组元素为：\n");
  Binary_InsertSort(L1);
  StrPrint1(L1);
  Str L2;
  CreatString1(L2);
  printf("希尔排序之后数组元素为：\n");
  ShellSort(L2);
  StrPrint1(L2);
  return 0;
}

void CreatString(Str &L)
{
	L.data = (int *)malloc(sizeof(int)*Size);
	L.length = Size;
	int val;
	for(int i = 0; i < L.length; ++i)
	{
	  printf("请输入数组第%d个值:",i+1);
	  scanf_s("%d",&val);
	  L.data[i] = val;
	}
}

void CreatString1(Str &L)
{
	L.data = (int *)malloc(sizeof(int)*Size+1);
	L.length = Size;
	int val;
	for(int i = 1; i <= L.length; ++i)
	{
	  printf("请输入数组第%d个值:",i);
	  scanf_s("%d",&val);
	  L.data[i] = val;
	}
}

//直接插入排序，从小到大进行排列
void InsertSort(Str &L)
{
	for(int i = 1; i < L.length; ++i)//最开始从第二个元素和前面元素相比
	{
		if(L.data[i] < L.data[i-1])//如果后面的元素比前面的元素小，执行后续操作
		{	
		  int temp = L.data[i];//先将元素存储在一个定义的元素中，防止被覆盖
		  int j;
		  for(j = i-1; j >= 0 && L.data[j] > temp; --j)//从i-1的那个元素开始前面的元素都和temp的元素进行比较，如果比temp元素大，就依次往后移动
		  {
			  L.data[j+1] = L.data[j];//如果比temp元素大，就依次往后移动
		  }
		  L.data[j+1] = temp;//加入说前面元素都是比temp中元素大，那么最后当j = -1是不满足循环条件，所以j应该加1，其他位置也是同样的逻辑

		}
	}
}

//遍历输出
void StrPrint(Str L)
{
	for(int i = 0; i < L.length; ++i)
	{
		printf("%d ",L.data[i]);
	}
	printf("\n");
}

void StrPrint1(Str L)
{
	for(int i = 1; i <= L.length; ++i)
	{
		printf("%d ",L.data[i]);
	}
	printf("\n");
}



//折半插入排序
void Binary_InsertSort(Str &L)
{
  int i,j,low,high,mid;
  for(i = 2; i <= L.length; ++i)//从第二个元素开始，依次向后
  {
	  L.data[0] = L.data[i];//将需要和前面元素进行比较的元素放在L.data[0]中，防止被覆盖
	  low = 1;//折半插入排序中折半过程是对前面已经排序好的元素进行折半，所以最开low = 1
	  high = i-1;//i前面的元素是已经排序好的，所以high = i-1;
	  while(low <= high)//循环条件
	  {
	    mid = (low+high)/2;//中间值，向下取整
		if(L.data[mid] > L.data[0])//查找左半子表
			high = mid-1;
		else
			low = mid+1;//查找右半子表，当等于的时候也是将low = mid+1,这样就可以使数组稳定
	  }
	  for(j = i-1; j >= low; --j)
	  {
		  L.data[j+1] = L.data[j];//统一后移元素，空出插入位置
	  }
	  L.data[low] = L.data[0];//将元素插入空出来的位置
  }
}

//希尔排序
void ShellSort(Str &L)
{
  int dk,i,j;
  for(dk = L.length/2; dk >= 1; dk = dk/2)//最开始令缩小增量dk为待排序列元素个数的一半，当dk = 1变成直接插入排序
  {
    for(i = 1; i < dk+1; ++i)//每次使用缩小变量组成子表的个数为dk,每个子表的第一个元素是从1到dk
	{
		for(j = i+dk; j <= L.length; j = j+dk)//从子表的第二个元素开始，循环
		{
			L.data[0] = L.data[j];//先将待排序元素存储到数组序号为0的位置上，以免移动时元素被覆盖无法找到
			if(L.data[j-dk] > L.data[0])//如果子表中以排序元素大于待排序元素
			{
				for(j; j > i && L.data[j-dk] > L.data[0]; j = j-dk)//j为待排序元素序号，如果已排序元素的序号大于子表第一个元素序号并且大于待排序元素，循环，从后往前，依次访问
				{
					L.data[j] = L.data[j-dk];//满足条件之后从后往前将元素依次往后移动
				}
				L.data[j] = L.data[0];//最后将数组序号为0中的元素赋值到腾出的位置，从前面可以分析出，如果子表第一个满足条件，执行循环语句之后，j就成为子表第一个元素所在序号，所以L.data[j] = L.data[0]
			}
		}
	}
  }
}

尘桥湖
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
直接插入排序
04-21
数据结构与算法中的直接插入排序实现，平均时间复杂度为n2亲测可用
直接插入排序、折半插入排序、希尔排列
10-06
直接插入排序、折半插入排序和希尔排序都是基于插入排序思想的算法，它们在不同场景下有着各自的优势。直接插入排序适用于小规模数据或基本有序的数据集；折半插入排序通过优化查找过程，减少了比较次数，适合于元素...
数据结构(C语言版)——简单选择排序(代码版)
qq_42683219的博客
10-04 4598
一、代码 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 20 #define ERROR 0 #define OK 1 typedef int Status; void selectSort(int data[]); int main(int argc, char *argv[]) { int data[MAXSIZE],i,arrSize; printf("请输入待排序的数组大小:"); if(scanf(
数据结构——排序算法实现：直接插入排序、折半查找排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数排序
cwindyc的博客
06-11 1951
1、插入排序 #include<iostream> #include<iomanip> using namespace std; #define MAXSIZE 105 #define MAXN 55 typedef int KeyType; typedef int InfoType; typedef char BaseType; typedef struct { KeyType key; BaseType Based[MAXN]; InfoType other; }Red
数据结构排序算法之直接插入、折半插入、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序（二路归并排序）C语言实现
c_cjiajia_的博客
06-13 3337
插入：直接插入、折半插入、希尔排序 交换：冒泡排序、快速排序⭐ 选择：简单选择排序、堆排序⭐ 归并：归并排序（二路归并排序）⭐ 快速排序、堆排序和归并排序为时间复杂度较小的排序方法，为O(nlogn); 英语不太好，有些算法就直接用拼音了... 这些算法的输入输出语句用的是cout.cin。（为C++内容，只需将头文件改为#include<iostream> using namespace std;即可兼容C\C++语句。或可直接将cin.cout语句改为scanf\printf语.
排序算法系列之直接插入排序
胡小聪246的博客
07-17 6万+
直接插入排序 1 基本原理 1 核心思想：插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入 ，如此重复，直至完成序列排序。 2 算法分析： 1. 从序列第一个元素开始，该元素可以认为已经被排序 2. 取出下一个元素，设为待插入元素，在已经排序的元素序列中从后向前扫描，如果该元素（已排序）大于待插入元素，将...
希尔排序，直接插入排序，折半插入排序算法.
05-29
希尔排序，直接插入排序，折半插入排序算法的实现，c语言实现希尔排序
排序（二）插入排序 c/c++与python实现
12-21
主要有直接插入排序、折半插入排序和希尔排序。 直接插入排序（Straight Insertion Sort） 直接插入排序的基本思想：首先，我们将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
它通过比较相距一定间隔的元素来进行排序，间隔逐渐缩小，最终达到直接插入排序的条件。希尔排序的时间复杂度介于O(n^2)和O(nlogn)之间，具体取决于间隔序列的选择。 5. **快速排序**（Quick Sort）： 快速排序是...
七种排序算法（包括直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，简单选择排序，归并排序）-C/C++代码类资源
07-30
七种排序算法（包括直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，简单选择排序，归并排序） 还有两道题 1./*设计并实现一个有效的对n个整数重排的算法，使得所有负数位于非负数之前，给出算法的...
插入排序（Insertion Sort）
鱼香肉丝没有鱼的博客
11-13 1万+
theory 原理讲解来源于文章 https://www.runoob.com/data-structures/insertion-sort.html 1、概念及其介绍 插入排序(InsertionSort)，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增 1 的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找
直接插入排序，折半插入排序，希尔排序详解及C++代码详细实现
weixin_45651616的博客
08-20 1541
直接插入排序，折半插入排序，希尔排序详解及C++代码详细实现
数据结构：插入排序
weixin_45652283的博客
08-03 9032
插入排序算法是所有排序方法中最简单的一种算法，其主要的实现思想是将数据按照一定的顺序一个一个的插入到有序的表中，最终得到的序列就是已经排序好的数据。直接插入排序是插入排序算法中的一种，采用的方法是：在添加新的记录时，使用顺序查找的方式找到其要插入的位置，然后将新记录插入。很多初学者所说的插入排序，实际上指的就是直接插入排序算法，插入排序算法还包括折半插入排序、2-路插入排序，表插入排序和希尔排序等。
排序——插入排序
最新发布
m0_57179599的博客
11-05 92
排序：就是重新排列表中的元素，使得表中的元素满足按关键字有序的过程。算法的稳定性：如果待排序表中的关键字不允许重复，则排序的结果是唯一的，那么选择排序算法时的稳定与否就无关紧要了。算法的稳定性体现在待排序表中若Ri和Rj，其对应的关键字相同keyi=keyj，且在排序前Ri在Rj的前面，若使用某一排序算法排序后，Ri仍然在Rj的前面，则这个排序算法是稳定的，否则是不稳定的。例题：对任意7个关键字进行基于比较的排序，至少要进行多少次关键字之间的比较。
排序算法——直接插入排序（图文超详细！）
热门推荐
qq_44616044的博客
04-14 14万+
简介 英文名：Straight Insertion Sort 也是一种最简单的排序方法，其基本操作是将一条记录插入到已排好的有序表中，从而得到一个新的、记录数量增1的有序表 步骤 以下用数组2,5,8,3,6,9,1,4,7为例 从小到大排序 1.先看第一个数，将数组划分为有序和无序部分 首先看第一个数2，一个数必然有序，所以将2划分有序，后面都是无序 2.无序部分的首个插入到有序部分 取出无序部分的首个，在有序部分从后向前比较，插入到合适的位置 3.重复第2步直到无序部分全部插入有序
排序算法详细讲解（超酷）
qq_51419787的博客
03-30 1万+
排序算法作为数据结构中重要的部分，是必须要掌握的知识之一。 目录 前言 一、插入类排序 1.直接插入排序 2.折半插入排序 3.希尔排序 二、交换类排序 1.冒泡排序（相邻比序法） 2.快速排序 三、选择类排序 1.简单选择排序 2.树形选择排序 3.堆排序 四、归并排序 五、分配类排序 1.多关键字排序 2.链式基数排序 3.计数排序 总结 前言 在进行数据处理时，经常需要对数据进行查找，为了查的更快，通常要求数据有序排列。根据排序时......
插入排序和折半插入排序实现
汽车电子从业者，电子爱好者。
12-14 672
一、实验（实训）目的 掌握插入排序的两种方法并加以实现： 二、实验（实训）原理或方法 直接插入排序：插入排序从第二个数开始，拿出第二个数进行向前插入排序，一直到最后一个数向前做插入排序。算法稳定。 折半插入排序:顺序地把待排序的序列中的各个元素按其关键字的大小，通过折半查找插入到已排序的序列的适当位置。 三、仪器设备、材料 VSCODE + gcc.exe 四、实验（实训）步骤 代码：复制或者截图（完整） void insertSort(int *L, int n) { int i, j;
插入排序—折半插入排序
SICAUliuy的博客
03-22 438
排序思路 和直接插入排序相似，先把待排序列看作连个部分：R[0……i-1]为有序，R[i……n-1]为无序。初始时，i=1,即有序部分为R[0] 和直接插入排序不同的是，无序元素向有序区插入的方式是通过折半查找到合适的位置。 在R[0……i-1]中（初始时low=0,high=i-1）,采用折半查找方法得到R[i]的位置为R[high+1]，然后将R[high+1,i-1]中的元素后移一个位...
直接插入排序、希尔排序、折半插入排序的c++代码
06-08
下面是直接插入排序、希尔排序、折半插入排序的C++代码： 直接插入排序： ```c++ void insertionSort(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; } } ``` 希尔排序： ```c++ void shellSort(int arr[], int n) { int gap = 1; while (gap < n / 3) { gap = gap * 3 + 1; } while (gap > 0) { for (int i = gap; i < n; i++) { int key = arr[i]; int j = i - gap; while (j >= 0 && arr[j] > key) { arr[j + gap] = arr[j]; j -= gap; } arr[j + gap] = key; } gap = (gap - 1) / 3; } } ``` 折半插入排序： ```c++ void binaryInsertionSort(int arr[], int n) { for (int i = 1; i < n; i++) { int key = arr[i]; int left = 0, right = i - 1; while (left <= right) { int mid = (left + right) / 2; if (arr[mid] > key) { right = mid - 1; } else { left = mid + 1; } } for (int j = i - 1; j >= left; j--) { arr[j + 1] = arr[j]; } arr[left] = key; } } ``` 以上是三种排序算法的C++代码，可以根据需要进行调用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值