数据结构初步：单链表

最新推荐文章于 2023-04-05 11:10:56 发布
最新推荐文章于 2023-04-05 11:10:56 发布
阅读量379 收藏 2
点赞数
分类专栏： 计导C语言+计算机一些知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40774136/article/details/104515033
版权

文章目录

链表的结构

链表是用链节指针链在一起的自引用结构变量（称为结点）的线性集合，是线性表的一种存储结构。
结构变量通过指针"链"在了一起，具有前驱和后继关系。第一个结构变量的地址单独记录在一个指针里。
（1）headPtr──指向链表首结点的指针变量。
（2）每个结点由2个域组成：
数据域──存储结点本身的信息。
指针域──存储指向后继结点的指针(针对单向链表)。
（3）尾结点的指针域置为NULL(用反斜杠表示)，作为链表结束的标志。
注：链表的结点在逻辑上是连续的，但是各结点的内存通常是不连续的，因此不能立即被访问到，只能从头结点开始逐结点访问。

链表的存储，打印，删除（释放）

以下是链表的简单存储代码，

#include<stdio.h>
#include<stdlib.h>
/****************************************************
结构体说明
功能：链表的一个单元，包括存储的数据，链接下一个单元的链节指针
参数：data, *nextptr
****************************************************/ 
typedef struct node{
	int data;
	struct node *nextptr;
}LISTUNIT;
int main()
{
	LISTUNIT *headptr=NULL,*lastptr=NULL,*currentptr=NULL;//前驱，后继，媒介 
	int num;
	scanf("%d",&num);
	while(num!=-1)
	{
		if(headptr==NULL)
		{
			headptr=malloc(sizeof(LISTUNIT));//直接用头指针申请空间 
			headptr->data=num;
			currentptr=headptr;
			lastptr=headptr;
		}
		else 
		{
			currentptr=malloc(sizeof(LISTUNIT));
			currentptr->data =num;
			lastptr->nextptr =currentptr;//将上一节点的后继与当前节点相连 
			lastptr=currentptr;//移动后继指针到当前节点 
		}
		//printf("%d\n",currentptr->data ); //不设置其他函数检验该部分的语句 
		scanf("%d",&num);
	}
	lastptr->nextptr =NULL;
	return 0;
 } 
 /*****************************************
 循环的第二种写法，直接以currentptr申请空间，少了几行代码。
 ****************************************/
 while(num!=-1)
	{
	    currentPtr=malloc(sizeof(LISTNODE)); /*分配结点内存*/ 
 	    if (currentPtr!=NULL)//还可判断申请空间是否成功
		{/*插入结点*/
 	        currentPtr->data=num;	
    		if (headPtr==NULL)
			{   /*若创建的是首元结点*/
    		    headPtr=currentPtr;
                lastPtr=currentPtr; 
            } 	   
          	else
			{
          	    lastPtr->nextPtr=currentPtr;  /*将结点连上链表尾结点*/
              	lastPtr=currentPtr;   /*使lastPtr指向当前链表的最后一个结点*/
            }
        }
        scanf("%d",&num);
 	}

以下是链表打印函数的代码，正确，但还可以更好

void LISTprint(LISTUNIT *headptr)
{
	LISTUNIT *currentptr=NULL,*lastptr=NULL;
	currentptr=headptr;
	lastptr=headptr;
	if(headptr==NULL)printf("NULL!!!");
	while(lastptr->nextptr!=NULL)//可以只用一个指针
	{
		printf("%d\n",currentptr->data  );
		currentptr=lastptr->nextptr ;
		lastptr=currentptr;
	}
	printf("%d\n",lastptr->data );
}
/***********************************************
以下是老师的代码
**********************************************/
/**************************************************
函数：void printList(LISTNODEPTR currentPtr) ;
功能：顺次输出链表中各节点数据；
参数：LISTNODEPTR currentPtr  指向链表首元结点的指针 
**************************************************/
void printList(LISTNODEPTR currentPtr)
{
    if (currentPtr==NULL)//!!!考虑到链表为空的情况
    	   printf("the list is empty\n");
    else
	{
	   	printf("the list is:\n");
   	   	while(currentPtr!=NULL)
		{
   	        printf("%d-->",currentPtr->data);
            currentPtr=currentPtr->nextPtr;
        } 
        printf("NULL\n\n");   
    }
}

以下是链表删除代码

void LISTdelete(LISTUNIT *headptr)
{
	LISTUNIT *currentptr=NULL;
	while(headptr!=NULL)
	{
		currentptr=headptr;
		headptr=headptr->nextptr ;
		free(currentptr);
	}	
}

