数据结构与算法笔记第2章 线性表 链式表示

最新推荐文章于 2022-05-28 15:31:12 发布
最新推荐文章于 2022-05-28 15:31:12 发布
阅读量1.1k 收藏 3
点赞数 2
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 单链表 算法 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45459526/article/details/113752341
版权
2.5 链式结构的表示和实现
  1. 头指针，头结点和首元结点：
  2. 头结点的好处：①便于首元结点的处理；②便于空表和非空表的处理；
  3. 链式存储的特点：①结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻；②访问时只能通过头指针进入链表，并通过每个结点的指针域 依次向后顺序扫描其余结点，所以寻找第一个结点和最后一个结点所花费的时间不等；
  4. 带头结点的单链表
2.5.1 单链表的表示
  • 单链表的存储结构：
typedef struct
{
	int num;
	char name[20];
	int score;
}ElemType;
typedef struct LNode//声明结点的类型和指向结点的指针类型
{
	ElemType data;//结点的数据域
	struct LNode* next;//结点的指针域
}LNode, * LinkList;//LinkList 为指向结构体Lnode的指针类型
/*解释：定义了一个结构体类型 利用typedef重新起名字为Lnode 然后定义指针LinkList指向Lnode*/
/*定义结点指针p：Lnode *p; <==> LinkList P;*/
2.5.2 单链表的实现

[ 算法2.6 ] 单链表的初始化（带头结点的单链表）

Status InitList(LinkList& L)
{
	L = (LinkList)malloc(sizeof(LNode));
	/*L=new LNode;*/
	L->next = NULL;
	return OK;
}

[ 补充算法 1 ] 判断链表是否为空

int ListEmpty(LinkList L)
{
	if (L->next)//非空
	{
		return 0;
	}
	else
	{
		return 1;
	}
}

[ 补充算法 2 ] 单链表的销毁
[ 算法思路 ]从头指针开始，依次释放所有结点；

Status DestroyList(LinkList& L)
{
	LNode* p;//LinkList p;
	while (L)
	{
		p = L;
		L = L->next;
		free(p);
	}
	return 0;
}

[ 补充算法 3 ] 清空链表（链表仍然存在，但链表中无元素，成为空链表）
[ 算法思路 ]依次释放所有结点，并将头结点的指针域设置为空；

Status ClearList(LinkList& L)
{
	LNode* p, * q;
	p = L->next;
	while (p)
	{
		q = p->next;
		free(p);
		p = q;
	}
	L->next = NULL;//头结点的指针域为空
	return OK;
}

[ 算法补充 4 ] 求单链表的表长
[ 算法思路 ]从首元结点开始，依次计数所有结点；

int ListLength(LinkList L)
{
	int count = 0;//链表长度
	LNode* p;
	p = L->next;
	while (p)
	{
		count++;
		p = p->next;
	}
	return count;
}

[ 算法 2.7 ] 查找第 i 个元素

Status GetElem(LinkList L, int i, ElemType& e)
{
	LNode* p;
	int j = 1;
	p = L->next;
	while (p && j < i)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i)
	{
		return ERROR;
	}
	e = p->data;
	return OK;
}

[ 算法 2.8 ] 按值查找

//O(n)
LNode* LocateElem(LinkList L, ElemType e)/*返回地址*/
{
	LNode* p;
	p = L->next;
	while (p && p->data != e)
	{
		p = p->next;
	}
	return p;
}

int LocateElem(LinkList L, ElemType e)/*返回元素的下标*/
{
	LNode* p;
	int j = 1;
	p = L->next;
	while (p && p->data != e)
	{
		p = p->next;
		j++;
	}
	if (p)
	{
		return j;
	}
	else
	{
		return 0;
	}
}

[ 算法 2.9 ] 插入（在第 i 个结点前插入值为 e 的新结点）

Status ListInsert(LinkList& L, int i, ElemType e)
{
	LNode *s, *p;
	int j = 0;
	s->data = e;
	p = L;
	while (p && j < i-1)//寻找i-1个结点 p指向i-1结点
	{
		p = p->next;
		j++;
	}
	if (!p || j > i-1)
	{
		return ERROR;
	}
	s->next = p->next;
	p->next = s;
	return OK;
}

[ 算法 2.10 ] 删除（删除第 i 个结点）

