2-2-1链表的基本操作

最新推荐文章于 2023-03-18 22:09:36 发布
原创 最新推荐文章于 2023-03-18 22:09:36 发布 · 380 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文探讨了带头结点和不带头结点链表在初始化、销毁、判断空链表、计算长度、返回元素及位置、插入和删除节点等操作上的区别。通过实例分析，强调了在处理逻辑位置和物理地址位置时的注意事项，以及不同操作对链表指针的影响。

2-2-1链表的基本操作(头结点与不带头结点的链表)

下面不带头结点的链表操作,与带头结点的链表操作,都用到同一个数据存储结构LinkListType.h

//LinkListType.h线性表的单链表存储结构
#pragma	once

#ifndef __LINKLISTTYPE_H__
#define __LINKLISTTYPE_H__
typedef int ElemType;
struct LNode
{
	ElemType data;
	LNode *next;
};
typedef LNode *LinkNode; // 另一种定义LinkList的方法

#endif

*LinkNode和*next都是指向LNode类型的节点

不带头结点的LinkListBasicOperation.h

#pragma	once

#ifndef _LINKLISTBASICOPERATION_H__
#define _LINKLISTBASICOPERATION_H__
#include "c1.h"
#include "LinkListType.h"
#define DestroyList ClearList // DestroyList()和ClearList()的操作是一样的
void InitList(LinkNode &L);
void ClearList(LinkNode &L);
Status ListEmpty(LinkNode L);
int ListLength(LinkNode L);
Status GetElem(LinkNode L,int pos,ElemType &e);
int LocateElem(LinkNode L,ElemType e,Status(*compare)(ElemType,ElemType));
Status PriorElem(LinkNode L,ElemType cur_e,ElemType &pre_e);
Status NextElem(LinkNode L,ElemType cur_e,ElemType &next_e);
Status ListInsert(LinkNode &L,int pos,ElemType e);
Status ListDelete(LinkNode &L,int pos,ElemType &e);
void ListTraverse(LinkNode L,void(*vi)(ElemType));
#endif

不带头结点的ListInsert和ListDelete都需要用到&L引用

带头结点的LinkListBasicOperationWithHead.h

#pragma	once

#ifndef _LINKLISTBASICOPERATIONWITHHEAD_H__
#define _LINKLISTBASICOPERATIONWITHHEAD_H__
#include "c1.h"
#include "LinkListType.h"
void InitList(LinkNode &L);
void DestroyList(LinkNode &L);
void ClearList(LinkNode L);
Status ListEmpty(LinkNode L);
int ListLength(LinkNode L);
Status GetElem(LinkNode L,int i,ElemType &e);
int LocateElem(LinkNode L,ElemType e,Status(*compare)(ElemType,ElemType));
Status PriorElem(LinkNode L,ElemType cur_e,ElemType &pre_e);
Status NextElem(LinkNode L,ElemType cur_e,ElemType &next_e);
Status ListInsert(LinkNode L,int i,ElemType e);
Status ListDelete(LinkNode L,int i,ElemType &e);
void ListTraverse(LinkNode L,void(*vi)(ElemType));
#endif

带头结点的ListInsert和ListDelete则没有用到&L引用

下面透过对比12个操作来区分头结点和不带头结点的区别

1.初始化链表

//不带
void InitList(LinkNode &L)
{ // 操作结果：构造一个空的线性表L
	L=NULL; // 指针为空
}
//带
void InitList(LinkNode &L)
{ // 操作结果：构造一个空的线性表L
	L=(LinkNode)malloc(sizeof(LNode)); // 产生头结点，并使L指向此头结点
	if(!L) // 存储分配失败
		exit(OVERFLOW);
	L->next=NULL; // 指针域为空
}

不带头结点{

初始化第一个节点的指针

}

带头结点{

 创建节点

如果创建失败 则返回错误

否则初始化第一个节点

}

2.销毁链表和清空链表

