单链表（不带头结点）的基本操作

最新推荐文章于 2024-04-22 21:00:01 发布
最新推荐文章于 2024-04-22 21:00:01 发布
阅读量1.4w 收藏 213
点赞数 51
分类专栏： C语言 单链表 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H643511/article/details/108959382
版权

不带头节点的单链表

       相对于带头结点的单链表对每一个结点的操作比较统一，不带头结点的单链表需要对第一个结点进行特殊的对比操作。

1、操作实现

1.1单链表的定义

通过结构体定义每个结点的数据格式

typedef int ElemType;//元素的类型

typedef struct LNode
{
	ElemType data;
	LNode* next;
}LNode,*LinkList;

1.2初始化单链表

通过对单链表之间设置为空完成初始化

//初始化单链表
void InitList(LinkList &L)
{
	L = NULL;
}

1.3得到单链表表长

通过遍历实现获得单链表表长，如果第一个结点就为空则返回0

//得到表长
int Length(LinkList L)
{
	int length = 0;
	if(L == NULL)//首先判断第一个结点是否为空
		return length;
	else
		length++;
	while(L->next != NULL)
	{
		length++;
		L = L->next;
	}
	return length;
}

1.4单链表的判空操作

通过判断第一个结点是否为空，判断单链表是否为空

//判断的单链表是否为空表
bool Empty(LinkList L)
{
	if(L == NULL)
		return true;
	else
		return false;
}

1.5建立单链表

建立单链表分头插法和尾插法两种方式

1.5.1头插法

每次插入都在表头的位置

//头插法建立单链表
LinkList List_HeadInsert(LinkList &L)
{
	InitList(L);//初始化
	LNode *s;
	ElemType e;
	printf("输入元素（输入9999为停止）");
	scanf("%d",&e);
	if(e != 9999)//首先对第一个结点赋值
	{
		L = (LinkList)malloc(sizeof(LNode));
		L->next = NULL;
		L->data = e;
		scanf("%d",&e);
		while(e != 9999){
			s = (LNode*)malloc(sizeof(LNode));
			s->data = e;
			s->next = L->next;
			L->next = s;
			scanf("%d",&e);
		}
	}
	return L;
}

1.5.2尾插法

每次插入都在表尾的位置

//尾插法建立单链表
LinkList List_TailInsert(LinkList &L)
{
	InitList(L);//初始化
	LNode *s,*r;
	ElemType e;
	printf("输入元素（输入9999为停止）");
	scanf("%d",&e);
	if(e != 9999)//首先对第一个结点赋值
	{
		L = (LinkList)malloc(sizeof(LNode));
		L->data = e;
		r = L;
		scanf("%d",&e);
		while(e != 9999)
		{
			s = (LNode*)malloc(sizeof(LNode));
			s->data = e;
			r->next = s;
			r = s;
			scanf("%d",&e);
		}
	}
	r->next = NULL;
	return L;
}

1.6按值查找结点

1.6.1得到一个结点

//在表中查找第一个与查找元素相同位置的结点
LNode* LocateElem_LNode(LinkList L, ElemType e)
{
	int j = 1;
	LNode* p = L;
	if(p->data == e)//首先查看第一个结点
		return p;
	else
		p = p->next;
	while(p != NULL && p->data != e)
	{
		p = p->next;
		j++;
	}
	if(j == Length(L))
	{
		return NULL;
	}
	return p;
}

1.6.2得到该结点的位置

int LocatedElem(LinkList L, ElemType e)
{
	int j = 1;
	LNode* p = L;
	if(p->data == e)
		return j;
	else
		p = p->next;
	while(p != NULL && p->data != e)
	{
		p = p->next;
		j++;
	}
	if(j == Length(L))//到最后一位依然没找到
	{
		return 0;
	}
	return j+1;
}

1.7按位查找结点

1.7.1得到一个结点