Status ListDelete(LinkList& L, int i,ElemType &e)
{
	LNode* p, * q;
	int j = 0;
	p = L;
	while (p && j < i - 1)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i - 1)
	{
		return ERROR;
	}
	q = p->next;
	p->next = q->next;//修改指针
	e = q->data;
	free(q);
	return OK;
}

[ 算法 2.11 ] 建立单链表—头插法（元素插入在链表头部 ）

/*倒位序插入n个元素的值*/
void CreateList(LinkList& L, int n)
{
	LNode* p;
	int i;
	for (i = n; i > 0; i--)
	{
		p = (LinkList)malloc(sizeof(LNode));
		scanf("%d", &p->data);
		p->next = L->next;
		L->next = p;
	}
}

[ 算法 2.12 ] 建立单链表–尾插法（元素插入在链表尾部）

/*正位序输入n个元素的值*/
void CreateList(LinkList& L, int n)
{
	LNode* p, *r;
	int i;
	r = L;
	for (i = n; i > 0; i--)
	{
		p = (LinkList)malloc(sizeof(LNode));
		scanf("%d",&p->data);
		p->next = NULL;
		r->next = p;
		r = p;//尾指针指向新结点
	}
}
2.5.3 循环链表

循环链表：是一种 头尾相接的链表（即：表中最后一个结点的指针域指向头结点，整个链表形成一个环）；

[ 算法 2.13 ] 循环链表的建立

void CreateList(LinkList& L, int n)
{
	LNode* p, *r;
	int i;
	r = L;
	for (i = n; i > 0; i--)
	{
		p = (LinkList)malloc(sizeof(LNode));
		scanf("%d",&p->data);
		p->next = NULL;
		r->next = p;
		r = p;
	}
	r->next = L;
}

[ 算法 2.14 ] 带尾指针循环链表的合并

