非循环单链表选择与插入排序

最新推荐文章于 2020-09-06 13:41:25 发布
最新推荐文章于 2020-09-06 13:41:25 发布
阅读量463 收藏
点赞数
分类专栏： C语言 文章标签： 单链表 排序 头节点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010452647/article/details/51068876
版权

非循环单链表的选择与插入排序


1.简介

排序是学习数据结构与算法中最有趣的知识之一，近期学习链表时，重点研究了选择排序和插入排序，经过了反复的推敲，最后明白

了一些，但又发现思维不够清晰，故打算写这篇博文，其重点是用来理清自己的思维，从而掌握这种算法。


2.算法的核心思想－－－有规律的改变链表中各节点间的连接方式。

核心就是规律(记得电视剧《天道》里有句话：按规律办事的人就是神～～～)，可见规律的重要性，而在我的认识中：自然的规律就

是科学，人的规律就是哲学…扯远了。

选择排序的规律：遍历整个原链表，找到<数据>最小(从小到大排序)或最大(从大到小排序)的节点。

                               

                                          在链表的结构中把它删除,但内存中一定要保留。

                              

                               将其追加到新的一个链表的末端。

                              

                               ～原链表会越来越短，而新链表会越来越长。～

                              

                                          最终原链表为空，而新链表会以<数据>从小到大或从大到小依次排列。


插入排序的规律：将原链表的第一个节点从其结构中删除，原链表结构从第二个节点开始。

                              

                               将删除的节点作为目前新链表的唯一节点。

                              

                               遍历原链表，依次取出各节点。

                              

                               将取出的节点依据<数据>的大小有序的插入新链表。

                              

                              ～原链表会越来越短，而新链表会越来越长。～

                              

                                         最终原链表为空，新链表会以<数据>从小到大或从大到小依次排列。


3.选择排序的伪算法

            

             定义原链表第一个节点的指针与新链表第一个节点的指针

         

               while( 原链表不为空 ){

                    1.在原链表中找到最小或最大的数据节点。

                    2.在原链表结构中删除此最小节点。

                   3.将删除的最小节点追加到新链表中。

                }

4.插入排序的伪算法

               

            定义原链表第一个节点的指针与新链表第一个节点的指针;

            新链表指针指向原链表的第一个节点。

            原链表指针指向原链表的第二个节点。

         

               while( 原链表不为空 ){

                    1.在原链表结构中有序的删除一个节点。

               2.遍历新链表，找到刚好比删除节点<数据>大的那个节点。(从小到大的排序)

                   3.将删除节点插入到新链表中那个刚好比它大的节点前。

               }

5.代码实现

下面的代码我混合实现了有头节点链表与无头节点链表的选择排序与插入排序。这里不得不说下我的排序函数原型：－－以选择排序为例。

                   PNODE     SelectSortList( PNODE   List, char   type, char  *head,   int  (*cmp)(PNODE p1, PNODE p2 ) );

                  PNODE  List:是链表的指针

                  char  type:是排序方式 '<'代表的是从小到大排序，'>'代表是从大到小排序，不接受其它字符

                  char *head:是一个字符串指针，该字符串为HEAD时说明是有头节点链表，结果可以用返回值，也可以用List参数。为其它字符串时，说明是无头节点链表，结果必须用返回值，该参

数不接受NULL指针

                  int(*cmp )( PNODE p1, PNODE p2 )是回调函数，用于参数比较。

                  Return:返回的是排序后的链表，对于无头节点链表调用该函数必须接收这个返回值。 

测试主函数

# include <stdio.h>
# include <stdlib.h>
# include <string.h>

# define TRUE 1
# define FLASE 0
# define MALLOC( type, len ) (type*)malloc( sizeof(type) * len )
# include "sort.c"

