数据结构—单链表操作及实现（CC++）

已于 2022-07-11 07:59:18 修改
阅读量270 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构 单链表 链表
于 2021-07-27 10:31:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52166656/article/details/119137033
版权

数据结构—单链表操作及实现（C/C++）

文章目录

1.0初始化定义

#include<iostream>
#define MAXSIZE 100
#define ERROR -1
#define OK 1
using namespace std;
typedef  int status;//自己定义的类型
typedef  int ElemType; //上同

1.1单链表的定义

typedef struct LNode
{
	ElemType data; //存储节点的数据域
	struct LNode* next;  //存储后继节点位置的指针域next
}LNode, * LinkList;

  • **说明：LinkList和LNode的区别，其实两者本质是等价的，只是习惯上用LinkList定义单链表，强调定义是单链表的头指针，而==LNode定义指向单链表中的任意节点的指针变量==。

  • *LinkList p ：*p为指向节点的指针变量，表示该节点的地址。

  • LNode p: p为指向单链表某个节点的指针，*p就是该节点 ， *p为对应节点的变量，表示该节点的名称。

  • 头结点：**在首元节点之前设置的一个节点，头结点的next域（指针域）指向首元节点。

  • 头指针：**指向链表中第一个节点的指针，如果链表有头结点，则头指针指向链表的头结点，如果没有头结点，则指向首元节点，例如当链表没有头结点时，头指针就应该指向首元节点，判断空表的条件可为：L==NULL，反之，当有头结点时候，无论链表是否为空，头指针都是指向头结点的飞空指针。判断空表条件就是：L->next==NULL

1.2单链表的初始化

status Initlist(LNode* L)
{
	L = new LNode; //生成新节点作为头节点，用头指针L指向头结点
	L->next = NULL;  //头结点置空
	return OK;
}

1.3单链表的取值

status GetElem(LNode* L, int i, ElemType& e)
{
	int j = 1;  //初始化，p指向头结点，计数器j 初始为1
	LNode* p;
	p = L->next; //指向头结点
	while (p && j < i) //p不为0并且计数器值小于i的值
	{
		p = p->next; //p指向p的后继节点
		j++; //计数器+1
	}
	if (!p || j > i) 
	{
		return ERROR;
	}
	else
	{
		e = p->data;
	}
	return OK;
}

1.4单链表按值查找

status LocateElem(LNode* L,ElemType e)
{
	int j=1;
	LNode* p;
	p = L->next;
	while(p&&p->data!=e)
	{
		p = p->next;
		j++;
	}
	cout<<j<<endl;
	return OK;
}

1.5单链表的插入

status ListInsert(LNode* L,int i,ElemType e)
{
	int j = 0;
	LNode* p;
	LNode* s;
	p = L;
	while(p&&(j<i-1))
	{
		p = p->next;
		j++;
	}
	if(!p||j>i-1)
	{
		return ERROR;
	}
	else
	{
		s = new LNode;
		s->data = e;
		s->next = p->next;
		p->next = s;
	}
	return OK;
}

1.6单链表的删除

tatus ListDelete(LNode* L,int i)
{
	int j = 0;
	LNode* p;
	LNode* q;
	p = L;
	while((p->next)&&(j<i-1))
	{
		p = p->next;
		j++;
	}
	if(!(p->next)||(j>i-1))
	{
		return ERROR;
	}
	else
	{
		q=p->next;
		p->next=q->next;
		delete q;
	}
	return OK;
}

1.7头插法(前插法)建立单链表

status tailInsert(LinkList &L)
{
	LinkList s;
	ElemType x;
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;
	cout << "请依次输入元素x的值,最后输入9999结束输入！"<<endl;
	cin>>x;
	while(x!=9999)
	{
		s =(LNode*)malloc(sizeof(LNode));
		s->data=x;
		s->next = L->next;
		L->next = s;
		cin>>x;
	}
	return OK;
}

1.8尾插法(后插法)建立单链表

status tailInsert2(LinkList &L)
{
	ElemType x;
	LNode* r;
	LNode* s;
	L = new LNode;
	L->next = NULL;
	r = L;
	cout << "请依次输入元素x的值,最后输入9999结束输入！"<<endl;
	cin >> x;
	while(x!=9999)
	{
		s = new LNode;
		s->next = NULL;
		s->data = x;
		r->next = s;
		r = s;
		cin >> x;
	}
	r->next = NULL;
	return OK;
}

1.9输出单链表函数

void print(LinkList L)
{
	LinkList p=L->next ;
	printf("当前的链表元素为：");
	while(p!=NULL)
	{
		printf("  %d",p->data);
		p=p->next;
	}
    cout<<endl;
}