LinkList Connect(LinkList Ta, LinkList Tb)//假设Ta,Tb都是非空的单循环链表
{
	LNode p;
	p = (LinkList)malloc(sizeof(LNode));
	p = Ta->next;
	Ta->next = Tb->next->next;
	free(Tb->next);
	Tb->next = p;//修改指针
	return Tb;
}
线性表的链式表示和实现完整参考代码
/*先看主函数了解 2021.1.17*/
#include<stdio.h>
#include<stdlib.h>
#define ERROR 0
#define OK 1
typedef int Status;
typedef int ElemType;
typedef struct LNode
{
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;
Status InitList(LinkList& L)
{
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	return OK;
}
/*
void CreateList(LinkList& L, int n)
{
	LNode* p;
	for (int i = n; i > 0; i--)
	{
		p = (LNode *)malloc(sizeof(LNode));
		scanf("%d", &p->data);
		p->next = L->next;
		L->next = p;
	}
}
*/
void CreateList(LinkList& L, int n)
{
	LNode* p, * r;
	r = L;
	for (int i = n; i > 0; i--)
	{
		p = (LinkList)malloc(sizeof(LNode));
		scanf("%d", &p->data);
		p->next = NULL;
		r->next = p;
		r = p;
	}
}
int ListLength(LinkList L)
{
	int count = 0;//用于计数
	LNode* p;
	p = L->next;
	while (p)
	{
		count++;
		p = p->next;
	}
	return count;
}
Status GetElem(LinkList L, int i, ElemType& e)
{
	int j = 1;
	LNode* p;
	p = L->next;
	while (p && j < i)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i)
	{
		return ERROR;
	}
	e = p->data;
	return OK;
}
int LocateElem(LinkList L, ElemType e)
{
	LNode* p;
	int j = 1;
	p = L->next;
	while (p && p->data != e)
	{
		p = p->next;
		j++;
	}
	if (p)
	{
		return j;
	}
	else
	{
		return ERROR;
	}
}
Status ListInsert(LinkList& L, int i, ElemType e)
{
	LNode* s, * p;
	s = (LinkList)malloc(sizeof(LNode));
	int j = 0;
	p = L;
	s->data = e;
	while(p && j < i - 1)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i - 1)
	{
		return ERROR;
	}
	s->next = p->next;
	p->next = s;
	return OK;
}
void print(LinkList L)
{
	LNode* p;
	p = L->next;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
Status ListDelete(LinkList& L, int i, ElemType& e)
{
	LNode* p, * q;
	p = L;
	q = (LinkList)malloc(sizeof(LNode));
	int j = 0;
	while (p && j < i - 1)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i - 1)
	{
		return ERROR;
	}
	q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return OK;
}
void ListEmpty(LinkList L)
{
	if (L->next)
	{
		printf("链表非空\n");
	}
	else
	{
		printf("链表为空\n");
	}
}
Status ClearList(LinkList& L)
{
	LNode* p, * q;
	p = L->next;
	while (p)
	{
		q = p->next;
		free(p);
		p = q;
	}
	L->next = NULL;
	return OK;
}
Status DestroyList(LinkList& L)
{
	LNode* p;
	while (L)
	{
		p = L;
		L = L->next;
		free(p);
	}
	printf("销毁完毕\n");
	return OK;
}
int main()
{
	int n;
	int i;
	LinkList L;
	ElemType e;
	InitList(L);/*带头结点的链表初始化*/
	printf("输入元素的个数：");
	scanf("%d", &n);//要输入的元素个数
	printf("输入元素：");
	//CreateList(L, n);/*头插法输入元素-倒叙状态*/
	CreateList(L, n);/*尾插法输入元素-顺序*/
	printf("单链表的长度：%d\n", ListLength(L));/*求单链表的表长*/
	printf("输入查找的i位置：");
	scanf("%d", &i);
	GetElem(L, i, e);/*查找第i个元素*/
	printf("查找的第i个元素是：%d\n", e);
	printf("输入要查找得值：");
	scanf("%d", &e);
	printf("查找到的元素的下标为：%d\n", LocateElem(L, e));/*按值查找*/
	printf("插入的位置：");
	scanf("%d",&i);
	printf("要插入的元素：");
	scanf("%d", &e);
	ListInsert(L, i, e);/*第i个位置之前插入元素e*/
	printf("插入元素后的链表：");
	print(L);//输出链表
	printf("输入删除元素的位置：");
	scanf("%d", &i);
	ListDelete(L, i, e);/*删除第i个元素*/
	printf("删除的元素%d\n",e);
	printf("删除元素后的链表：");
	print(L);
	ListEmpty(L);/*判断链表是否为空*/
	ClearList(L);/*清空单链表*/
	printf("清空单链表后：");
	ListEmpty(L);/*判断链表是否为空*/
	DestroyList(L);/*销毁单链表*/
	return 0;
}
清纯献给了作业
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
数据结构相关知识点整理
m0_47469819的博客
05-06 668
编译原理概述 1.1 计算机语言 机器语言: 0、1代码 汇编语言: 0、1代码与助记符：接近计算机硬件指令系统 高级语言: 语句定义数据、描述算法(程序) 如：C、SQL(数据定义、数据操作) 命令语言: 以功能封装为特征 翻译程序：将某一种语言描述的程序(源程序SP)翻译成等价的另一种语言描述的程序(目标程序OP)的程序 编译程序：高级语言程序→汇编/机器语言程序 1.2 编译程序总体结构 ...
new和malloc的区别、ptmalloc
lisaaaaaas0405的博客
08-15 380
一、new和malloc的区别 1、new/delete是C++的运算符/关键字，malloc与free是c++/c语言的标准函数 void* malloc(size_t); void free(void*); void *operator new (size_t); void operator delete (void *); void *operator new[] (size_t); ...
（数据结构）c/c++语言：带头结点的循环链表
weixin_47153399的博客
05-28 96
#include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; LinkList Create(int n) {//创建带头结点n个结点的循环链表 int i; LinkList L,p,q; L=(LinkList)malloc(sizeof(LNode));//头结点...
创建单链表的头插法与尾插法详解
热门推荐
Frank的博客
09-26 16万+
创建单链表 关于数据结构的入门，就是从顺序表和单链表开始。 我们不讲顺序表，直接从单链表开始我们的数据结构和算法的学习之路。 单链表就是一种特殊的结构体组合而成的数据结构，关于单链表的创建方法有很多种，但都大同小异。 正如这幅图中所表示的那样，单链表就是由可能不连续的数据所组合而成的数据结构。 其中每个数据分为两部分，一部分是数据存储的位置，称为数据域，另外指针所存储的地方，称为指针域。 typ...
数据结构考研 笔记 完结 西电）.pdf
11-04
本笔记总结了数据结构的基本概念、逻辑结构、存储结构、数据运算等知识点，涵盖了线性表、栈、队列、串、树、图、查找、排序等数据结构的基本概念和算法。 一、逻辑结构 * 线性结构：元素之间的逻辑关系是线性的，...
自考数据结构笔记.ppt
02-21
本资源摘要信息来自自考数据结构笔记.ppt，涵盖了数据结构的基本概念、算法和算法分析、线性表的逻辑结构和存储结构等知识点。 一、数据结构基本概念 数据结构是研究非数值计算的程序设计问题中计算机的操作对象及...
数据结构笔记-《考研王道笔记知识点整理》
最新发布
05-23
《考研王道笔记知识点整理》中的内容涵盖了数据结构的基础概念、数据结构的三要素、算法的基本概念以及线性表的定义。 1. **数据结构的基本概念**： - 数据是描述客观事物属性的符号集合，数据元素是数据的基本...
软考数据结构基础学习笔记
04-02
本笔记将为您详细介绍数据结构的基础知识，包括线性表、栈、队列、串和KMP算法等内容。 一、线性表 线性表是n个元素的有限序列，通常记为(a1，a2，…，an)。特点是：(1)存在惟一的表头和表尾。(2)除了表头外，表中...
数据结构视频教程学习笔记
12-19
在本教程中，我们将重点关注由王卓老师和王道考研提供的数据结构视频教程的学习笔记。 首先，我们要理解数据结构的基本概念。数据是计算机能够识别和处理的符号，分为数值型（如整数、浮点数）和非数值型（如字符、...
LinkList的具体实现
weixin_42349313的博客
09-27 2921
LinkList #include&lt;cstdlib&gt; #include&lt;iostream&gt; using namespace std; #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define...
数据结构之实用单链表(参考整理严蔚敏数据结构)
EditGP的专栏
11-01 816
#include using namespace std; typedef int ElemType; typedef struct Node { ElemType data; Node *pNext; }Node,*Link; typedef struct LinkList { Link pHead; Link pTail; int Length; }LinkList; voi
C语言-头插法-尾插法建单链表
huangjiaaaaa的博客
02-19 6233
C语言单链表 1、单链表定义 链表是通过一组任意的存储单元来存储线性表中的数据元素，这些存储单元可以是连续的也可以是不连续的。为了建立起数据元素之间的关系，对于每个数据元素除了存放数据元素自身的信息外，还必须有包含的指示该元素直接后继元素存储位置的信息，这两部分信息组成一个结点，即每个结点都有至少包括两个域，一个域存储数据元素信息，称为数据域，另...
数据结构的查找操作
weiker12的专栏
08-06 1570
1.顺序表的查找： int LocateElem(SqList *L, ElemType e) //按元素值查找 { int i = 0; while (i length && L -> data[i] != e) i++; //遍历查找元素e if (i >= L ->length) //未找到时返回0 return 0; else return i+1;
单链表的基本操作（读取、插入、删除）及优缺点总结
rujin_shi的博客
03-06 4万+
1.单链表的读取 获取链表第i个数据的算法思路： 1. 声明一个指针p指向链表的第一个结点，初始化j从1开始； 2. 当j&lt; i 时，遍历链表，让p的指针向后移动，不断指向下一结点，j累加1； 3. 若到链表末尾p为空，说明第i个元素不存在； 4. 否则查找成功，返回结点p的数据。 /*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*/ /*操作结果： 用e返回...
实验2-单链表的建立及操作-数据结构（C语言）
qq_45773423的博客
03-27 8611
实验2 单链表的建立及操作 实验要求 1.建立一个带头结点的单链表，结点的值域为整型数据。要求将用户输入的数据按尾插入法来建立相应单链表。 2.设计一个函数在链表中查找元素x的位置，如果x不在链表中则返回-1。 3.设计一个函数将元素x插入第i个元素的后面。如果i大于链表的长度，则将x插入链表的末尾，如果i小于或等于0，则将x直接插入表头之后。 实验过程及结果 1.基本思路： 定义一个结点的...
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6114
单链表的操作与实现
数据结构与算法学习笔记：线性表和顺序存储
"数据结构与算法的学习笔记，包含基本数据结构的概念、代码实现及图片，但笔记格式不美观。" 本文将深入探讨数据结构与算法的相关知识，首先，我们要理解数据结构这一概念。数据结构是一门研究非数值计算中数据元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

清纯献给了作业

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值