以下是主函数代码对比

int main()
{
	LISTUNIT *headptr=NULL;
	headptr=LISTSAVE();
	LISTprint(headptr);
	LISTdelete(headptr);
	LISTprint(headptr);
	return 0;
}

结果如下。。前面三函数正常，最后删除又打印打印出了这一堆，乱七八糟的数据，删除链表后headptr应该赋为NULL。
在这里插入图片描述
以下是老师的主函数

int main()
{
	LISTNODEPTR		headPtr = NULL ;
    
	headPtr = createFIFOList1();
	printList(headPtr) ;
	destroyList(headPtr) ; 
	headPtr = NULL ;//!!!
	
	return 0;
}

链表的插入

实际链表第一个节点不存放数据，只存放下一节点地址。因此该链表永远不可能为空。从而可以简化程序的判断逻辑：插入节点或删除节点时不用判断前驱节点为空的情况。
在这里插入图片描述

创建一个带空节点的链表头

/*创建一个带空节点的链表头*/
//传递指向指针的指针
void createListHead (LISTNODEPTR * headPtrPtr){
	*headPtrPtr = malloc(sizeof(LISTNODEPTR));
	if ((*headPtrPtr) != NULL){
		(*headPtrPtr)->nextPtr = NULL;
	} 
}

尾插

(1)无尾指针插法
在这里插入图片描述

/*把一个新值插入到链表尾部*/
void insertEnd1 (LISTNODEPTR sPtr, ElementType value){
	LISTNODEPTR newPtr, previousPtr, currentPtr;
	/*动态分配新节点，将新值存入*/
	newPtr = malloc(sizeof(LISTNODEPTR));
	if (newPtr != NULL){
		newPtr->data = value;
		newPtr->nextPtr = NULL;
		/*找到尾节点，记为前驱指针previousPtr*/
		previousPtr = sPtr ;
		currentPtr = sPtr->nextPtr;
		while (currentPtr != NULL){
			previousPtr = currentPtr;
			currentPtr = currentPtr->nextPtr;
		}

		/*在尾节点后链接新节点*/
		previousPtr->nextPtr = newPtr;
	}
	else 
	    printf("Not inserted. No memory avaliable.\n");
}

（2）有尾指针插法
在这里插入图片描述

单链表改进

1、首尾指针相连，形成环状链表；
2、双链表：将链表的指针域改成包含前驱节点指针

头插

在这里插入图片描述

有序插节点

在这里插入图片描述

按值删除节点

在这里插入图片描述

删除多重节点

/*删除所有值为value的节点，成功则返回被删元素个数；否则返回0。*/
int deleteNodes(LISTNODEPTR headPtr,ElementType value){
    LISTNODEPTR previousPtr,currentPtr;
     int count=0;
    previousPtr = headPtr;
    currentPtr = headPtr->nextPtr; /*将空节点的后继传给currentPtr*/
    
    while ( currentPtr != NULL){  /*遍历整个链表来删除多个value值节点*/
        /*查找待删除节点，若找到，则由currentPt指向该节点*/
        while (currentPtr!=NULL &&  currentPtr->data!=value){ 
              previousPtr=currentPtr;
              currentPtr=currentPtr->nextPtr;
        }
      if (currentPtr!=NULL){ /*如果找到要删除的节点*/
	previousPtr->nextPtr= currentPtr->nextPtr;
             free(currentPtr); //释放节点
             currentPtr = previousPtr->nextPtr;//删除多重节点的关键
 	count++;
        } 
    }
    return count;
}

链表不可以排序后二分查找

链表不能直接定位到第k个节点，所以链表不能进行二分查找，除非借助于存储所有节点指针的指针数组。

链表逆序

在这里插入图片描述
在这里插入图片描述

void reverseList(LISTNODEPTR headPtr, LISTNODEPTR * lastPtrPtr) {
    	LISTNODEPTR firstPtr,previousPtr,currentPtr,tempPtr;  

	/*若是空链表，不用逆序*/
   	if(headPtr->nextPtr == NULL)  	return ;

	/*空节点处理*/
	firstPtr = headPtr->nextPtr;
    headPtr->nextPtr = *lastPtrPtr;

	/*第一个数据节点处理 */	
	currentPtr = firstPtr->nextPtr; 	previousPtr = firstPtr; 
	firstPtr->nextPtr=NULL;  //很重要，反向后的链表结束标记
	/*循环处理后续所有节点*/
    while ( currentPtr != NULL ) {
	   tempPtr = currentPtr->nextPtr;
    	   currentPtr->nextPtr = previousPtr;/*反向连接*/
    	   previousPtr = currentPtr;/*下次循环准备工作*/
    	   currentPtr = tempPtr;
    }        
    *lastPtrPtr = firstPtr; /*返回更新后的尾指针*/ 
}

