【上机代码】插入排序——直接插入，折半插入，希尔排序

最新推荐文章于 2022-07-06 09:00:47 发布
最新推荐文章于 2022-07-06 09:00:47 发布
阅读量285 收藏 3
点赞数
分类专栏： 上机代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xza13155/article/details/115955256
版权

目录

直接插入排序

思路

在排序中，序列为以下状态：

有序待排无序
L[1,…,i-1]L[i]L[i+1,…,n]

要将L[i]插入有序序列L[1,…,i-1]中
1，在L[1,…,i-1]中找到L[i]的插入位置K（从后向前遍历，K>=L[i])
2，将L[k,…,i-1]全部后移一位，空出L[k]
3，将L[i]插入L[K]

初始时，我们将L[1]看做有序，依次对L[2]-L[n]执行n-1次插入排序

代码

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void print(int A[], int length)
{
	for (int i = 0; i < length; ++i)
	{
		printf("%d ", A[i]);
	}
}
//直接插入排序
void InsertSort(int A[], int n) {
	int i, j, temp;
	for (i = 1; i < n; ++i)//从第二个元素开始遍历
	{
		if (A[i] < A[i - 1]) {//若当前遍历的元素>=前一元素，已经有序故不操作；若<前一元素，则执行
			temp = A[i];//暂存元素值
			for (j = i - 1; j >= 0&&A[j]>temp; --j)//从前一元素，向前遍历有序序列，直到遇到大于等于该元素的，或者遍历到头
				A[j + 1] = A[j];
			A[j + 1] = temp;//插在A[J]后面（若A[j]==temp,保证了稳定性）
		}
	}
}

void test()
{
	int A[10];
	int length = sizeof(A) / sizeof(A[0]);
	srand(time(0));
	for (int i = 0; i < length; ++i)
	{
		A[i] = rand() % 100;//取0-99的随机数  0-99，都为原值，100-199为0-99，以此类推

	}
	printf("原始序列为：\n");
	print(A, length);
	InsertSort(A, length);
	printf("\n排序后为：\n");
	print(A, length);
}


int main()
{
	test();
}

链表实现

思路

对数组插入排序时，是两重循环，第一重是从第二个元素开始遍历整个数组，第二个就是反向循环，从当前元素开始向前寻找第一个小于当前数的值，并插到它后面。

但单链表无法反向，所以第二重循环就可以进行正向遍历，找到第一个大于当前结点值的结点，并插到它前面。

借助两个指针sort和unsort，分别指向待排序的第一个元素，和未排序的最后一个元素，且unsort->next==sort。
1，当前元素大于链表第一个元素就直接头插法
2，当前元素不大于第一个元素，就从第二个元素开始遍历已排序的元素（利用p和q两个指针），要么已排序都小于当前元素，则插入尾部。要么找到大于当前元素的节点，插在该节点前即可。

错误点
1，unsort与sort对比是从第二个元素开始遍历，L->next->next开始

2，遍历要遍历完sort中最后一个元素，因为之前只和第一个元素对比过了。

代码

#include<stdio.h>
#include "malloc.h"
#include<stdlib.h>
#include<time.h>
//定义链表结构体
typedef struct LinkList
{
	int data;
	int id;//唯一标识每个节点
	struct LinkList* next;
}LinkList;

//交换链表中两个数据
void swap(LinkList* p, LinkList* min)
{
	int temp = p->data;
	p->data = min->data;
	min->data = temp;
};

void Insertsort(LinkList* L)
{
	LinkList* sort, * unsort, * p, * q;
	if (L != NULL) { //保证链表不为空
		sort = L->next;//指向排序好部分的最后一个元素
		while (sort->next != NULL)//遍历未排序的第一个元素
		{
			unsort = sort->next;//每次循环都指向未排序的第一个元素
			if (unsort->data < L->next->data) { //未排序的元素小于链表第一个元素
				sort->next = unsort->next;//头插法，把第一个未排序的插入表头
				unsort->next = L->next;
				L->next = unsort;
			}
			else
			{
				q = L->next;
				p = q->next;//从第二个元素开始遍历，第一个在上面头插法对比过了
				while (unsort->data >= p->data) {//直到找到p>unsort
					if (p->id == unsort->id)//遍历到unsort就停止,若遍历到unsort前一个就会少对比sort的最后一个元素
						break;
					q = p;
					p = p->next;
				}
				if (p->id == unsort->id) {//遍历到unsort前。说明未排序元素均大于已排序元素，插入队尾
					sort = unsort;
				}
				else//未遍历到unsort前，找到了大于未排序元素的p，插入p前
				{
					sort->next = unsort->next;
					unsort->next = p;
					q->next = unsort;
				}
			}
		}
	}
}

//输出链表节点
void print(LinkList* L)
{
	LinkList* p = L;
	for (int i = 0; i < L->data; ++i)//L为头结点不能动 否则每次遍历就会改变条件
	{
		printf("%d-%d ", p->next->id, p->next->data);

		p = p->next;
	}
}

