数据结构系列之二单链表

最新推荐文章于 2022-10-02 12:06:53 发布
最新推荐文章于 2022-10-02 12:06:53 发布
阅读量346 收藏
点赞数
分类专栏： 算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/starfromhere/article/details/107404113
版权

1. 知识点回顾

顺序表和单链表区别：

        顺序表：（1）特点：长度固定且需要分配一段连续的存储空间，存储密度大，可以使用倍增（具体方法就是判断当前元素如果达到最大，重新开辟2*N的空间，如果当前元素为空间的1/4，可以缩小原来空间至1/2，每次操作的同时要复制原来的旧的元素到新的存储空间中）的方法来动态扩容，将顺序表变成"可变长度"。（2）优点：便于随机访问，时间复制度O(1)。（3）缺点：插入和删除需要移动大量的元素，时间复制度O(n)。

        单链表：（1）特点：长度不固定，可以任意增删；存储空间不连续，元素之间使用指针相连；存储密度小；（2）优点：插入和删除元素只需要修改指针，不需要移动元素，时间复制度O(1)。（3）缺点：访问元素都需要从链表头开始，时间复制度O(n)。

2. 单链表定义

链表又分为：单链表、循环链表、双向链表。单链表是由很多个结点组成（没有结点的链表就是空链表），每个结点都包含一个数据域和指针域，指针域指向的是紧邻的下一个结点，最后一个结点指针通常为NULL。单链表又分为有头结点和无头结点的单链表，本文主要讨论带头结点的单链表，在此必须清楚三个概念：开始结点、头指针、头结点。

开始结点：就是链表中的第一个结点，该结点没有直接前驱。

头指针：在没有头结点的前提下，头指针是指向开始结点的指针。有了头指针可以唯一确定一个单链表。

头结点：就是在链表开始结点之前再附加一个结点，头结点指针指向的结点数据域为空，有了头结点之后，头指针指向头结点，无论链表是否为空，头指针总是非空。有了头结点之后，对链表开始结点的操作和其他位置的结点操作是一样的。

语法难点：

因为头结点的指针本身就是个结构指针，所以在需要改变头结点的地方，函数的形参应该为指向头指针的指针。

如果这里不使用二级指针，会导致的问题就是我们已经给函数内分配了内存，但是在函数外却访问不到。

3. 单链表基本操作：

（1）void InitLinkedList(LinkedList* L)：初始化一个单链表。

（2）void CreateLinkedList_Head(LinkedList* L,int n)：头插法创建单链表。

（3）void CreateLinkedList_Tail(LinkedList* L, int n)：尾插法创建单链表。

（4）int InsertLinkedList(LinkedList L, int i, DataType e)：在第i个位置插入元素e。

（5）int DeleteElement(LinkedList L, int i)：删除第i个位置的元素。

（6）void ClearLinkedList(LinkedList L)：清理单链表，保留头结点。

（7）void DestroyLinkedList(LinkedList* L)：销毁单链表。

（8）bool IsEmpty(LinkedList L)：判断单链表是否为空。

（9）int GetLength(LinkedList L)：获取单链表长度。

（10）LinkedList GetElement(LinkedList L, int i)：查找第i个位置上的元素。

（11）void OutPut(LinkedList L)：遍历输出单链表。

3.1 单链表结构体定义

//系统中已有此状态码定义，要防止冲突
#ifndef OVERFLOW
#define OVERFLOW    -2  //堆栈上溢
#endif

typedef int DataType;
//单链表结构体
typedef struct LNode
{
	DataType data;
	struct LNode* next;
}LNode;
typedef LNode* LinkedList;	//指向单链表结点的指针

3.2  初始化单链表

//初始化单链表
void InitLinkedList(LinkedList* L) {
	(*L) = (LinkedList)malloc(sizeof(LNode));
	if (!(*L))
	{
		exit(OVERFLOW);
	}
	(*L)->next = NULL;
}

3.3 头插法