//得到表中某一位置的结点
LNode* GetElem_LNode(LinkList L, int i)
{
	LNode *p = L;
	if(i < 0 || i > Length(L))
		return NULL;
	for(int j = 1; j < i; j++)
	{
		p = p->next;
	}
	return p;
}

1.7.2得到该位置结点的数据

//获得某一位置元素的值
ElemType GetElem(LinkList L, int i)
{
	LNode *p = L;
	if(i < 0 || i > Length(L))
		return 0;
	for(int j = 1; j < i; j++)
	{
		p = p->next;
	}
	return p->data;
}

1.8插入数据

向表中对应位置插入数据

//向表中插入数据
bool ListInsert(LinkList &L, int i, ElemType e)
{
	if(i < 1 || i > Length(L)+1)
		return false;
	LNode *s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	if(i == 1)
	{
		s->next = L;
		L = s;
		return true;
	}
	LNode *p = GetElem_LNode(L,i-1);
	s->next = p->next;
	p->next = s;
	return true;
}

1.9删除数据

删除表中某一位置的数据

//删除表中某位置的数据
bool ListDelete(LinkList &L, int i, ElemType &e)
{
	if(i < 1 || i > Length(L))//位置不在表中则返回false
		return false;
	if(L == NULL)//表为空则返回false
		return false;
	LNode* p;
	LNode* q;
	if(i == 1)//删除第一个结点的情况
	{
		p = L;
		e = p->data;
		q = L->next;
		free(p);//释放p结点
		L = q;
		return true;
	}
	p = GetElem_LNode(L,i-1);
	q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

1.10输出表中数据

通过遍历的方式打印表中数据

//打印单链表的所有数据
void PrintList(LinkList L)
{
	printf("表中的数据为：");
	if(L != NULL)
	{
		printf("%d ",L->data);
		while(L->next != NULL)
		{
			L = L->next;
			printf("%d ",L->data);
		}
	}
	printf("\n");
}

1.11清空表

删除表中所有数据

//清空表的数据
bool ClearList(LinkList &L)
{
	if(L == NULL)//表空则返回false
		return false;
	LNode *p;
	while(L->next != NULL)//删除第一个结点之后的所有结点
	{
		p = L->next;
		L->next = p->next;
		free(p);
	}
	L = NULL;//删除第一个结点
	return true;
}

2、全部代码

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

typedef int ElemType;//元素的类型

typedef struct LNode
{
	ElemType data;
	LNode* next;
}LNode,*LinkList;

//初始化单链表
void InitList(LinkList &L)
{
	L = NULL;
}

//得到表长
int Length(LinkList L)
{
	int length = 0;
	if(L == NULL)//首先判断第一个结点是否为空
		return length;
	else
		length++;
	while(L->next != NULL)
	{
		length++;
		L = L->next;
	}
	return length;
}

//判断的单链表是否为空表
bool Empty(LinkList L)
{
	if(L == NULL)
		return true;
	else
		return false;
}

//头插法建立单链表
LinkList List_HeadInsert(LinkList &L)
{
	InitList(L);//初始化
	LNode *s;
	ElemType e;
	printf("输入元素（输入9999为停止）");
	scanf("%d",&e);
	if(e != 9999)//首先对第一个结点赋值
	{
		L = (LinkList)malloc(sizeof(LNode));
		L->next = NULL;
		L->data = e;
		scanf("%d",&e);
		while(e != 9999){
			s = (LNode*)malloc(sizeof(LNode));
			s->data = e;
			s->next = L->next;
			L->next = s;
			scanf("%d",&e);
		}
	}
	return L;
}

//尾插法建立单链表
LinkList List_TailInsert(LinkList &L)
{
	InitList(L);//初始化
	LNode *s,*r;
	ElemType e;
	printf("输入元素（输入9999为停止）");
	scanf("%d",&e);
	if(e != 9999)//首先对第一个结点赋值
	{
		L = (LinkList)malloc(sizeof(LNode));
		L->data = e;
		r = L;
		scanf("%d",&e);
		while(e != 9999)
		{
			s = (LNode*)malloc(sizeof(LNode));
			s->data = e;
			r->next = s;
			r = s;
			scanf("%d",&e);
		}
	}
	r->next = NULL;
	return L;
}

//在表中查找第一个与查找元素相同位置的结点
LNode* LocateElem_LNode(LinkList L, ElemType e)
{
	int j = 1;
	LNode* p = L;
	if(p->data == e)//首先查看第一个结点
		return p;
	else
		p = p->next;
	while(p != NULL && p->data != e)
	{
		p = p->next;
		j++;
	}
	if(j == Length(L))
	{
		return NULL;
	}
	return p;
}
//在表中查找第一个与查找元素相同的结点的位置
int LocatedElem(LinkList L, ElemType e)
{
	int j = 1;
	LNode* p = L;
	if(p->data == e)
		return j;
	else
		p = p->next;
	while(p != NULL && p->data != e)
	{
		p = p->next;
		j++;
	}
	if(j == Length(L))//到最后一位依然没找到
	{
		return 0;
	}
	return j+1;
}

//得到表中某一位置的结点
LNode* GetElem_LNode(LinkList L, int i)
{
	LNode *p = L;
	if(i < 0 || i > Length(L))
		return NULL;
	for(int j = 1; j < i; j++)
	{
		p = p->next;
	}
	return p;
}
//获得某一位置元素的值
ElemType GetElem(LinkList L, int i)
{
	LNode *p = L;
	if(i < 0 || i > Length(L))
		return 0;
	for(int j = 1; j < i; j++)
	{
		p = p->next;
	}
	return p->data;
}

//向表中插入数据
bool ListInsert(LinkList &L, int i, ElemType e)
{
	if(i < 1 || i > Length(L)+1)
		return false;
	LNode *s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	if(i == 1)
	{
		s->next = L;
		L = s;
		return true;
	}
	LNode *p = GetElem_LNode(L,i-1);
	s->next = p->next;
	p->next = s;
	return true;
}

//删除表中某位置的数据
bool ListDelete(LinkList &L, int i, ElemType &e)
{
	if(i < 1 || i > Length(L))//位置不在表中则返回false
		return false;
	if(L == NULL)//表为空则返回false
		return false;
	LNode* p;
	LNode* q;
	if(i == 1)//删除第一个结点的情况
	{
		p = L;
		e = p->data;
		q = L->next;
		free(p);//释放p结点
		L = q;
		return true;
	}
	p = GetElem_LNode(L,i-1);
	q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

//打印单链表的所有数据
void PrintList(LinkList L)
{
	printf("表中的数据为：");
	if(L != NULL)
	{
		printf("%d ",L->data);
		while(L->next != NULL)
		{
			L = L->next;
			printf("%d ",L->data);
		}
	}
	printf("\n");
}

//清空表的数据
bool ClearList(LinkList &L)
{
	if(L == NULL)//表空则返回false
		return false;
	LNode *p;
	while(L->next != NULL)//删除第一个结点之后的所有结点
	{
		p = L->next;
		L->next = p->next;
		free(p);
	}
	L = NULL;//删除第一个结点
	return true;
}

int main()
{
	LinkList L;
	LNode* p;
	ElemType e;
	InitList(L);
	if(Empty(L))//判空
		printf("表是空表\n");
	else
		printf("表不是空表\n");
	List_TailInsert(L);//尾插法
	PrintList(L);
	printf("表长为%d\n",Length(L));
	p = LocateElem_LNode(L,2);
	printf("6的位置%d\n",LocatedElem(L,6));
	printf("2号位置的数据%d\n",GetElem(L,2));
	ListInsert(L,2,3);//在第2号位置插入数据3
	printf("插入后的数据为");
	PrintList(L);
	ListDelete(L,1,e);//删除一号位置的数据
	printf("删除的元素为%d\n",e);
	printf("删除后的数据为");
	PrintList(L);
	ClearList(L);//清空表
	if(Empty(L))//清空之后判空
		printf("表是空表\n");
	else
		printf("表不是空表\n");
	return 0;
}
Mr.火
关注
  • 51
    点赞
  • 踩
  • 213
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
专栏目录
不带头结点的单链表c语言,不带头结点的单链表的实现（C语言）
weixin_42297675的博客
05-21 1599
不带头结点的单链表的实现(C语言)不带头结点的单链表的实现(C语言)链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示线性表称作线性链表(单链表)单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。因此，查找第 i 个数据元素的基本操作...
C语言数据结构——单链表(不带头)
qq_65980796的博客
02-13 2237
一、单链表：1.1 概念、1.2 链表结构分析、1.3 单链表的基本操作、1.4 单链表的基本操作源码。
2.3不带头结点的单链表
我走的每一步都算数
08-01 3028
InitList(&L)：初始化表。构造一个空的线性表L，分配内存空间。 ListInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e。 ListDelete(&L,i,&e)：删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。 LocateElem(L,e)：按值查找操作。在表L中查找具有给定关键字值的元素。 GetElem(L,i)：按位查找操作。获取表L中第i个位置的元素的值。 其他常用操作： Length(L)：求表长。返回线性表L
不带头结点的双链表 和 带头结点的双链表
最新发布
weixin_70744989的博客
04-22 191
前插法创建一个链表
不带头结点的单链表的基本操作
good_skills的博客
10-18 411
@[不带头结点的单链表的基本操作] 单链表的基本操作创建、输入、打印、求长度、查找、插入、删除、释放 头文件 #pragma once /*before实现单链表的创建、输入、打印、 求长度、查找、插入、删除、释放等操作*/ #include <stdio.h> #include <stdlib.h> typedef char ElemType; typedef struct node { //链表结点 ElemType data;
C语言 不带头结点的单链表的实现和相关操作。
ok_阿伟的博客
07-13 1609
C语言 不带头结点的单链表的实现和相关操作。 #include<stdio.h> #include<stdlib.h> typedef int DAT; typedef struct node//定义一个结构体 { DAT data;//存放数据 struct node *next;//指向下一个结构体的指针 }Node; void init_list(Node **pL)//初始化 { (*pL) = NULL; } Node* make_node(D
【基础算法】单链表的OJ练习(3) # 移除链表元素 # 相交链表 #
Welcome home | Jian Liao 's blog
03-04 954
本章的OJ练习也是相对简单的，只要能够理解解题的思路，并且依照这个思路能够快速的写出代码，我相信，你的链表水平已经足够了。对于OJ练习（2）,其中两道题都可运用快慢指针的解题思路，这使得两个题都只需要遍历一次链表即可解答。对于本章，是链表的OJ练习的最后一篇较为简单的章节，后续的OJ练习将会上难度。对于单链表的题目练习，最重要的是思路，我们在数据结构阶段要养成画图的习惯，因为它能帮助我们更好的理解。后续还会有单链表相关的题目练习。
数据结构实验报告（二）——不带头结点的单链表
future_dreaming的博客
01-10 1039
不带头结点的单链表的系列操作
不带头节点的单链表操作
w_lixiang的博客
06-05 766
对不带头节点的单链表的基本操作
数据结构：不带头结点单链表的实现及其一些基本操作.cpp
08-03
不带头结点，不带头结点，不带头结点！ 实现单链表及其一些基本操作函数（不带头结点） 1.头文件包含 2.宏定义及节点类型描述 3.初始化、判断是否为空 4.指定位置插入操作 5.在p节点后插入元素e 6.在p节点前插入元素e 7.删除操作：删除第i个节点，元素值有e传回 8.删除指定节点，不能删除尾部节点 9.按位序查找和按值查找 10.尾插法和头插法建立单链表（包含初始化） 11.表长和简单打印 12.其他简单封装（_fz表示封装） main函数简单测试
数据结构 不带头结点的单链表代码
12-16
数据结构 用不带头结点的单链表实现遍历、插入、查询和删除等功能
单链表的基本操作（不带头结点）
minamiximawa的博客
08-10 778
Node.h #ifndef NODE_H #define NODE_H //不带头结点的单链表 typedef struct NODE { int value; struct NODE* next; }Node,*pNode; #endif // NODE_H List.h #ifndef LIST_H #define LIST_H #include &amp;amp;quot;...
不带头结点单链表的基本操作
fallingskies
03-05 2497
定义结点 typedef struct LNode{ int data; //每个节点存放一个数据元素 struct LNode *next; //指针指向下一个节点 }LNode,*LinkList; //LinkList等价于LNode *,前者强调链表，后者强调结点 初始化 //初始化一个空的单链表 bool InitList(LinkList &L){ L = NU...
数据结构：单链表（不带头结点）
Kobe51920的博客
01-05 735
nlist.h #pragma once typedef struct NNode { int data; struct NNode *next; }NNode,*NList; //链表初始化 void InitList(NList *pplist); //头插 bool Insert_head(NList *pplist,int val); //尾插 bool Inse...
C语言实现单链表（不带头结点）的基本操作
热门推荐
乞力马扎罗的雪CYF的博客
02-24 1万+
链表在数据结构和算法中的重要性不言而喻。这里我们要用C来实现链表（单链表）中的基本操作。对于链表的基本概念请参考《数据结构与算法之链表》这篇博客。示例代码上传至 https://github.com/chenyufeng1991/LinkedList 。（1）定义单链表的节点类型typedef int elemType ; // 定义单链表结点类型 typedef struct ListNode
C语言实现单链表(不带头结点)
lxt-st
04-29 1530
在之前的博客中，我写了有关线性表的顺序存储结构的顺序表，顺序表的特点是逻辑关系上，相邻的两个元素在物理位置上也相邻，因此可以随机存取表中任一元素，但是，它在进行插入删除操作时，需要移动大量的数据元素，故而在下面的内容中，讨论的是线性表的另一种存储结构（链式存储结构）中的不带头节点的单链表，由于链表不要求逻辑上相邻的元素在物理位置上也相邻，所以它没有顺序表的弱点，但是也失去了它的优点。 ...
不带头节点的单链表——基本函数
阿巴卡的博客
08-16 1349
链表分为带头节点和不带头节点，头节点就是在链表的首个节点处不存放数据，而是存放有关此链表的一些信息 今天我的这篇博客是有关不带头节点的单链表实现 结构体： typedef int DataType; typedef struct Node { DataType data; struct Node* next; }Node, *pNode, List, *pList; 基...
数据结构——单链表(带头结点和不带头结点)
csdn_wanziooo的博客
09-09 6009
1 //单链表：通过各结点的链接指针来表示结点间的逻辑关系，长度可扩充，遍历或查找 2 //只能从指针的指示的首元结点开始，跟随链接指针逐个结点进行访问，进行删除或插 3 //入时，只需修改相关结点的指针域，但链接表比顺序表需要的存储空间多 4 5 6 //单链表的结构定义 7 typedef int DataType; 8 typedef struct node
单链表不带头结点头插法
10-17
单链表不带头结点的头插法，即每次将新节点插入到链表的第一个位置。具体实现步骤如下： 1. 创建一个新节点，并将数据存储在该节点中。 2. 将新节点的 next 指针指向原链表的第一个节点。 3. 将链表的头指针指向新节点。 下面是一个示例代码： ```c++ struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; ListNode* insertAtHead(ListNode* head, int val) { ListNode* newNode = new ListNode(val); newNode->next = head; head = newNode; return head; } ```
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值