void test()
{
	//建立链表
	LinkList* L = (LinkList*)malloc(sizeof(LinkList));
	if (L == NULL) {
		printf("内存分配不成功！\n");
	}
	else
	{
		L->data = 10;
		LinkList* p = L;
		srand(time(0));
		for (int i = 0; i < L->data; ++i)
		{
			p->next = (LinkList*)malloc(sizeof(LinkList));
			if (p->next) {
				p = p->next;
				p->data = rand() % 100;//取0-99的随机数  0-99，都为原值，100-199为0-99，以此类推
				p->id = i;
			}
		}
		p->next = NULL;
		printf("原始序列为：\n");
		print(L);
		Insertsort(L);
		printf("\n排序后为：\n");
		print(L);
	}
}

int main()
{
	test();
}

折半插入排序

思路

在直接插入排序的基础上做改进，以减少比较次数。

有序待排无序
L[1,…,i-1]L[i]L[i+1,…,n]

1，对已排序列L[1,…,i-1]使用折半查找法找到比待排元素L[i]大的元素L[k]
2，将L[k,…,i-1]全部后移一位，空出L[k]
3，将L[i]插入L[K]

代码

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void print(int A[], int length)
{
	for (int i = 0; i < length; ++i)
	{
		printf("%d ", A[i]);
	}
}
//折半插入排序
void InsertSort(int A[], int n) {
	int i, j, low,high,mid,temp;
	for (i = 1; i < n; ++i)//从第二个元素开始遍历
	{
		temp = A[i];//暂存数据
		low = 0; high = i - 1;//已排序序列首尾元素
		while (low <= high) {//折半查找
			mid = (low + high) / 2;//取中间元素
			if (A[mid] > temp)//不断缩小查找访问
				high = mid - 1;
			else
				low = mid + 1;//low会不断指向值更大的方向
		}
		若j<low,待排元素比前面所有元素都大，无需后移，直接插在原处。
		for (j = i - 1; j >= low; --j)//值大于temp的元素，依次后移
			A[j + 1] = A[j];
		A[low] = temp;//插入low位置
	}
}

void test()
{
	int A[10];
	int length = sizeof(A) / sizeof(A[0]);
	srand(time(0));
	for (int i = 0; i < length; ++i)
	{
		A[i] = rand() % 100;//取0-99的随机数  0-99，都为原值，100-199为0-99，以此类推

	}
	printf("原始序列为：\n");
	print(A, length);
	InsertSort(A, length);
	printf("\n排序后为：\n");
	print(A, length);
}
int main()
{
	test();
}

希尔排序

思路

插入排序适合基本有序的序列，若序列逆序时间复杂度达到 O ( n 2 ) O(n^{2}) O(n2)，若为正序则可提升到O(n)，希尔排序（缩小增量排序）就是在此基础上进行优化。
首先确定一个小于n的增量d，将序列分为形如L[i,i+d,…,i+kd]的d个子表。即间隔d的元素组成子表，然后对每个子表进行插入排序。不断缩小d的值，进行排序。当整个表已经基本有序（具有较好的局部有序性）的时候（d=1），最后进行一次排序即可。

代码

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void print(int A[], int length)
{
	for (int i = 0; i < length; ++i)
	{
		printf("%d ", A[i]);
	}
}
//希尔排序
void ShellSort(int A[], int n) {
	int d, i, j, k, temp;
	for (d = n / 2; d >= 1; d = d / 2)//取增量，以增量为间隔构建子表
	{
		for (i = 0; i < d; ++i)//遍历子表的头结点
		{
			for (j = i + d; j < n; j = j + d)//遍历每个子表的元素，默认第一个元素有序，按直接排序处理。
			{
				if (A[j] < A[j - d]) {
					temp = A[j];//暂存数据
					for (k = j - d; k >= 0 && temp < A[k]; k -= d)
						A[k + d] = A[k];
					A[k + d] = temp;
				}
			}
		}//每次都使整个序列更有序，从而直接排序速度越来越快。
	}
}

void test()
{
	int A[10];
	int length = sizeof(A) / sizeof(A[0]);
	srand(time(0));
	for (int i = 0; i < length; ++i)
	{
		A[i] = rand() % 100;//取0-99的随机数  0-99，都为原值，100-199为0-99，以此类推

	}
	printf("原始序列为：\n");
	print(A, length);
	ShellSort(A, length);
	printf("\n排序后为：\n");
	print(A, length);
}


int main()
{
	test();
}

参考：
#数据结构 将带头结点的单链表实现直接插入排序.