//头插法
void CreateLinkedList_Head(LinkedList* L,int n) {
	int i;
	LinkedList p;
	DataType tmp;
	*L = (LinkedList)malloc(sizeof(LNode));
	if (!(*L))
	{
		exit(OVERFLOW);
	}
	(*L)->next = NULL;
	cout << "头插法建立单链表:\n" << endl;
	for (int i=1; i<=n; i++)
	{
		p = (LinkedList)malloc(sizeof(LNode));
		cout << "请输入第" << i << "个数:" << endl;
		cin >> tmp;
		p->data = tmp;
		p->next = (*L)->next;
		(*L)->next = p;
	}
}

3.4 尾插法

//尾插法
void CreateLinkedList_Tail(LinkedList* L, int n) {
	int i;
	LinkedList p, q;
	DataType tmp;
	*L = (LinkedList)malloc(sizeof(LNode));
	if (!(*L))
	{
		exit(OVERFLOW);
	}
	(*L)->next = NULL;
	q = *L;
	cout << "尾插法建立单链表:\n" << endl;
	for (int i=1; i<=n; i++)
	{
		p = (LinkedList)malloc(sizeof(LNode));
		cout << "请输入第" << i << "个数:" << endl;
		cin >> tmp;
		p->data = tmp;
		q->next = p;
		q = q->next;
	}
	q->next = NULL;
}

3.5 在第i个位置插入一个元素e

//在位置i插入元素e
int InsertLinkedList(LinkedList L, int i, DataType e) {
	int j = 1;
	LinkedList pre, p;
	LinkedList new_node;//带插入的结点
	pre = L;

	cout << "在第"<<i<<"个位置插入元素"<< e << endl;

	//寻找第i个结点，并令pre指向其前驱
	while (pre->next && j < i)
	{
		pre = pre->next;
		j++;
	}
	if (!pre->next || j > i)
	{
		return -1;
	}
	else
	{
		p = pre->next;
		new_node = (LinkedList)malloc(sizeof(LNode));
		new_node->data = e;
		pre->next = new_node;
		new_node->next = p;
		return 1;
	}
}

4  代码实现


#include <iostream>

using namespace std;

//系统中已有此状态码定义，要防止冲突
#ifndef OVERFLOW
#define OVERFLOW    -2  //堆栈上溢
#endif

typedef int DataType;
//单链表结构体
typedef struct LNode
{
	DataType data;
	struct LNode* next;
}LNode;
typedef LNode* LinkedList;	//指向单链表结点的指针


//清理单链表，保留头结点
void ClearLinkedList(LinkedList L) {
	LinkedList pre, p;
	pre = L->next;
	while (pre)
	{
		p = pre->next;
		free(pre);
		pre = p;
	}
	L->next = NULL;
}