int
main( void ){

	PNODE List  =  NULL;
	PNODE pHead =  NULL;

    printf( "************************无头节点链表排序测试****************************\n");
	printf( "追加函数测试:             ");
	List = AppendList( List, 5 );
	AppendList( List, 11 );
	AppendList( List, 8 );
	AppendList( List, -3 );
	AppendList( List, 0 );
	AppendList( List, 8 );
	AppendList( List, 24 );
	AppendList( List, 11 );
	AppendList( List, 7 );
	TraversList( List,"NOHEAD", Print );
	printf( "\n选择排序函数由小到大测试: " );
    List = SelectSortList( List, '<', "NOHEAD", CompareNum );
	TraversList( List, "NOHEAD", Print );
	printf( "\n选择排序函数由大到小测试: " );
    List = SelectSortList( List, '>', "NOHEAD", CompareNum );
	TraversList( List, "NOHEAD", Print );
    printf( "\n插入排序函数由小到大测试: " );
    List = InsertSortList( List, '<', "NOHEAD", CompareNum );
	TraversList( List,"NOHEAD", Print );
    printf( "\n插入排序函数由大到小测试: " );
    List = InsertSortList( List, '>', "NOHEAD", CompareNum );
	TraversList( List,"NOHEAD", Print );
	DestoryList( List );
	List = NULL;
    printf( "\n***********************无头节点链表排序测试完毕*************************\n\n\n");

    printf( "*************************有头节点链表排序测试***************************\n");
	printf( "追加函数测试:             ");
	pHead = CreateHeadNode();
    AppendList( pHead, 8 );
	AppendList( pHead, 113 );
	AppendList( pHead, 52 );
	AppendList( pHead, -33 );
	AppendList( pHead, 10 );
	AppendList( pHead, 34 );
	AppendList( pHead, 52 );
	AppendList( pHead, -18 );
	AppendList( pHead, -33 );
	TraversList( pHead,"HEAD", Print );
	printf( "\n选择排序函数由小到大测试: " );
    SelectSortList( pHead, '<', "HEAD", CompareNum );
	TraversList( pHead, "HEAD", Print );
	printf( "\n选择排序函数由大到小测试: " );
	SelectSortList( pHead, '>', "HEAD", CompareNum );
	TraversList( pHead, "HEAD", Print );

    printf( "\n插入排序函数由小到大测试: " );
    InsertSortList( pHead, '<', "HEAD", CompareNum );
	TraversList( pHead, "HEAD", Print );
    printf( "\n插入排序函数由大到小测试: " );
    InsertSortList( pHead, '>', "HEAD", CompareNum );
	TraversList( pHead,"HEAD", Print );
	DestoryList( pHead );
    printf( "\n************************有头节点链表排序测试完毕************************\n\n");




	return EXIT_SUCCESS;
}


链表排序函数库   

/*************************************************************
 *   非循环单链表选择与插入排序演练                          *
 ************************声明*********************************/
/*  数据结构  */
typedef struct node{

	long   num; //编号，用于排序
	struct node *pNext;//下一个节点

} NODE,*PNODE;

/*  接口函数  */
PNODE CreateHeadNode(); //创建一个头节点

PNODE AppendList( PNODE List, long New );//追加一个节点

PNODE SelectSortList( PNODE List, char type, char *head, int (*cmp)( PNODE p1, PNODE p2 ) );//选择排序

PNODE InsertSortList( PNODE List, char type, char *head, int (*cmp)( PNODE p1, PNODE p2 ) );//插入排序

void TraversList( PNODE List, char *head, void (*func)( PNODE p ) );//遍历链表

void DestoryList( PNODE List );//销毁链表


/*  操作函数  */
int CompareNum( PNODE p1, PNODE p2 );// 节点中 num数据的比较

void Print( PNODE p );//stdout 打印

/************************END**********************************/

/**********************接口函数*******************************/
/*
 * Function: 创建一个头节点
 * Return:   PNODE指针
 * */
PNODE CreateHeadNode(){
	
	PNODE pHead;
	pHead = MALLOC( NODE, 1 );
	//分配一个头节点, 初始化 num = -100000 pNext = NULL
	if( pHead != NULL )
		pHead->num = -100000;
		pHead->pNext = NULL;

	return  pHead;//返回头节点
}

