数据结构-单链表

已于 2024-05-25 16:35:15 修改
阅读量389 收藏
点赞数 13
分类专栏： 数据结构 文章标签： c语言 数据结构 算法
于 2024-05-25 16:30:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W2814595682/article/details/139199304
版权

一、链表初始化

typedef struct LNode
{
	int data;
	struct LNode *next;
} LNode, *LinkList;
// 链表初始化
bool ListInit(LinkList &L)
{

	L = (LNode *)malloc(sizeof(LNode));
	if (L == NULL)
	{
		perror("malloc LNode fault\n");
		return false;
	}
	L->next = NULL;
	return true;
}

二、链表的插入

（1）按位序插入
// 按位序插入，指插入节点为第n个节点
bool ListNodeInsert(LinkList &L, int i, int elem)
{
	if (i < 1)
	{
		perror("insert element falut: i < 1");
		return false;
	}
	LNode *p = FindNode(L, i - 1);

	return InsertNode(p, elem);
}
 （2）第i个节点之后插入
// 第i个节点之后插入一个新的节点
bool InsertNextNode(LinkList &L, int i, int elem)
{
	if (i < 1)
	{
		perror("insert element falut: i < 1");
		return false;
	}

	LNode *p = FindNode(L, i);

	return InsertNode(p, elem);
}
（3）指定节点前面插入
// 在指定节点前面插入一个节点
bool InsertFrontNode(LinkList &L, int i, int elem)
{
	if (i < 1)
	{
		perror("insert element falut: i < 1");
		return false;
	}
	LNode *p = FindNode(L, i);

	if (p == NULL)
	{
		perror("insert i Illegal");
		return false;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if (s == NULL)
	{
		perror("Malloc LNode fault");
		return false;
	}
	s->next = p->next;
	s->data = p->data;
	p->next = s;
	p->data = elem;
	return true;
}
（4）插入节点详细描述
// 插入节点详细步骤
bool InsertNode(LNode *p, int elem)
{
	if (p == NULL)
	{
		perror("insert i Illegal");
		return false;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if (s == NULL)
	{
		perror("Malloc LNode fault");
		return false;
	}
	s->data = elem;
	s->next = p->next;
	p->next = s;
	return true;
}

三、查找

（1）按位序查找
// 按位序查找
bool GetElem(LinkList &L, int i, int &elem)
{
	if (i < 1)
	{
		perror("GetElem falut: i < 1");
		return false;
	}
	LNode *p = FindNode(L, i);
	if (p == NULL)
	{
		perror("Getelem's Node i Illegal");
		return false;
	}
	elem = p->data;
	return true;
}
（2）按值查找
// 按值查找
LNode *FindElem(LinkList &L, int elem)
{
	LNode *p = L->next;
	while (p != NULL && p->data != elem)
	{
		p = p->next;
	}
	return p;
}
（3）查找指定节点
// 查找指定节点
LNode *FindNode(LinkList &L, int i)
{
	int k = 0;
	LNode *p = L;
	while (p != NULL && k < i)
	{
		p = p->next;
		k++;
	}
	return p;
}

四、删除节点

（1）按位序删除节点
// 按位序删除节点
bool DeleteNode(LinkList &L, int i, int &elem)
{
	if (i < 1)
	{
		perror("insert element falut: i < 1");
		return false;
	}
	LNode *p = FindNode(L, i - 1);
	if (p == NULL || p->next == NULL)
	{
		perror("delete i Illegal");
		return false;
	}
	LNode *q = p->next;
	elem = q->data;
	p->next = q->next;
	free(q);
	return false;
}
（2）删除指定节点
// 删除指定节点
bool DeletePointNode(LinkList &L, int i, int &elem)
{
	if (i < 1)
	{
		perror("insert element falut: i < 1");
		return false;
	}
	LNode *p = FindNode(L, i);
	if (p == NULL)
	{
		perror("delete i Illegal");
		return false;
	}
	elem = p->data; // 获取指定节点的数据

	LNode *q = p->next; // 找到指定节点的后继节点
	p->data = q->data;	// 将后继节点的数据复制到指定节点p
	p->next = q->next;	// 让指定节点p的next指向原本后继节点的下一个节点
	// 这里就相当于把指定节点的后继节点给覆盖到指定节点
	free(q);
	return true;
}

五、计算链表长度及输出

 （1）计算
// 计算链表长度
void ClacListlength(LinkList L)
{
	int length = 0;
	LNode *p = L;
	while(p->next)
	{
		length++;
		p = p->next;
	}
	printf("List length is %d\n",length);
}
（2）输出
// 输出链表
void ListPrint(LinkList L)
{
	LNode *p = L->next;
	while (p != NULL)
	{
		printf("%d\n", p->data);
		p = p->next;
	}
}

六、整体代码演示

/*
	此链表的操作基于带头节点的操作
	不带头节点的操作，在插入第一个节点操作需做特殊处理
	不带头节点除第一个节点外其它操作与带头节点一致
	需注意的是当前p指向的是第一个节点
*/
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>

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

// 链表初始化
bool ListInit(LinkList &L)
{

	L = (LNode *)malloc(sizeof(LNode));
	if (L == NULL)
	{
		perror("malloc LNode fault\n");
		return false;
	}
	L->next = NULL;
	return true;
}

// 插入节点详细步骤
bool InsertNode(LNode *p, int elem)
{
	if (p == NULL)
	{
		perror("insert i Illegal");
		return false;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if (s == NULL)
	{
		perror("Malloc LNode fault");
		return false;
	}
	s->data = elem;
	s->next = p->next;
	p->next = s;
	return true;
}

// 查找指定节点
LNode *FindNode(LinkList &L, int i)
{
	int k = 0;
	LNode *p = L;
	while (p != NULL && k < i)
	{
		p = p->next;
		k++;
	}
	return p;
}

// 按位序插入，指插入节点为第n个节点
bool ListNodeInsert(LinkList &L, int i, int elem)
{
	if (i < 1)
	{
		perror("insert element falut: i < 1");
		return false;
	}
	LNode *p = FindNode(L, i - 1);

	return InsertNode(p, elem);
}

// 第i个节点之后插入一个新的节点
bool InsertNextNode(LinkList &L, int i, int elem)
{
	if (i < 1)
	{
		perror("insert element falut: i < 1");
		return false;
	}

	LNode *p = FindNode(L, i);

	return InsertNode(p, elem);
}

// 在指定节点前面插入一个节点
bool InsertFrontNode(LinkList &L, int i, int elem)
{
	if (i < 1)
	{
		perror("insert element falut: i < 1");
		return false;
	}
	LNode *p = FindNode(L, i);

	if (p == NULL)
	{
		perror("insert i Illegal");
		return false;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if (s == NULL)
	{
		perror("Malloc LNode fault");
		return false;
	}
	s->next = p->next;
	s->data = p->data;
	p->next = s;
	p->data = elem;
	return true;
}

// 按位序删除节点
bool DeleteNode(LinkList &L, int i, int &elem)
{
	if (i < 1)
	{
		perror("insert element falut: i < 1");
		return false;
	}
	LNode *p = FindNode(L, i - 1);
	if (p == NULL || p->next == NULL)
	{
		perror("delete i Illegal");
		return false;
	}
	LNode *q = p->next;
	elem = q->data;
	p->next = q->next;
	free(q);
	return false;
}

// 删除指定节点
bool DeletePointNode(LinkList &L, int i, int &elem)
{
	if (i < 1)
	{
		perror("insert element falut: i < 1");
		return false;
	}
	LNode *p = FindNode(L, i);
	if (p == NULL)
	{
		perror("delete i Illegal");
		return false;
	}
	elem = p->data; // 获取指定节点的数据

	LNode *q = p->next; // 找到指定节点的后继节点
	p->data = q->data;	// 将后继节点的数据复制到指定节点p
	p->next = q->next;	// 让指定节点p的next指向原本后继节点的下一个节点
	// 这里就相当于把指定节点的后继节点给覆盖到指定节点
	free(q);
	return true;
}

// 按位序查找
bool GetElem(LinkList &L, int i, int &elem)
{
	if (i < 1)
	{
		perror("GetElem falut: i < 1");
		return false;
	}
	LNode *p = FindNode(L, i);
	if (p == NULL)
	{
		perror("Getelem's Node i Illegal");
		return false;
	}
	elem = p->data;
	return true;
}

// 按值查找
LNode *FindElem(LinkList &L, int elem)
{
	LNode *p = L->next;
	while (p != NULL && p->data != elem)
	{
		p = p->next;
	}
	return p;
}

// 计算链表长度
void ClacListlength(LinkList L)
{
	int length = 0;
	LNode *p = L;
	while(p->next)
	{
		length++;
		p = p->next;
	}
	printf("List length is %d\n",length);
}

// 输出链表
void ListPrint(LinkList L)
{
	LNode *p = L->next;
	while (p != NULL)
	{
		printf("%d\n", p->data);
		p = p->next;
	}
}

int main()
{
	LinkList L;
	ListInit(L);
	for (int i = 1; i <= 10; i++)
	{
		ListNodeInsert(L, i, i);
	}
	// 指定节点之后插入一个新的节点
	InsertNextNode(L, 2, 6);

	// 指定节点之前插入一个新的节点
	InsertFrontNode(L, 4, 5);
	ListPrint(L);

	// 删除指定节点并返回指定节点的数据
	int elem = 0;
	DeleteNode(L, 4, elem);
	printf("Deleted data is %d Node\n", elem);
	ListPrint(L);

	// 删除指定节点(方法二)并返回指定节点的数据
	DeletePointNode(L, 2, elem);
	printf("Deleted data is %d Node\n", elem);
	ListPrint(L);

	// 获取节点数据
	GetElem(L, 2, elem);
	printf("No.2 Node's data is %d\n", elem);

	// 查找链表中是否存在数据elem
	if (FindElem(L, 8))
	{
		printf("exist Node\n");
	}
	else
	{
		printf("Can't find eNode\n");
	}
	ClacListlength(L);

	return 0;
}

蓝桉_An
关注
  • 13
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表的初始化、取值、查找、插入、删除
m0_68002095的博客
03-13 3777
以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。在`getVal`函数中，使用循环遍历链表中的节点，如果找到了第`i`个节点，则返回其值。以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。缺点是访问节点的时间复杂度为 O(n)，其中 n 表示链表的长度。
一：线性表:链表的初始化操作及应用
@76135327的博客
11-17 6099
内容节点结构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和
数据结构之链表的初始化，存储，合并等等非常详细的代码（含测试数据）(含效果展示)
m0_65929214的博客
11-21 239
链表的实现
单链表的初始化
Lianuuu的博客
10-05 1万+
1. 链表的节点 链表存储的数据元素，其物理存储位置是随机的，并通过指针表示数据之间逻辑关系 链表中每个数据的存储都由以下两部分组成： 数据元素本身，其所在的区域称为数据域； 指向直接后继元素的指针，所在的区域称为指针域； 链表节点结构如图所示： 链表实际存储的是一个一个的节点，真正的数据元素包含在这些节点中 链表中每个节点的具体实现，需要使用 C 语言中的结构体，具体实现代码为： typedef struct Link { char elem; //代表数据域 struct L
单链表的初始化代码
一个随时准备弃坑的博客
03-24 3191
①无头结点 //初始化一个空的单链表 bool InitList(LinkList &L) { L=NULL; //空表，暂时还没有任何结点（防止脏数据遗留） return true; } ②有头节点 //初始化一个空的单链表（带头结点） bool InitList(LinkList &L) { L=（LNode*)malloc(sizeof(LNode...
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（1）掌握线性表的顺序存储结构； （2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； ...
数据结构-单链表以及对单链表进行的操作
最新发布
01-08
数据结构-单链表以及对单链表进行的操作
数据结构-单链表的学习及代码实现
09-03
包含单链表的增加、删除、修改，增加分为两种，直接增加到链表的最后和按照编号添加到固定的位置。以及对这些代码的全部实现。 为了自己学习记录，如果里面有不正确的，还请指正
C语言-数据结构-单链表完整程序
10-22
C语言-数据结构-单链表完整程序
数据结构-单链表删除绝对值相同的元素-c语言代码
11-07
单链表删除绝对值相同的元素
数据结构单链表初始化c/c++语言代码实现
01-22
很多刚接触数据结构的小白在学完单链表，只知道理论知识，却不知道如何实现，这是用c++语言实现的两种单链表初始化过程
纯C语言完整代码操作单链表(初始化、插入、删除、查找...)
qq_44697268的博客
08-26 1034
C语言操作单链表
C语言之单链表初始化
little_fengfeng的博客
04-26 2万+
单链表
链表的初始化【C语言】
少年一贯快马扬帆，道阻且长不转弯； 要盛大，要绚烂，要哗然； 要用理想的泰坦尼克，去撞现实的冰川； 要当烧赤壁的风，而非借鉴草船； 要为了一片海，就肯翻万山。
07-20 4252
/*By yangbocsu 线性表之链表 2021.07.20*/ #include <stdio.h> #include <stdlib.h> /*预定义常量和类型*/ /*函数结果状态码*/ #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -
2.3单链表的基本操作代码（数据结构C语言版）
weixin_51575278的博客
07-16 6417
1.单链表的存储结构 typedef struct Node//结点类型定义 { ElemType data; struct Node *next; }Node,*LinkList;//LinkList为结构体指针类型 2.初始化单链表 InitList(LinkList *L) { *L=(LinkList)malloc(sizeof(Node));//建立头结点 (*L)->next=NULL;//建立空的单链表 } /*L是指向单链表的头结点的指针，用来接收主程序中.
C语言实现单链表的初始化及增删改查
m0_51060495的博客
09-23 1133
C语言实现链表的初始化及增删改查 文件组织 main.c main.c //注意：linkList为头节点，头节点只是为了后面操作方便。其数据域无意义，但是头节点数据域通常保存链表长度，头指针指向第一个节点。 #include "test.h" //初始化链表 void InitLinkList(LinkList * linkList,ElementType * dataArray,int length); //插入节点 void InsertLinkList(LinkList * linkList
单链表的基本操作代码实现(C语言版)
热门推荐
m0_67647682的博客
08-04 3万+
单链表基本操作取值、按值查找返回元素所在地址、按值查找返回元素所对应序号、结点插入和删除以及头插法和尾插法建立单链表等的实现与解析，链表学习记录。
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6090
单链表的操作与实现
学习记录：第二章 线性表的链式存储_单链表_初始化创建（代码、图示、C++）
weixin_45790081的博客
05-03 1389
本文给出了单链表的初始化（带头结点、不带头结点）、结点的定义（两种方式）、头指针 L 的两种命名方式及区别，它们的代码及相应图示助于理解，代码实现使用的是C语言在线工具。无概念解释，初学者建议配合书本食用。
-3 数据结构-单链表-TODO：ReverseLinkList 原地逆转单链表, gCC ）
05-12
下面是使用C语言实现的单链表原地逆转的代码： ```c #include #include struct Node { int data; struct Node* next; }; void reverseList(struct Node** head) { struct Node* prev = NULL; struct Node* ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值