链表归并

在这里插入图片描述

/*有序(升序)链表的归并函数*/
void mergeSortList(LISTNODEPTR head1Ptr, LISTNODEPTR * last1PtrPtr, LISTNODEPTR head2Ptr, LISTNODEPTR * last2PtrPtr )
  参数：head1Ptr指向链表1的头指针；
 		   head2Ptr指向链表2的头指针；
 		   last1PtrPtr指向链表1的尾指针；
 		   last2PtrPtr指向链表2的尾指针；
   返回值：无，因为空节点的添加保证了头指针不会变化，尾指针的变化可以通过二级指针带回。
void mergeSortList(LISTNODEPTR head1Ptr, LISTNODEPTR * last1PtrPtr, LISTNODEPTR head2Ptr, LISTNODEPTR * last2PtrPtr )
{
	LISTNODEPTR first1, first2, pre1, temp2;
	first1 = head1Ptr->nextPtr;  first2 = head2Ptr->nextPtr;
	pre1 = head1Ptr; 
	while ( first1 != NULL && first2 != NULL){
      	if ( first2->data < first1->data){
			temp2 = first2->nextPtr;
			pre1->nextPtr = first2;	pre1 = first2;
			first2->nextPtr = first1;
			first2  = temp2;
		} else {
			pre1 = first1;	first1 = first1->nextPtr; 
		}
	}//end while
	if (first2 != NULL ){
		pre1->nextPtr = first2;
//也可以	(*last1PtrPtr)->nextPtr = first2;
		*last1PtrPtr = *last2PtrPtr;
	} 
	/*修正链表2为空链表*/
	head2Ptr->nextPtr = NULL;
	*last2PtrPtr = head2Ptr;
}

环形链表

在这里插入图片描述

/*把一个新值插入到环形链表尾部，利用尾指针*/
void insertCirEnd2 (LISTNODEPTR * lastPtrPtr , ElementType value){
	LISTNODEPTR newPtr;
	/*动态分配新节点，将新值存入*/
	newPtr = malloc(sizeof(LISTNODEPTR));
	if (newPtr != NULL){
		newPtr->data = value;
		newPtr->nextPtr = (*lastPtrPtr)->nextPtr ;
		/*直接在尾节点后链接新节点*/
		(*lastPtrPtr)->nextPtr = newPtr ;
		*lastPtrPtr = newPtr;
	}
	else 
	    printf("Not inserted. No memory avaliable.\n");
}

释放环形链表