/*
 * Function: 追加一个节点
 * List:     原链表
 * long:     追加编号
 * Return:   新链表 追加成功，NULL 追加失败
 * */
PNODE AppendList( PNODE List, long num ){

	PNODE new;

	//分配空间
	new = MALLOC( NODE, 1 );
	if( new != NULL){
		//写入数据
		new->num = num;
		new->pNext = NULL;
		
		if( List != NULL ){
			//找到末尾
			while( List->pNext != NULL )
				List = List->pNext;
			//追加节点
			List->pNext = new;

		}else//对于无头链表的第一个节点写入
			List = new;

		return List;//无头链表的首次追加需要此返回值
	}

	return NULL;
} 

/*
 * Function: 选择排序
 * List:     链表
 * type:     模式，'<' 从小到大, '>' 从大到小
 * head:     是否有头节点 "HEAD" 是有头节点， 其它字符串为无头节点，该参数不能为NULL
 * cmp:      回调函数，用于比较方法,返回 1 0 -1
 * Return:   PNODE指针，指向排序后的链表
 * */
PNODE SelectSortList( PNODE List, char type, char *head, int (*cmp)( PNODE p1, PNODE p2 ) ){


	if( strcmp( head, "HEAD" ) == 0 ){//如果有头节点

		//空链表参加排序，直接返回
		if( List->pNext == NULL )
			return List;

		//定义变量并初始化
		PNODE subList = List->pNext;//子链表指向首节点
		PNODE tailNew;              //新链表的尾指针
		PNODE tmp,   preTmp;        //最小(大)节点指针，最小(大)节点前驱节点指针 
		PNODE p,     pre;           //遍历指针，遍历前驱节点指针 

		List->pNext = NULL;         //新链表依旧用List这个头节点
		tailNew = List;

		//循环查找最小节点
		while( subList != NULL ){
			//参数初始化
			tmp = subList;//当前最小节点
			pre = subList;//当前遍历节点的前驱节点初始化
			p = subList->pNext;//当前遍历节点初始化
			preTmp = NULL;//当前最小节点前驱节点初始化
			//循环比较
			while( p != NULL ){
				/* 由小到大排序时，当tmp > p 时，说明P是当前最小值，所以tmp = p
				 * 由大到小排序时，当tmp < p 时，说明p是当前最大值，所以tmp = p
				 * */
				if( ( type == '<' && cmp( tmp, p ) == -1 ) || ( type == '>' && cmp( tmp, p ) == 1 ) )
					tmp = p, preTmp = pre;

				pre = p;//遍历
				p = p ->pNext;
			}
			
			//在旧链表中删除最小节点
			if( tmp == subList )//最小节点为首节点
				subList = subList->pNext;
			else//最小节点不为首节点
				preTmp->pNext = tmp->pNext;

			//追加最小节点至新链表
			tmp->pNext = NULL;//尾结点pNext=NULL
			tailNew->pNext = tmp;//尾结点指针遍历
			tailNew = tailNew->pNext;
		}
		return List;
	}else{//如果没有头节点

		//空链表参加排序，直接返回
		if( List == NULL )
			return List;

		//定义变量
		PNODE new = NULL, tailNew;//新链表指针, 新链表尾指针
		PNODE tmp,preTmp;         //最小(大)节点指针，最小(大)节点前驱节点指针 
		PNODE p, pre;       //遍历指针，遍历前驱节点指针 

		//循环拆分链表
		while( List != NULL ){

			//初始化参数
			p = List->pNext;
			pre = List;
			tmp = List;
			preTmp = NULL;

			//循环查找最小节点
			while( p != NULL ){

				/* 由小到大排序时，当tmp > p 时，说明P是当前最小值，所以tmp = p
				 * 由大到小排序时，当tmp < p 时，说明p是当前最大值，所以tmp = p
				 * */
				if( (type == '<' && cmp( tmp, p ) == -1) || ( type == '>' && cmp( tmp, p ) == 1 ) )
					tmp = p, preTmp = pre;//获得当前最小节点指针与最小节点前驱节点指针

				pre = p;//遍历指针与其前驱节点指针移动
				p = p->pNext;
			}

			//在旧链表结构中删除最小节点
			if( tmp == List )//最小节点为首节点时
				List = List->pNext;
			else
				preTmp->pNext = tmp->pNext;//最小节点不为首节点时

			//在新链表结构中追加最小节点
			tmp->pNext = NULL;//追加的就是尾结点
			if( new == NULL ){//追加第一个节点
				new = tmp;
				tailNew = new;//有了首节点才能初始化尾节点
			}
			else{//链表有首节点后的追加
				tailNew->pNext = tmp;
				tailNew = tailNew->pNext;
			}
		}

		return new;//返回新链表
	}
	return NULL;
}