//销毁单链表
void DestroyLinkedList(LinkedList* L) {
	LinkedList p = *L;
	while (p)
	{
		p = (*L)->next;
		free(*L);
		(*L) = p;
	}
}
//判断单链表是否为空
bool IsEmpty(LinkedList L) {
	//链表存在且只有头结点
	if (L != NULL && L->next == NULL)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//获取单链表长度
int GetLength(LinkedList L) {
	LinkedList p;
	int lenght = 0;
	cout << "单链表长度:" << endl;
	if (L)
	{
		p = L->next;
		while (p)
		{
			lenght++;
			p = p->next;
		}
	}
	return lenght;
}
//查找第i个位置结点的数据
LinkedList GetElement(LinkedList L, int i) {
	int j = 1;
	DataType e;
	LinkedList p = L->next;
	cout << "返回第" << i << "个位置的元素:" << endl;
	while (p && j<i)
	{
		p = p->next;
		j++;
	}
	if (!p || j>i)
	{
		return NULL;
	}
	else
	{
		return p;
	}
}

void OutPut(LinkedList L) {
	LinkedList p = L->next;
	cout << "链表中的元素：\n" << endl;
	while (p)
	{
		cout << p->data << endl;
		p = p->next;
	}
}

//初始化单链表
void InitLinkedList(LinkedList* L) {
	(*L) = (LinkedList)malloc(sizeof(LNode));
	if (!(*L))
	{
		exit(OVERFLOW);
	}
	(*L)->next = NULL;
}

//头插法
void CreateLinkedList_Head(LinkedList* L,int n) {
	int i;
	LinkedList p;
	DataType tmp;
	*L = (LinkedList)malloc(sizeof(LNode));
	if (!(*L))
	{
		exit(OVERFLOW);
	}
	(*L)->next = NULL;
	cout << "头插法建立单链表:\n" << endl;
	for (int i=1; i<=n; i++)
	{
		p = (LinkedList)malloc(sizeof(LNode));
		cout << "请输入第" << i << "个数:" << endl;
		cin >> tmp;
		p->data = tmp;
		p->next = (*L)->next;
		(*L)->next = p;
	}
}

//尾插法
void CreateLinkedList_Tail(LinkedList* L, int n) {
	int i;
	LinkedList p, q;
	DataType tmp;
	*L = (LinkedList)malloc(sizeof(LNode));
	if (!(*L))
	{
		exit(OVERFLOW);
	}
	(*L)->next = NULL;
	q = *L;
	cout << "尾插法建立单链表:\n" << endl;
	for (int i=1; i<=n; i++)
	{
		p = (LinkedList)malloc(sizeof(LNode));
		cout << "请输入第" << i << "个数:" << endl;
		cin >> tmp;
		p->data = tmp;
		q->next = p;
		q = q->next;
	}
	q->next = NULL;
}

//在位置i插入元素e
int InsertLinkedList(LinkedList L, int i, DataType e) {
	int j = 1;
	LinkedList pre, p;
	LinkedList new_node;//带插入的结点
	pre = L;

	cout << "在第"<<i<<"个位置插入元素"<< e << endl;

	//寻找第i个结点，并令pre指向其前驱
	while (pre->next && j < i)
	{
		pre = pre->next;
		j++;
	}
	if (!pre->next || j > i)
	{
		return -1;
	}
	else
	{
		p = pre->next;
		new_node = (LinkedList)malloc(sizeof(LNode));
		new_node->data = e;
		pre->next = new_node;
		new_node->next = p;
		return 1;
	}
}
//删除第i个位置的结点
int DeleteElement(LinkedList L, int i) {
	int j = 1;
	LinkedList pre, p;
	pre = L;
	cout << "删除第" << i << "个位置的元素" << endl;

	//寻找第i个结点，并令pre指向其前驱
	while (pre->next && j < i)
	{
		pre = pre->next;
		j++;
	}
	if (!pre->next || j > i)
	{
		return -1;
	}
	p = pre->next;
	pre->next = p->next;
	free(p);
	return 1;
}

int main()
{
	LinkedList L;
	InitLinkedList(&L);
	//CreateLinkedList_Head(&L, 5);
	CreateLinkedList_Tail(&L, 5);
	OutPut(L);

	InsertLinkedList(L, 2, 100);
	OutPut(L);
	LinkedList e = GetElement(L, 2);
	cout << "e=" << e->data << endl;
	int len = GetLength(L);
	cout << "len=" << len << endl;
	/*DeleteElement(L, 1);
	OutPut(L);*/
	system("pause");
	return 0;
}

代码简单测试了下尾插法创建单链表，并在第2个位置插入元素100：

 

 

 

 

starfromhere
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构（数据表之单链表）（Day4）
楚子航
04-06 1732
一、线性表的链式存储结构（什么是链表及其原理） 将线性表L=(a0,a1,……,an-1)中各元素分布在存储器的不同存储块，称为结点，通过地址或指针建立元素之间的联系 。 结点的data域存放数据元素ai，而next域是一个指针，指向ai的直接后继ai+1所在的结点。 举例： 结点类型描述： typedef struct node { data_t data; //结点的数据域// struct node *next; ...
《数据结构》实验指导实验二单链表的存储及操作.docx
12-17
数据结构实验指导实验二单链表的存储及操作 本实验指导旨在让学生掌握单链表的存储实现、操作算法实现和应用。下面是相关知识点的详细解释： 一、单链表的定义 单链表是一种抽象数据类型，它由一系列结点组成，每...
【数据结构系列】单链表的基本操作
CSDN明星博主，认证博客专家，视频、Matlab领域优质创作者。
04-14 314
DATE: 2020.4.14 1、参考 2、单链表的基本操作（创建、查找、插入、删除、遍历）
数据结构-实验2 单链表
weixin_43488714的博客
11-28 1203
【问题描述】 设计一个单链表操作演示程序。 【基本要求】 设计实现一个带头结点的单链表的操作演示程序，提供一个用户界面，可演 示的基本功能包括： （1）初始化单链表； （2）输入并建立单链表；（头插入法、尾插入法均可） （3）输出单链表中的元素； （4）在单链表指定位置插入元素； （5）在单链表指定元素之前插入元素； （6）删除单链表指定位置的元素； （7）删除单链表指定元素之前的元素； （8）删...
判断单链表是否有环的两种方法
weixin_34411563的博客
08-14 94
如图，如果单链表有环，则在遍历时，在通过6之后，会重新回到3，那么我们可以在遍历时使用两个指针，看两个指针是否相等。 方法一：使用p、q两个指针，p总是向前走，但q每次都从头开始走，对于每个节点，看p走的步数是否和q一样。如图，当p从6走到3时，用了6步，此时若q从head出发，则只需两步就到3，因而步数不等，出现矛盾，存在环方法二：使用p、q两个指针，p每次向前走一步，q每次向前走两步，若...
数据结构中的.和-＞的辨析
MichaelSuns的博客
11-03 6434
在数据结构中我们经常会用到p->data,p.data,p->lchild等，这里的.和->分别是什么意思？各自的用法是什么？详解如下： -> 左边是结构体指针，右边是结构体成员，因此p->next 的含义是p指针指向结构体zhi变量的next数据域（一般该数据域存放后继dao结点的地址） . 左边是结构体变量名，右边是结构体成员，因此p.next的含义是p结构体变量的next数据域，如： SqList &L;//这里的L是一个变量 L.data[1]=1; SqLi
Python实现数据结构线性链表（单链表）算法示例
09-19
在Python中，数据结构线性链表是一种常用的数据组织方式，特别是单链表。单链表是由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。在这个示例中，我们将详细讨论如何用Python实现单链表的...
数据结构 合并有序链表 单链表 初学
02-17
在IT领域，数据结构是计算机科学的基础之一，它关乎如何高效地存储和处理数据。本文将深入探讨"合并有序链表"这一主题，这在单链表初学者中是非常重要的话题。链表作为一种非线性数据结构，与数组相比，具有更灵活的...
【Java数据结构与算法】单链表
12-21
【Java数据结构与算法】单链表 单链表是一种基本的数据结构，它在计算机科学中扮演着重要的角色。链表是由一系列节点构成的，每个节点包含两部分：data域用于存储数据，以及next域用于指向下一个节点。与数组不同，...
数据结构之单链表操作合集.zip
最新发布
06-16
这个“数据结构之单链表操作合集.zip”文件显然是针对大学生学习数据结构而准备的资源，包含了丰富的学习材料。下面将详细讨论单链表的相关知识点。 单链表是一种线性数据结构，由一系列节点（也称为元素或记录）...
【数据结构】链表中的 指针，地址
follow your heart
10-17 5283
数据结构中跳过集合，直接开始线性结构 线性结构中单链表的操作涉及到给一个变量赋值地址，所以涉及到了指针 通过指针里的地址很方便找到节点 但指针这里绕了我很长时间，不论学了多少遍也不敢说把指针学会了 地址： 地址是什么，从哪里来？ 地址是内存中每个字节的编号 我的电脑内存是4G=4×1024(M)×1024(K)×1024(Byte)=4294967296 Byte 其中每个字节Byte=8...
单链表的创建算法
火雨(Nick)
03-26 5万+
单链表的创建算法        当一个序列中只含有指向它的后继结点的链接时，就称该链表为单链表。        单链表的示意图如下：                                                   Head指针为单链表的头指针，单链表L：L既是单链表的名字，也是其头指针。链表中的最后一个结点的指针域定义为空指针(NULL)。       单链表
单链表增序排列节点
qq_57484399的博客
10-02 1990
我们既然想把节点排序 , 那就要先有一个初始节点, 然后把新节点来与初始节点比较, 如果比初始节点大,就插入到初始节点的后面,如果比初始节点小 , 那就插入到节点的前面 ,这样就把新元素插入到了, pre的后面, 但是后面的元素pre->next存储的是后面的元素,全被覆盖了, 相当于 比新元素大的元素,以后都断掉了,指针失踪了。我们如果直接覆盖掉 新节点的后继指针 p->next 的话 ,就会让下一个要操作的新节点q ,失去联系 ,那我们就失去了链表联系 ,那如何再接着构建链表呢?
数据结构之栈
heyuanjiang的博客
11-10 394
S=(a1,a2,a3,a4,a5,,,,,,,,,,,,,) 允许插入和操作的一端叫 栈顶。 表达另一端称为栈底 当栈中没有数据元素称为空栈 栈的插入操作通常叫进栈
数据结构面试之一——单链表常见操作
铭毅天下Elasticsearch
08-13 5822
数据结构面试之一——单链表常见操作 题注：《程序员面试宝典》有相关习题，但思路相对不清晰，排版有错误，本文对此参考相关书籍和自己观点进行了重写，供大家参考。 1.查找链表元素 Step1：置查找标记bfound=false;判断链表是否为空，是，提示“不能查找空链表”；否，进入step2。 Step2：从链表头开始查找，判断（当前点的info是否与待查找元素值相等&&指针未指向末尾），是，
各类链表判空条件
abcdeasdfas的博客
01-02 1万+
——> 转自原博客 1.单链表 带头结点： 分析： 带有头节点的链表若为空，只需要整条链表只剩一个头节点 [这是和不带头节点的链表的一个很大的区别（不带头结点的链表若要为空，整个链表不能存在一个结点）]， 怎样使带头节点的链表只剩一个头节点呢？ 只需要第一个存储数据的节点不存在即可，即头节点的后继结点不存在即可 所以只需要头节点的next指针域不存在即可（实质上使指向NULL） 所以 带头点的单链表的判空条件为 head->next=NULL 不带头结点： 分析： 若要不带头结点的链表为空，
单链表为空的判定条件
mxing5694270的博客
06-03 2万+
带头结点的单链表head为空的判定条件是（）。 A.head==NULL B.head->next==NULL C.head->next==head D.head!=NULL 正确答案：B 解析：若单链表带头结点，那么判定它为空的条件是head->next==NULL；若单链表不带头结点，那么判定它为空的条件则是head==NULL。 ...
单链表——单链表的定义及基本操作（初始化、头插法尾插法建表、查找、插入、删除、判空等）
热门推荐
薛定谔的猫的博客
04-17 9万+
文章目录单链表的定义单链表上的操作初始化建立单链表头插法建立单链表尾插法建立单链表遍历单链表求单链表的长度查找操作按值查找按位查找插入操作删除操作完整代码及实例 单链表的定义   由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。单链表通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。   单链表的特点： 单链表不要求逻辑上相邻的两个元素在物理位置上也相邻，因此不需要连续的存储
链表操作—单链表的销毁与清空
Gentle722的博客
05-17 1万+
/* 单链表的销毁与清空 销毁：连同头结点一起释放 清空：保留头结点；置头结点的指针域为NULL */ //销毁链表 void destroyList(Linklist &L) { Linklist p; p = L; while (p) { L = L->next; // free(p); delete(p); } } //清空链表 void clearList(Linklist &L) { Linklist p; while (L->next)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值