void destroyCirList(LISTNODEPTR * headPtrPtr)
{
    LISTNODEPTR tempPtr, currentPtr;
	currentPtr = (*headPtrPtr)->nextPtr;
	while ( currentPtr != *headPtrPtr ){
        tempPtr = currentPtr;
        currentPtr = currentPtr->nextPtr;
        free(tempPtr);
    }
    free(*headPtrPtr);
	*headPtrPtr = NULL; /*被释放链表的头指针应该置为空*/
}
写程序先想后写
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构单链表完整程序
12-09
数据结构单链表基本操作实现，查找、插入、删除、连接两个单链表的实现
数据结构中单链表的程序
05-16
数据结构中单链表的程序。。。。。。。。。。。。。。。。。。。。。。
单链表简易教程
好好学java
06-17 920
一、概述 单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链式存储结构的线性表将采用一组任意的存储单元存放线性表中的数据元素。由于不需要按顺序存储，链表在插入、删除数据元素时比顺序存储要快，但是在查找一个节点时则要比顺序存储要慢 使用链式存储可以克服顺序线性表需要预先知道数据大小的缺点，链表结构可以充分利用内存空间，实现灵活的内存动态管...
c语言数据结构链表程序,链表实例程序（C语言）
weixin_32339855的博客
05-17 339
下面是用 C语言来实现链表的一个实例程序，具体细节如下：#include #include #include #include struct node {int data;int key;struct node *next;};struct node *head = NULL;struct node *current = NULL;//display the listvoid printList...
C#数据结构-链栈
子时已过的博客
10-15 280
上一篇我们通过数组结构实现了栈结构（准确的说是栈的顺序存储结构），现在我们通过链（单链）存储栈，也就是链栈。 通常对于正向单链表来说，是从头节点开始，在链的尾部附加节点，前一个节点的指针指向附加节点；对于实现栈结构来说是在栈顶（链尾部）插入节点，指针指向上一个节点，所以实现栈结构的链可以说是反向单链表。 public class LinkStackNode<T> { /// <summary> /// 数据存储 /// </summary>
数据结构课程大纲和所有教案
01-21
数据结构是计算机科学中的核心课程，它探讨了如何在计算机中有效地组织和管理数据，以实现高效的算法。本课程大纲和教案将全面涵盖这一领域的基础知识和高级概念。 **课程大纲** 1. **引言** - 数据结构的概念与...
《算法与数据结构》课程设计任务书
06-03
1. 单链表：包括创建、插入、删除、查找和显示元素等功能。 2. 栈：支持进栈、出栈、获取栈顶元素的操作。 3. 数组：实现数组的创建、加法、减法、乘法等运算。 4. 二叉树：包括创建二叉树、遍历（先序、中序、后序...
数据结构与算法（四）：Python实现单链表的反转、环的检测、两个有序链表的合并、判断单向链表是否是回文字符串
01-20
根据链表数据结构的知识，进行初步练习，从单链表的反转、环的检测、两个有序链表的合并、判断单向链表是否是回文字符串四个题目着手，分别进行代码实现。 首先定义单链表类： # 结点类 class Node(object): def _...
嵌入式系统软件设计中的数据结构
08-23
《嵌入式系统软件设计中的数据结构》可作为从事嵌入式系统软件设计的电子技术人员自学"数据结构"的教材，也可供高等院校电子技术类专业本科生、研究生作为教学参考书。 　根据嵌入式系统软件设计需要的“数据结构”...
c语言版数据结构课件
11-03
数据结构是计算机科学中的核心课程之一，它研究如何在计算机中有效地组织和管理数据，以提高数据处理的效率。在C语言中实现数据结构，能够更深入地理解底层操作，对于学习计算机科学的学生来说至关重要。清华大学...
数据结构单链表实例一个简单的小程序
07-09
数据结构单链表实例一个简单的小程序,没有多大
数据结构（链表操作）
02-04
本程序是数据结构作业，实现链表的创建，删除，逆序输出等操作。
数据结构之单链表
weixin_49561445的博客
02-14 436
简介 链表是有序的列表，它是构成单链表的基本结点结构。 在结点中数据域用来存储数据元素，指针域用于指 向下一个具有相同结构的结点。 因为只有一个指针结点，称为单链表。 单链表其内存存储结构 其逻辑结构图 特点 1 链表是以节点的方式来存储的 2 每个节点包含data域，存放值，next域指向下一个节点的指针 3 链表的各个节点不一定是连续存储的 4 链表分带头节点的链表和不带头节点的链表，根据实际需求来确定 单链表结点 头结点：有时，在链表的第一个结点之前会额外增设一个结点，结点的
数据结构链表小程序
hubi0952的专栏
07-21 617
#include "stdio.h"#include "stdlib.h"struct list{ int num; struct list *next;};typedef struct list node;typedef node *link;link createlist(i
数据结构--单链表基本功能实现程序…
01-01 831
#include   #include      #include    const MAXNUMOFBASE=5;  //基础数据总量 enum returninfo{success,fail,overflow,underflow,range_error};//定义返回信息清单 int   sourcedata[MAXNUMOFBASE]={11,22,33,55,66,};  //内部数据数组
【数据结构】---【单链表完整介绍和实现】
最新发布
m0_74044018的博客
04-05 812
单链表的实现逻辑是什么？他的实现功能基本全部实现！详细讲解！
【数据结构】单链表完整代码实现
飞舞的蓝色雪花
11-21 4227
数据结构中单链表的完整代码实现。
数据结构之链表程序解析
shi_shi08的博客
07-16 819
/** 此文件是链表的学习知识：* 内容参考《大话数据结构》和博客 https://www.cnblogs.com/leaver/p/6718421.html* 链表的基本单位是节点，节点包含俩部分的内容，一个是数据，一个是指向下一个节点的指针。*//* 线性表的单链表存储结构 */typedef int ElemType;/* (一)、数据结构 */typedef struct Node{Ele...
C语言数据结构——链表
weixin_52398991的博客
07-03 466
怎么解决数据大小未知、不知如何存储的问题呢？在这篇博文里，小编就来推荐一种自制数据结构——链表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值