/*
 * Function: 插入排序
 * List:     链表
 * type:     模式，'<' 从小到大, '>' 从大到小
 * head:     是否有头节点
 * cmp:      回调函数，比较方法
 * Return:   PNODE指针，指向排序后的链表
 * */
PNODE InsertSortList( PNODE List, char type, char *head, int (*cmp)( PNODE p1, PNODE p2 ) ){


	if( strcmp( head, "HEAD" ) == 0 ){

		//空链表参加排序，直接返回
		if( List->pNext == NULL )
			return List;

		//定义变量
		PNODE subList;//子链表
		PNODE tmp;//当前节点
		PNODE pre, p;//新链表遍历指针

		//参数初始化
		subList = List->pNext->pNext;//子链表指向第二个有效节点
		List->pNext->pNext = NULL;//头节点与第一个有效节点组成一个新链表

		//循环插入节点
		while( subList != NULL ){
			//参数初始化
			tmp = subList;//获取待插节点
			p = List->pNext;//准备遍历指针
			pre = List;//p 的前驱就是头节点
			
			//寻找插入点
			while( p != NULL ){
				/* 由小到大排序时，当tmp < p 时，说明tmp要插入在p的前面
				 * 由大到小排序时，当tmp > p 时，说明tmp要插入在p的前面
				 * */
				if( ( type == '<' && cmp( tmp, p ) == 1 ) || ( type == '>' && cmp(tmp, p ) == -1 ) )
					break;
				pre = p;//遍历
				p = p->pNext;
			}

			//旧链表指向下一个待插参数
			subList = subList->pNext;

			//插入当前参数
			pre->pNext = tmp;
			tmp->pNext = p;

		}
		return List;

	}else{

		//空链表参加排序，直接返回
		if( List == NULL )
			return List;

		//定义变量
		PNODE new;//新链表
		PNODE tmp;//当前待插节点
		PNODE p, pre;//新链表遍历指针

		//初始化参数
		new = List;
		List = List->pNext;//旧链表从第二个有效节点开始
		new->pNext = NULL;//新链表保留旧链表第一个有效节点

		//循环将旧链表数据依次插入新链表
		while( List != NULL ){

			//获得插入节点，初始化遍历新链表参数
			tmp = List;
			p = new;
			pre = NULL;

			//在新链表中循环找到链表的插入点
			while( p != NULL ){
				/* 由小到大排序时，当tmp < p 时，说明tmp要插入在p的前面
				 * 由大到小排序时，当tmp > p 时，说明tmp要插入在p的前面
				 * */
				if( ( type == '<' && cmp( tmp, p ) == 1 ) || ( type == '>' && cmp( tmp, p ) == -1 ) )
					break;

				pre = p;
				p = p->pNext;
			}
			//旧链表移向下一个待插入节点
			List = List->pNext;

			//在新链表中插入当前节点
			if( p == new )//插入到首节点前
				new = tmp;
			else//插入到首节点后，任何节点前
				pre->pNext= tmp;
			tmp->pNext = p;

		}
		return new;
	}

	return NULL;
}

/*
 * Function: 遍历链表
 * List:     链表
 * head:     是否含头结点 HEAD 是有，其它是无，不能用NULL
 * func:     回调操作函数
 * Return:   void
 * */