//不带
#define DestroyList ClearList // DestroyList()和ClearList()的操作是一样的
void ClearList(LinkNode &L)
{ // 初始条件：线性表L已存在。操作结果：将L重置为空表
	LinkNode p;
	//int i=0;
	while(L!=NULL) // L不空
	{
		p=L;  // p指向首元结点
		L=L->next;// L指向第2个结点(新首元结点)
		//printf("i=%d,L->next=%x\n",++i,L);
		free(p); // 释放首元结点
		//printf("p=%x\n",p);

	}
	/*
	LinkNode p;
	while(L!=NULL){
		p=L->next;
		free(L);
		L=p;
	}
	*/
}}
}
//带
void DestroyList(LinkNode &L)
{ // 初始条件：线性表L已存在。操作结果：销毁线性表L
	LinkNode p;
	while(L)
	{
		p=L->next;//把第一个节点地址赋值给p,p指向第一个节点
		free(L);//清空头结点
		//printf("****p=%d\n",p);
		//printf("************L=%d\n",L);
		L=p;//将第一个节点(新)的地址给
	}
}
//带
void ClearList(LinkNode L) // 不改变L
{ // 初始条件：线性表L已存在。操作结果：将L重置为空表
	LinkNode pre,nex;
	pre=L->next; // p指向第一个结点
	while(pre!=NULL) // 没到表尾
	{
		nex=pre->next;
		free(pre);
		pre=nex;
	}
	L->next=NULL; // 头结点指针域为空
}

L指针向右走

1方法.p=L->next; L=p;

3方法p=L,L=L->next;L=p

L指针不移动

1方法pre=L->next; nex=pre->next; pre=nex;

L指针向左移动(s为新节点)

1.s->next=L;L=s

3.判断是否是空链表

//不带
Status ListEmpty(LinkNode L)
{ // 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
	if(L==NULL)
		return TRUE;
	else
		return FALSE;
}
//带
Status ListEmpty(LinkNode L)
{ // 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
	if(L->next==NULL) // 空
		return TRUE;
	else
		return FALSE;
}

4.求链表的长度

//不带
int ListLength(LinkNode L)
{ // 初始条件：线性表L已存在。操作结果：返回L中数据元素个数
	int count=0;
	LinkNode p=L;
	while(p!=NULL) // p指向结点(没到表尾)
	{
		p=p->next; // p指向下一个结点
		++count;
		//printf("ListLength=%d\n",i);
	}
	return count;
}
//带
int ListLength(LinkNode L)
{ // 初始条件：线性表L已存在。操作结果：返回L中数据元素个数
	int count=0;
	LinkNode p=L->next; // p指向第一个结点
	while(p!=NULL) // 没到表尾
	{
		++i;
		p=p->next;
	}
	return count;
}

int x=a;

while(a<b){

 a++;

}

则循环中执行了b-a次;

InitList(L);
	for (j=0;j<10;j++){
		ListInsert(L,j+1,100-j);
	}
	LinkList p=L;
	int count=0;
	while (p){
		printf("p=%x,%d,%d\n",p,p->data,count);
		p=p->next;
		count++;
	}
	printf("count=%d",count-1);

我们会发现带有10个元素的链表中(带头结点),while执行了11次

如果p=L->next;

InitList(L);
	for (j=0;j<10;j++){
		ListInsert(L,j+1,100-j);
	}
	LinkList p=L->next;
	int count=0;
	while (p){
		printf("p=%x,%d,%d\n",p,p->data,count);
		p=p->next;
		count++;
	}
	printf("count=%d",count);

所以我们想知道元素的index下标的话要制定规则

|头|->|第1个|->|第2个|->............................|第n个|->null

0         1               2                                        n         n+1

|头|->|第1个|->|第2个|->............................|第n个|->null

             0         1               2                           n-1       n

|头|->|第1个|->|第2个|->.............................|第n个|->null

            1                2                                        n       n+1

5.通过位置返回元素

//不带
Status GetElem(LinkNode L,int pos,ElemType &e)
{ // L为不带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
	int j=1;
	LinkNode p=L;
	if(i<1) // i值不合法
		return ERROR;
	while(j<i&&p) // 没到第i个元素，也没到表尾
	{
		j++;
		p=p->next;
	}
	if(j==i) // 存在第i个元素
	{
		e=p->data;
		return OK;
	}
	else
		return ERROR;
}
//带
Status GetElem(LinkNode L,int i,ElemType &e) // 算法2.8
{ // L为带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
	int j=0; // j为计数器
	LinkNode p=L->next; // p指向第一个结点
	while(p&&j<i) // 顺指针向后查找，直到p指向第i个元素或p为空
	{	
		j++;
		p=p->next;
	}
	if(!p||j>i) // 第i个元素不存在
		return ERROR;
	e=p->data; // 取第i个元素
	return OK;
}

6.通过元素返回元素所在的位置