2.0 C 完整代码如下：

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
#define ERROR -1
#define OK 1
typedef  int status;
typedef  int ElemType;
//定义单链表
typedef struct LNode
{
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

//初始化单链表
status Initionlist(LNode* L)
{
	L = (LNode*)malloc(sizeof(LNode)); //生成新节点作为头节点，用头指针L指向头结点
	L->next = NULL;  //头结点置空
	return OK;
}

//单链表的取值
status GetElem(LNode* L, int i, ElemType& e)
{
	int j = 1;  //初始化，p指向头结点，计数器j 初始为1
	LNode* p;
	p = L->next; //指向头结点
	while (p && j < i) //p不为0并且计数器值小于i的值
	{
		p = p->next; //p指向p的后继节点
		j++; //计数器+1
	}
	if (!p || j > i) 
	{
		return ERROR;
	}
	else
	{
		e = p->data;
	}
	return OK;
}
//单链表按值查找w位置
status LocateElem(LNode* L,ElemType e)
{
	int j=1;
	LNode* p;
	p = L->next;
	while(p&&p->data!=e)
	{
		p = p->next;
		j++;
	}
	printf("%d",j);
	return OK;
}
//单链表的插入操作
status ListInsert(LNode* L,int i,ElemType e)
{
	int j = 0;
	LNode* p;
	LNode* s;
	p = L;
	while(p&&(j<i-1))
	{
		p = p->next;
		j++;
	}
	if(!p||j>i-1)
	{
		return ERROR;
	}
	else
	{
		s = new LNode;
		s->data = e;
		s->next = p->next;
		p->next = s;
	}
	return OK;
}
//单链表的删除操作
status ListDelete(LNode* L,int i)
{
	int j = 0;
	LNode* p;
	LNode* q;
	p = L;
	while((p->next)&&(j<i-1))
	{
		p = p->next;
		j++;
	}
	if(!(p->next)||(j>i-1))
	{
		return ERROR;
	}
	else
	{
		q=p->next;
		p->next=q->next;
		delete q;
	}
	return OK;
}
//头插法(前插法)建立单链表

status tailInsert(LinkList &L)
{
	LinkList s;
	ElemType x;
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;
	printf("请依次输入元素x的值,最后以9999结束输入：\n");
	scanf("%d",&x);
	while(x!=9999)
	{
		s =(LNode*)malloc(sizeof(LNode));
		s->data=x;
		s->next = L->next;
		L->next = s;
		scanf("%d",&x);
	}
	return OK;
}
//尾插法(后插法)建立单链表
status tailInsert2(LinkList &L)
{
	ElemType x;
	LNode* r;
	LNode* s;
	L = (LNode*)malloc(sizeof(LNode));;
	L->next = NULL;
	r = L;
		printf("请依次输入元素x的值,最后以9999结束输入：\n");
	scanf("%d",&x);
	while(x!=9999)
	{
		s = (LNode*)malloc(sizeof(LNode));;
		s->next = NULL;
		s->data = x;
		r->next = s;
		r = s;
		scanf("%d",&x);
	}
	r->next = NULL;
	return OK;
}
void print(LinkList L)
{
	LinkList p=L->next ;
	printf("当前的链表元素为：");
	while(p!=NULL)
	{
		printf("  %d",p->data);
		p=p->next;
	}
}


int main()
{
	LinkList L;
	Initionlist(L);
	printf("头插法建立单链表：\n");
	tailInsert(L);
	print(L);
	printf("\n");
	printf("删除第三个位置的值,");
	ListDelete(L,3);
	print(L);
	printf("\n");
	printf("插入第三个位置的值,");
	ListInsert(L,3,88);
	print(L);
	printf("\n");
	printf("元素88的位置是：");
	LocateElem(L,88);
	printf("\n");
	printf("\n");
	printf("\n");
	printf("尾插法建立单链表：\n");
	tailInsert2(L);
	print(L);
	printf("\n");
	printf("删除第三个位置的值,");
	ListDelete(L,3);
	print(L);
	printf("\n");
	printf("插入第三个位置的值,");
	ListInsert(L,3,88);
	print(L);
	printf("\n");
	printf("元素88的位置是：");
	LocateElem(L,88);
	return 0;
}

2.1 C++完整代码如下：

#include<iostream>
#define MAXSIZE 100
#define ERROR -1
#define OK 1
using namespace std;
typedef  int status;
typedef  int ElemType;
//定义单链表
typedef struct LNode
{
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

//初始化单链表
status Initionlist(LNode* L)
{
	L = new LNode; //生成新节点作为头节点，用头指针L指向头结点
	L->next = NULL;  //头结点置空
	return OK;
}

//单链表的取值
status GetElem(LNode* L, int i, ElemType& e)
{
	int j = 1;  //初始化，p指向头结点，计数器j 初始为1
	LNode* p;
	p = L->next; //指向头结点
	while (p && j < i) //p不为0并且计数器值小于i的值
	{
		p = p->next; //p指向p的后继节点
		j++; //计数器+1
	}
	if (!p || j > i) 
	{
		return ERROR;
	}
	else
	{
		e = p->data;
	}
	return OK;
}
//单链表按值查找w位置
status LocateElem(LNode* L,ElemType e)
{
	int j=1;
	LNode* p;
	p = L->next;
	while(p&&p->data!=e)
	{
		p = p->next;
		j++;
	}
	cout<<j<<endl;
	return OK;
}
//单链表的插入操作
status ListInsert(LNode* L,int i,ElemType e)
{
	int j = 0;
	LNode* p;
	LNode* s;
	p = L;
	while(p&&(j<i-1))
	{
		p = p->next;
		j++;
	}
	if(!p||j>i-1)
	{
		return ERROR;
	}
	else
	{
		s = new LNode;
		s->data = e;
		s->next = p->next;
		p->next = s;
	}
	return OK;
}
//单链表的删除操作
status ListDelete(LNode* L,int i)
{
	int j = 0;
	LNode* p;
	LNode* q;
	p = L;
	while((p->next)&&(j<i-1))
	{
		p = p->next;
		j++;
	}
	if(!(p->next)||(j>i-1))
	{
		return ERROR;
	}
	else
	{
		q=p->next;
		p->next=q->next;
		delete q;
	}
	return OK;
}
//头插法(前插法)建立单链表

status tailInsert(LinkList &L)
{
	LinkList s;
	ElemType x;
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;
	cout << "请依次输入元素x的值,最后以9999结束输入："<<endl;
	cin>>x;
	while(x!=9999)
	{
		s =(LNode*)malloc(sizeof(LNode));
		s->data=x;
		s->next = L->next;
		L->next = s;
		cin>>x;
	}
	return OK;
}
//尾插法(后插法)建立单链表
status tailInsert2(LinkList &L)
{
	ElemType x;
	LNode* r;
	LNode* s;
	L = new LNode;
	L->next = NULL;
	r = L;
	cout << "请依次输入元素x的值,最后以9999结束输入："<<endl;
	cin >> x;
	while(x!=9999)
	{
		s = new LNode;
		s->next = NULL;
		s->data = x;
		r->next = s;
		r = s;
		cin >> x;
	}
	r->next = NULL;
	return OK;
}
void print(LinkList L)
{
	LinkList p=L->next ;
	printf("当前的链表元素为：");
	while(p!=NULL)
	{
		printf("  %d",p->data);
		p=p->next;
	}
}


int main()
{
	LinkList L;
	Initionlist(L);
	cout<<"头插法建立单链表："<<endl;
	tailInsert(L);
	print(L);
	cout<<endl;
	cout<<"删除第三个位置的值,";
	ListDelete(L,3);
	print(L);
	cout<<endl;
	cout<<"插入第三个位置的值,";
	ListInsert(L,3,88);
	print(L);
	cout<<endl;
	cout<<"元素88的位置是：";
	LocateElem(L,88);
	cout<<endl<<endl<<endl;
	cout<<"尾插法建立单链表："<<endl;
	tailInsert2(L);
	print(L);
	cout<<endl;
	cout<<"删除第三个位置的值,";
	ListDelete(L,3);
	print(L);
	cout<<endl;
	cout<<"插入第三个位置的值,";
	ListInsert(L,3,88);
	print(L);
	cout<<endl;
	cout<<"元素88的位置是：";
	LocateElem(L,88);
	return 0;
}

2.1 运行截图

在这里插入图片描述

2.2参考书籍

《数据结构》(C语言版)（第2版）—严蔚敏 李冬梅 吴伟民 编著

2.3总结

对于链表，在确定插入和删除位置后，插入或删除操作无需移动数据，只需要修改指针。

有时间我在好好完善一下内容，这个没有修改多少。
水平有限，如果有错误的地方希望大家能够多指正！
写博客不容易，动动大家小手，多多关注！！！

芙如东海
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-链表的可视化编辑
m0_57805405的博客
01-04 1121
链表创建源码
c_ds_algo：通过实现流行的数据结构和算法，网络编程，操作系统来编码CC ++示例。
02-04
《C++实现数据结构与算法、网络编程及操作系统示例详解》 在计算机科学领域，理解和掌握数据结构、算法、网络编程以及操作系统是至关重要的。本项目“c_ds_algo”致力于提供一系列用C++编写的实例，以帮助学习者...
单链表的实现及基本操作总结
这里记录着我一点一滴的进步
09-04 3057
结点的引入 链表是一种链式存储结构，链式存储结构的特点是用一组任意的存储单元存储数据元素。为了能正确表示数据元素之间的线性关系，需引入结点概念。一个结点表示链表中的一个数据元素，节点中除了储存数据元素的信息， 还必须存放指向下一个节点的的指针（单、双链表的最后一个节点除外，它们存储的是一个空指针NULL） 结点的结构如下图所示： 代码如下： typede...
数据结构之用单链表的应用实现
apple_53384397的博客
01-08 759
数据结构单链表
单链表基本操作的实现
qq_53947363的博客
09-14 2549
单链表基本操作的实现
Java实现数据结构——不带头单链表
2303_80472275的博客
07-02 838
本文不会详细说理论可观看笔者之前的文章。
数据结构-单链表基本操作实现（含全部代码）
weixin_30323631的博客
09-18 403
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。本文链接：https://blog.csdn.net/lady_killer9/article/details/82700743 今天是单链表的实现，主要实现函数如下： InitList(LinkList &L) 参数...
【数据结构】单链表
编程小菜kun
01-14 899
现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。给定一个头结点为 head 的非空单链表，返回链表的中间结点。新链表是通过拼接给定的两个链表的所有节点组成的。给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。思路：依次比较链表中的结点，每次取小的结点，尾插到新链表即可。、非顺序的存储结构，数据元素的。
数据结构—单链表OJ
IfYouHave的博客
03-12 324
目录Number 1:删除链表中等于给定值 val 的所有结点。Number 2：反转一个单链表。Number 3：给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则 返回第二个中间结点。Number 4： 输入一个链表，输出该链表中倒数第k个结点。Number 5：将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有结点组成的。Number 6：编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 。Nu
基础数据结构之单链表倒置
Cc2018qaq的博客
08-12 679
1.递归方法 简单来说就是除了空链表和一个结点的链表之外，当结点的下一跳不为空时就继续让下一跳执行倒置。当结点下一跳 为空时，返回该结点给倒数第二个结点，倒数第二个结点将最后一次递归返回的最后一个结点的指针指向自己，然后自己的指针置空，然后返回。依此类推。描述起来有点麻烦，代码比较简介，代码如下： List Reverse(List i){ if(iNULL){ return NULL; } if(i->NextNULL){ return i; } List temp=Reverse(i->Ne
数组、单链表和双链表介绍以及双向链表的CC++Java实现 数组和链表.pdf
04-18
数组、单链表和双链表是最基本的数据结构，它们的实现方式有所不同，但是它们都是线性表的实现方式，具有相同类型的n(n≥0)个数据元素组成的有限序列。双向链表的实现可以使用C、C++和Java三种语言，它们的实现方式...
数据结构课程设计（CC++描述）[阮宏一][程序源代码]
12-26
本项目“数据结构课程设计（CC++描述）”由阮宏一提供，它包含了一系列用C++语言实现的数据结构及其算法。源代码的实践性极强，对于学习和理解数据结构有极大的帮助。 首先，我们来讨论一下数据结构的基本概念。...
DataStructers:由指针和动态数组构建的CC ++数据结构
03-22
在IT领域，特别是软件开发中，数据结构是编程的基础，它们是存储和组织数据的方式，以便于高效地访问和操作。本主题聚焦于使用C++编程语言，通过指针和动态数组来构建数据结构。C++是一种强大的、面向对象的编程语言...
DataStructures:CC ++中的数据结构
05-08
指针与数据结构结合使用，可以实现动态内存分配和高级数据结构，如链表和树。 掌握这些数据结构及其操作是成为一名优秀C++程序员的关键。通过理解和熟练运用这些数据结构，可以编写出更加高效和优雅的代码。在实际...
C++笔记18•数据结构:AVL树•
qq_64446190的博客
09-06 449
AVL树
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）
yzc的博客
09-05 948
详解了推有关的两个面试题：堆排序，TopK问题
【数据结构-二维前缀和】力扣1277. 统计全为 1 的正方形子矩阵
sjsjs11的博客
09-06 346
该题和力扣221.最大正方形类似，以某一格为右下角能形成最大正方形的边长，就是以该格为右下角的正方形数量。给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的 正方形 子矩阵的个数。正方形的总数 = 10 + 4 + 1 = 15.正方形的总数 = 6 + 1 = 7.边长为 1 的正方形有 10 个。边长为 2 的正方形有 4 个。边长为 3 的正方形有 1 个。边长为 1 的正方形有 6 个。边长为 2 的正方形有 1 个。输入：matrix =
栈—数据结构
最新发布
weixin_63722559的博客
09-06 948
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值