燕南路GISer
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
插入排序代码
zhangqiang180的博客
08-14 364
public class charu { //从第一值向前插入，后面的数字在向前面插入的时候， // 前面的数字一定已经排序好了，找一个位置将这个放入正确的位置 public static void main(String[] args) { int [] ar ={19,3,6,8,219,57,2,6,3,8}; for (int i = 0; i <ar.length ; i++) {//将a【i] 向前移动，移动到前面一个值比它小，或.
三种插入排序代码实现 (直接插入排序 +折半插入排序 +希尔排序)
四月的萤火之光的博客
05-02 2102
插入排序 1、直接插入排序 2、折半插入排序 3、希尔排序 1、直接插入排序 package sort; public class InsertSort {//直接插入排序 //有序区 无序区 [前：后] public static void sortA(int[] arr,int n){ int tmp;//临时值 int i,j; for(i=
折半插入排序
weixin_34252090的博客
06-01 82
    只有比别人更早、更勤奋地努力，才能尝到成功的滋味。              ------麦克马斯特大学训言            记得之前总结过插入排序，有兴趣的可以看看---插入排序。    如果在最复杂的情况下，所要排序的整个数列是逆序的，当第 i-1 趟需要将 第 i 个元素插入前面的 0~ i -1 个元素的序列当中的时候，它总是会从第 i -1 个元素开始，逐个比较每个元...
插入排序
qq_39543174的博客
12-08 264
插入排序 **基本思想：**每一步将一个待排序的数据插入到前面已经排好序的有序序列中，直到插完所有元素为止。 算法实现：直接插入排序是将无序序列中的数据插入到有序的序列中，在遍历无序序列时，首先拿无序序列中的首元素去与有序序列中的每一个元素比较并插入到合适的位置，一直到无序序列中的所有元素插完为止。对于一个无序序列arr{4，6，8，5，9}来说，我们首先先确定首元素4是有序的，然后在无序序列中向右遍历，6大于4则它插入到4的后面，再继续遍历到8，8大于6则插入到6的后面，这样继续直到得到有序序列{4，5，
浅析直接插入排序与折半插入排序
09-04
直接插入排序和折半插入排序是两种常见的简单排序算法，它们都基于比较元素来决定元素的相对顺序。这里我们将深入探讨这两种排序算法的工作原理、效率分析以及适用场景。 首先，直接插入排序（Straight Insertion ...
C++折半插入排序详解以及代码实现
最新发布
12-25
折半插入排序（Binary Insertion Sort）是对直接插入排序的一种优化。在直接插入排序中，我们需要遍历整个已排序部分来找到新元素的正确位置，而折半插入排序则利用了二分搜索算法来减少这个过程的时间消耗。以下是...
Python实现的直接插入排序算法示例
09-20
直接插入排序是一种简单的排序算法，它的基本思想是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这种排序算法是稳定的，即相同元素的相对顺序在排序后不会改变。以下是...
Java实现直接插入排序和折半插入排序算法示例
09-02
直接插入排序和折半插入排序是两种常见的简单排序算法，它们都基于比较和移动元素来达到排序的目的。这里我们将深入探讨这两种算法的实现、性能分析以及它们的特点。 **直接插入排序** 是一种基础的排序算法，其...
简单的插入排序代码
caolinan的专栏
03-20 326
#include using namespace std; void fun(int number[],int n){ for(int i=2;i int tem=number[i]; int j=i-1; while(j>0&&number[j]>tem){ number[j+1]=number[j]; j=j-1; } number[j]=tem; } //
插入排序（内附代码）
张洁的笔记
08-04 520
插入排序的原理与打扑克摸牌一致，当一张新牌来时，我们会选择一个合适的位置插入，插入排序算法原理类似，当数据的前半部分有序时，依次遍历后半部分的数据，将每个无序数据插入到前面有序部分中。在此处，我们用双链表的方式实现该算法。
插入排序（insertion_sort）python代码
YZZF14的博客
07-06 459
just 代码+使用案例
C语言直接插入排序和折半插入排序算法的实现
ZGUIZ的博客
01-22 7061
直接插入排序是是一种稳定的排序，其算法简便，适用于顺序结构和链式结构，更适合于基本有序（正序）的情况。其空间复杂度为O(1)，时间复杂度为O(n2)。下面是实现算法： 先是预定义和类型定义： typedef int Status; typedef int ElemType; typedef struct{ ElemType *data; int length; }SqList; 创建
插入排序示例代码
lu2985323的博客
06-14 84
插入排序示例代码 思想:将左边第0个元素开始，认为是有序的，后面是无序的 每次用无序的和有序的比较，如果小了，就插入到有序序列。 插入的时候要逐次移动元素，因此看到的是三层循环。 ...
插入排序的代码实现
Felaim的博客
07-30 683
最近有时间会开始看算法导论，一点一点的把算法导论中的一些常见算法都实现一下，也算是扩充一下LZ的知识储备和代码储备，这样，无论什么时候要什么算法，LZ能很快找到，深有感慨，“纸上得来终觉浅，绝知此事要躬行”。理论到位了，代码也要到位。#include <iostream> using namespace std; //LZ这里添加了一个模板类 template <class T>int getArr
插入排序的代码书写
weixin_62047160的博客
03-20 89
插入排序 #include <iostream> #include <ctime> using namespace std; void sort(int arr[],int k) { if(k == 0) return; //对前k-1个元素进行排序 sort(arr,k-1); //把位置k的元素插入到前面的部分 int x = arr[k]; int index = k-1; while(index &
直接插入排序、希尔排序、折半插入排序的c++代码
06-08
下面是直接插入排序、希尔排序、折半插入排序的C++代码： 直接插入排序： ```c++ void insertionSort(int arr[], int n) { for (int i = 1; i ; i++) { int key = arr[i]; int j = i - 1; while (j >= 0 && ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

燕南路GISer

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值