//不带
int LocateElem(LinkNode L,ElemType e,Status(*compare)(ElemType,ElemType))
{ // 初始条件：线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0)
	// 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
	//           若这样的数据元素不存在，则返回值为0
	int i=0;
	LinkNode p=L;
	while(p)
	{
		i++;
		if(compare(p->data,e)) // 找到这样的数据元素
			return i;
		p=p->next;
	}
	return 0;
}
//带
int LocateElem(LinkNode L,ElemType e,Status(*compare)(ElemType,ElemType))
{ // 初始条件: 线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0)
	// 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。
	//           若这样的数据元素不存在，则返回值为0
	int i=0;
	LinkNode p=L->next;
	while(p)
	{
		i++;
		if(compare(p->data,e)) // 找到这样的数据元素
			return i;
		p=p->next;
	}
	return 0;
}

返回元素前驱

//不带
Status PriorElem(LinkNode L,ElemType cur_e,ElemType &pre_e)
{ // 初始条件：线性表L已存在
	// 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
	//           返回OK；否则操作失败，pre_e无定义，返回INFEASIBLE
	LinkNode q,p=L; // p指向第一个结点
	while(p->next) // p所指结点有后继
	{
		q=p->next; // q为p的后继
		if(q->data==cur_e)
		{
			pre_e=p->data;
			return OK;
		}
		p=q; // p向后移
	}
	return INFEASIBLE;
}
//带
Status PriorElem(LinkNode L,ElemType cur_e,ElemType &pre_e)
{ // 初始条件: 线性表L已存在
	// 操作结果: 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
	//           返回OK；否则操作失败，pre_e无定义，返回INFEASIBLE
	LinkNode q,p=L->next; // p指向第一个结点
	while(p->next) // p所指结点有后继
	{
		q=p->next; // q为p的后继
		if(q->data==cur_e)
		{
			pre_e=p->data;
			return OK;
		}
		p=q; // p向后移
	}
	return INFEASIBLE;
}

返回后驱

//不带
Status NextElem(LinkNode L,ElemType cur_e,ElemType &next_e)
{ // 初始条件：线性表L已存在
	// 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
	//           返回OK；否则操作失败，next_e无定义，返回INFEASIBLE
	LinkNode p=L; // p指向第一个结点
	while(p->next) // p所指结点有后继
	{
		if(p->data==cur_e)
		{
			next_e=p->next->data;
			return OK;
		}
		p=p->next;
	}
	return INFEASIBLE;
}
//带
Status NextElem(LinkNode L,ElemType cur_e,ElemType &next_e)
{ // 初始条件：线性表L已存在
	// 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
	//           返回OK;否则操作失败，next_e无定义，返回INFEASIBLE
	LinkNode p=L->next; // p指向第一个结点
	while(p->next) // p所指结点有后继
	{
		if(p->data==cur_e)
		{
			next_e=p->next->data;
			return OK;
		}
		p=p->next;
	}
	return INFEASIBLE;
}

插入节点

//不带
Status ListInsert(LinkNode &L,int pos,ElemType e)
{ // 在不带头结点的单链线性表L中第i个位置之前插入元素e
	int count=0;
	int index=pos-1;//链表的指针
	LinkNode p=L,s;
	if(index<0) // i值不合法
		return ERROR;
	s=(LinkNode)malloc(sizeof(LNode)); // 生成新结点
	s->data=e; // 给s的data域赋值
	if(index==0) // 插在表头
	{
		s->next=L;
		L=s; // 改变L
	}else{ // 插在表的其余处
		while(p!=NULL&&count<index-1) // 寻找第i-1个结点
		{
			p=p->next;
			++count;
		}
		if(!p) // i大于表长+1
			return ERROR;
		s->next=p->next;
		p->next=s;
	}
	return OK;
}
//带
Status ListInsert(LinkNode L,int pos,ElemType e) // 算法2.9。不改变L
{ // 在带头结点的单链线性表L中第i个位置之前插入元素e
	int count=0;
	int index=pos-1;
	LinkNode p=L,s;
	while(p!=NULL&&count<index) // 寻找第i-1个结点
	{
		p=p->next;
		++count;
	}
	if(p==NULL||count>index) // i小于1或者大于表长
		return ERROR;
	s=(LinkNode)malloc(sizeof(LNode)); // 生成新结点
	s->data=e; // 插入L中
	s->next=p->next;
	p->next=s;
	return OK;
}

pos是逻辑位置

index是物理地址位置,所以index=pos-1

count是记录指针的移动次数

删除节点