void TraversList( PNODE List, char *head, void (*func)( PNODE p ) ){

	if( strcmp( head, "HEAD" ) == 0 ){
		//有头节点
		while( List->pNext != NULL ){
			func( List->pNext );
			List = List->pNext;
		}

	}else{
		//无头节点
		while( List != NULL ){
			func( List );
			List = List->pNext;
		}
	}
}

/*
 * Function: 销毁链表
 * List:     链表
 * Return:   void
 * */
void DestoryList( PNODE List ){

	PNODE t;

	while( List != NULL ){

		t = List;
		List = List->pNext;

		free( t );
		t = NULL;
	}
}
/************************END**********************************/
/**********************操作函数*******************************/
/*
 * Function: 比较函数
 * p1:       节点1
 * p2:       节点2 
 * Return:   p1 < p2 时返回 1， p1 > p2 时返回 -1
 * */
int CompareNum( PNODE p1, PNODE p2 ){

	if( p1->num < p2->num )
		return 1;
	else if( p1->num == p2->num )
		return 0;
	return -1;

}

/*
 * Function: 标准输出打印
 * p:        节点
 * Return:   void
 * */
void Print( PNODE p ){

	printf( " %3ld ", p->num );

}
/************************END*******************************/


图示


Writer:  Anden       Email:  andensemail@163.com      Time:  2016.04.5