//不带
Status ListDelete(LinkNode &L,int pos,ElemType &e)
{ // 在不带头结点的单链线性表L中，删除第i个元素，并由e返回其值
	int j=1;
	LinkNode p=L,q;
	if(i==1) // 删除第1个结点
	{
		L=p->next; // L由第2个结点开始
		e=p->data;
		free(p); // 删除并释放第1个结点
	}
	else
	{
		while(p->next&&j<i-1) // 寻找第i个结点，并令p指向其前趋
		{					
			p=p->next;
			j++;		
		}
		if(!p->next||j>i-1) // 删除位置不合理
			return ERROR;
		q=p->next; // 删除并释放结点
		p->next=q->next;
		e=q->data;
		free(q);
	}
	return OK;
}
//带
Status ListDelete(LinkNode L,int i,ElemType &e) // 算法2.10。不改变L
{ // 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
	int j=0;
	LinkNode p=L,q;
	while(p->next&&j<i-1) // 寻找第i个结点，并令p指向其前驱
	{
		p=p->next;
		j++;
	}
	if(!p->next||j>i-1) // 删除位置不合理
		return ERROR;
	q=p->next; // 删除并释放结点
	p->next=q->next;
	e=q->data;
	free(q);
	return OK;
}
//不带
void ListTraverse(LinkNode L,void(*vi)(ElemType))
{ // 初始条件：线性表L已存在。操作结果：依次对L的每个数据元素调用函数vi()
	LinkNode p=L;
	while(p)
	{
		vi(p->data);
		p=p->next;
	}
	printf("\n");
}
//带
void ListTraverse(LinkNode L,void(*vi)(ElemType))
// vi的形参类型为ElemType，与bo2-1.cpp中相应函数的形参类型ElemType&不同
{ // 初始条件：线性表L已存在。操作结果：依次对L的每个数据元素调用函数vi()
	LinkNode p=L->next;
	while(p)
	{
		vi(p->data);
		p=p->next;
	}
	printf("\n");
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

i_am_kiki
关注
C语言描述：单向链表的相关操作
Joyee的博客
03-26 466
先找到课本，熟悉单向链表的结构； 关键词： 头结点，头指针，表头，表尾，数据域，地址域（指针域）1，生成空表销毁链表 2，清空链表 3，是否为空表 4，表长 5，查找第i个结点的值6，查找第一个等于e的结点在链表的位置
bo2-3.c 带有头结点单链表的基本操作
SJMP
10-28 1218
void InitList(LinkList *L)  { /* 操作结果：构造一个空的线性表L */    *L=(LinkList)malloc(sizeof(struct LNode)); /* 产生头结点，并使L指向此头结点 */    if(!*L) /* 存储分配失败 */      exit(OVERFLOW);    (*L)->next=NULL; /* 指针域为空 *
数据结构c语言实现之单链表的应用
云守护的专栏
12-08 1560
//c语言实现,单链表实现学生健康登记表,参考严蔚敏书本代码和《数据结构算法实现及解析》 #include #include #include // malloc()等 #include // INT_MAX等 #include // EOF(=^Z或F6),NULL #include // atoi() #include // eof() #include // floor(),ceil(),a
顺序链表的一些操作
zhouyelihua
08-19 1207
#include #include #include using namespace std; class list { private : int*array_pointer; int arraysize; int length; int increment; publ
单向链表
Godruoyi
04-20 1485
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 单向链表的数据结构可以分为两部分：数据域和指针域，数据域存储数据，指针域指向下一个储存节点的地址。/*線性表的單鏈表存儲结構*/ typedef struct LNode{ ElemType data; struct LNode *next; }LNode, *LinkList;/*带有头
DSA-LINKED-LIST:基本链表操作
03-25
DSA链接列表 基本链表操作
harmonyos2-algorithm-linked-list:算法链表
07-01
链表是一种练习递归的数据结构，本系列包含链表的许多基本操作。 检查lib/的解决方案和test/的单元测试。 注意：一些 kata 需要 TCO（尾调用优化）来测试大型链表。 TCO 仅在具有严格模式和--harmony标志的 Node.js ...
DS-PTA-Coding-两个有序链表的合并pta
最新发布
10-27
合并两个有序链表是链表操作中的一个基本问题，它涉及到将两个已经排序的链表组合成一个新的有序链表。 在合并两个有序链表的过程中，算法的基本思想是从两个链表的头部开始，比较各自当前节点的值，根据大小关系...
leetcode-Linked-List-2:链表-2
06-29
此问题可能涉及到链表的基本操作，如创建、插入节点、遍历或删除节点。链表不同于数组，它的元素不是存储在连续的内存位置，而是通过指针连接。因此，理解如何在链表中添加或移除元素是至关重要的。例如，可能需要...
003-FreeRTOS202212-4003-链表节点初始化
11-11
链表节点的初始化是FreeRTOS中的一种重要的操作，因为链表节点是FreeRTOS中的基本数据结构，许多操作都依赖于链表节点的正确初始化。 在FreeRTOS中，链表节点的初始化是通过函数vListInitialiseItem来实现的，该...
LocateElem()&ListTraverse;()实例说明
10-31
LocateElem(L,e,compare())&ListTraverse;(L,visit())实例说明
线性表的单链表表示和实现
C语言、数据结构、算法
11-27 236
/* c2-2.h 线性表的单链表存储结构 */ struct LNode { ElemType data; struct LNode *next; }; typedef struct LNode *LinkList; /* 另一种定义LinkList的方法 */   /* bo2-2.c 单链表线性表(存储结构由c2-2.h定义)的基本操作(12个) ...
bo3-4.c 用单链表的基本操作实现链队列(存储结构由c3-2.h定义)的基本操作(9个)
SJMP
11-07 1317
由c3-2.h和c2-2.h对比可见，单链队列和单链表结构有相同之处。单链队列是带有头结点的单链表。他的头指针相当于单链表的头指针。因此队列操作时线性表操作的子集，所以bo3-2.c中的基本操作也可以用单链表的基本操作来代替。这样既可以充分利用现有资源，减小编程工作量，又可以更清楚的看出队列和线性表的内在联系和共性。  /* bo3-6.c 用单链表的基本操作实现链队列(存储结构由c3-2.h定
数据结构笔记（六）-- 双向链表
m0_43609475的博客
05-30 755
带头结点的双向循环链表的实现 一、双向链表的概念 双向链表的每个结点有两个指针，一个指针指向该结点的前驱，一个指针指向该结点的后继。 二、双向链表的存储结构 //线性表的双向链表存储结构 typedef struct DuLNode { ElemType data; DuLNode *prior, *next; }DuLNode, *DuLinkList; 三、带有头结点的双向循环链表的样子 四、带头结点的双向循环链表的操作 五、操作的实现 1、 创建空的双向循环链表L void InitLis
一：线性表:链表的初始化操作及应用
@76135327的博客
11-17 7636
内容节点结构InitList(*L):初始化一个线性表ListEmpty(L):判断是否为空表ClearList(*L):清空线性表GetElem(L,i,*e):将表中的第i个元素，返回给eLocateElem(L,e)：查找表中是否有与e相等元素ListInsert(L,i,e):在线性表的第i个位置插入元素eListDelete(*L,i,*e):删除线性表中的第i个元素，并将值返回给eListLength(L): 返回线性表元素的个数头插法插入元素尾插法求两个线性表La和Lb的并集求两个线性表La和
单链表的基本操作
qq_62949330的博客
03-18 671
单链表的基本操作
【头歌】循环单链表的基本操作
qq_39977056的博客
01-25 3849
an），LB=（b1，b2，…算法思想： 先找到两个链表的尾，并分别由指针p、q指向它们，然后将第一个链表的尾结点与第二个表的第一个结点链接起来，并修改第二个表的尾结点，使它的链域指向第一个表的头结点。将尾结点的next域用一个特殊值NULL（空指针，不指向任何结点，只起标志作用）表示，这样的单链表为非循环单链表，通常所说的单链表都是指这种类型的单链表。=L作为循环条件，当p==L时循环结束，此时p回过来指向头结点，所以p应该初始化指向第一个数据结点而不是头结点，否则循环内的语句不会执行。
C++ 头插法 链表
laocooon的博客
03-25 451
10010 Liyi M 2000 5 23 45 10020 Lier M 2001 2 3 62.5 10030 Lisan F 2000 10 14 92.5 10040 Lisi F 2002 7 23 87 10050 Liwu M 1999 8 6 78 学号:10050 姓名:Liwu 性别:M 出生日期:1999-8-6 成绩:78.0 学号:10040 姓名:Lisi 性别:F 出生日期:2002-7-23 成绩...
链表的操作
Sun19910114的专栏
08-19 571
#include #include #include   #include #include #include #include #include #include #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 typedef int Status; typedef int Boo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值