Anden_C
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
非循环单链表的C++实现
11-21
非循环单链表的C++实现。创建CLinkList类，实现链表的各项功能：初始化，插入，删除，获取元素，获取链表长度，排序，遍历等。
数据结构之------非循环单链表的 基础冒泡排序算法实现 ( C Language )
yang7654的博客
03-06 193
关于C语言版的一些算法实现,例如二叉树的各种算法在很多应用里面比较重要(最短路径什么的).但是计算机发展到今天,很多软件方面的东西已经集成在了各种库中,没有一些很详细的算法介绍(这里要再次膜拜一下严老师和国内外一些把这些原理实现的大牛),还有一些原理的理解,上层建筑的由来可能有些和我一样的朋友,一开始也是比较模糊的,但是如果真的可以理解这些稍微底层点的东西,会对后面的深造有很大的帮助,这些主要是一...
查找链表最大值&&链表排序
巴啦啦能量
03-12 1210
输入一个数列以0位结束标志，建立链式线性表，查找其中最大的数并输出删除释放节点，然后对剩余的进行排序，并输出释放节点。 分步骤解决： 1）初始化链表，建立头结点 2）根据输入建立链表 link *Create(link *l)，此处采用尾插法即可，直接在Create函数中输入并以此插入到尾节点后 3）查找出最大值并从链表中删除之link *Find_delete_max(link *l) 4）最有...
非循环单链表创建和链表遍历
a1004117090的博客
08-07 191
1 #include<stdio.h> 2 #include<malloc.h> 3 #include<stdlib.h> 4 //函数声明 5 PNODE create_list();//返回值是链表头结点的地址 6 void traverse_list(PNODE pHead); 7 8 typedef stru...
线性表与链表的三个常用操作： 最值，逆置，归并
qq_45044146的博客
09-06 254
最值 思想：数组保存线性表L，形成顺序表，标记当前的数据元素，用2个变量表示min,max最小值和最大值，并把他们初始化第一个数据元素，对于从前往后遍历整个线性表 顺序表----------遍历整个顺序表与n同阶无穷大，时间复杂度为O(n) int min = L[0]; int max = L[0]; 1.首先是声明2个变量，保存当前最大值和最小值，并把他们初始化为线性表中第一个元素L[0] 2.使用for循环遍历整个数组 if 语句-- 当前遍历的数组元素与当前保存的最大值和最小值比较，比当前保存的.
返回一个将list插入this的排序循环单链表
11-10
返回一个将list插入this的排序循环单链表
利用单链表实现有序表的合并.cpp .h
01-25
利用单链表实现有序表的合并的cpp文件和h文件，可以用来学习。 ... template void LinkList<ElemType>::Merge... if(p->data<=q->data)//将满足排序要求的结点插入到L1 { r->next=p; r=p; p=p->next; }
循环链表基本操作
04-15
输入多个字符，用顺序表保存，实现对表的操作，实现初始化，求表长度，求表中的第i个结点，输入一个字符，查找对应的结点，插入一个结点，删除一个结点，排序
经典算法学习——非循环双向链表实现冒泡排序（不带头结点）
乞力马扎罗的雪CYF的博客
03-03 4311
我在前面两篇博客《经典算法学习——单链表（不带头结点）实现冒泡排序》《经典算法学习——单链表实现冒泡排序（带头结点）》中详细描述了分别使用带头结点和不带头结点的单链表实现了冒泡排序，让我们对单链表和冒泡排序有了理性的认识。今天我们将会来使用不带头结点的非循环双向链表来实现冒泡排序，在处理过程中，这种冒泡比前面两种更为简单高效。代码上传至 https://github.com/chenyufeng1
链表插入排序
huixiaowangshu的博客
03-31 180
问题描述：用插入排序对链表排序                    样例：Given 1->3->2->0->null, return 0->1->2->3->null  解题思路：主要思路为建立一个新链表将原链表中的节点依次插入新链表中，
对utf-8字符串计算长度
热门推荐
Anden与C
03-30 1万+
对utf-8字符串计算长度 1.简介 在linux操作系统下，默认使用utf-8字符集,当程序中的在流中使用字符(ASCII)时用strlen()函数完全能够处理问题，但是在流中使用中文汉字时，strlen()就力不从心了。若更改字符集为GB2312，一个汉字等于两个字符，但是此更改不仅要修改文件保存的保存字符集，还要修改系统的字符集及终端的字符集。所以我通过对utf-8字符集的学习，自己
讨论: 字符串数组与字符串指针数组
Anden与C
04-20 2987
由于原来学习C语言字符串时，常把字符串数组与字符串指针数组弄不清楚，它们的元素都可以用作字符串标准库函数的实参，但是自己写函数调用时，却出了不少问题，所以我就有了想再次学习它们打算。
UTF-8编码数据在命令行终端编织成表格并输出
Anden与C
04-03 2938
UTF-8编码数据在命令行终端编织成表格并输出 Linux系统常用的是UTF-8编码，一个UTF-8的汉字在内存占用三个字节，而在终端打印时，它只占用二个字符的位置，那么表格的格式(各字段对齐)成了主要问题。本函数库就解决了这一问题，在命令行终端下编织出中英文混合且整齐的表格。
C语言伪泛型的实现－－栈
Anden与C
04-08 1490
我思考了很久，什么是数据结构？最终得到一个答案(还不知道是不是对的～～，不对的话email我)：数据结构是数据的载体和操作这种载体方法的集合，它与数据是无关的，所以它是可以被抽象出来的。为了实践这个结论，我打算用－－栈－－这个最简单的数据结构来实践它。 我分别用静态数组栈，动态数组栈，链表栈实现的我的这一结论，由于C语言的本质，静态数组栈的初始化得在主函数中实现或在代码中定义静态数组栈，这样有被于我这篇博文想实现的代码功能，所以这篇博文我不会再讲到它。
函数调用符、聚合访问符、单目操作符综合学习
Anden与C
04-18 600
聚组符，函数调用符，聚合数据访问符，单目运算符的综合运用
五种排序的思想及其基本实现
Anden与C
04-26 436
五种排序的思想及其基本实现 1. 简介:    这两天重学了冒泡排序、插入排序、选择排序、归并排序、快速排序，这五种排序，现就学到知识做以总结，我的代码风格有所变化，注释不仅成块出现，而且用了英语，语句中的空白运用也有所变化。 2. 算法分析  a. 冒泡排序     在序列中从左到右比较相邻的两个元素，若右边元素小于左边元素则交换(从小到大);     依次遍历比较至指定的位
插入排序对单链表排序
最新发布
12-08
插入排序是一种简单直观的排序算法，对于单链表的排序也可以采用插入排序。具体实现方法如下： 1. 将单链表的表头分离，形成两个表，一个有序表（La1），一个无序表（La2）。 2. 对无序表进行循环，将每个元素插入到...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值