[数据结构]第二章--线性表(读书笔记3)

最新推荐文章于 2022-02-24 21:22:09 发布
最新推荐文章于 2022-02-24 21:22:09 发布
阅读量859 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Last_Impression/article/details/8534388
本文介绍线性表的两种链式表示方法：静态链表和双向链表。静态链表利用一维数组和游标实现链式结构，便于进行插入和删除操作。双向链表则采用指针连接前后节点，支持高效地向前和向后遍历。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

2.3 线性表的链式表示和实现

□静态链表
有时，也可借用一维数组来描述线性表，同时用游标(指示器cur)代替指针指示结点在数组中的相对位置。数组的第0分量可看成头结点，其指针域指示链表的第一个结点。
这种存储结构仍需要分配一个较大的空间，但在作线性表的插入和删除操作的时候不需移动元素，仅需修改指针，故仍有链式结构的主要优点。为了和指针型描述的线性链表相区别，我们给这种用数组描述的链表起名叫静态链表。

#define MAXSIZE 1000 /*链表的最大长度*/
typedef struct {
	ElemType data;
	int cur;
}component,SLinkList[MAXSIZE];
/*将整个数组空间初始化成一个链表*/
void InitSpace_SL(SLinkList space)/* 算法2.14 */
{	/*将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，0表示空指针*/
	int i;
	for (i = 0; i < MAXSIZE - 1; ++i){
		space[i].cur = i + 1;
	}
	/*最后一个元素为空指针*/
	space[MAXSIZE].cur = 0;
}
/*从备用空间取得一个结点,space[0].cur为备用链表的头指针*/
int Malloc_SL(SLinkList space) /* 算法2.15 */
{	/* 若备用链表非空,则返回分配的结点下标(备用链表的第一个结点),否则返回0 */
	int i = space[0].cur;/*从备用空间取得一个结点*/
	if (space[0].cur){/* 备用链表非空 */
		space[0].cur = space[i].cur;/* 备用链表的头结点指向原备用链表的第二个结点 */
	}
	return i;/* 返回新开辟结点的坐标 */
}
/*将空闲结点链结到备用链表上*/
void Free_SL(SLinkList space,int k) /* 算法2.16 */
{ /* 将下标为k的空闲结点回收到备用链表(成为备用链表的第一个结点) */
	space[k].cur = space[0].cur;/* 回收结点的＂游标＂指向备用链表的第一个结点 */
	space[0].cur = k;/* 备用链表的头结点指向新回收的结点 */
}
int _tmain(int argc, _TCHAR* argv[])
{
	SLinkList list;
	int pos = 0;

	InitSpace_SL(list);
	pos = Malloc_SL(list);
	Free_SL(list,pos);
	return 0;
}

线性表的双向链表：

/*线性表的双向链表存储结构*/
typedef struct DulNode{
	ElemType data;
	struct DulNode *prior;
	struct DulNode *next;
}DulNode,*DuLinkList;

Status InitList(DuLinkList *L)
{ /* 产生空的双向循环链表L */
	*L = (DuLinkList)malloc(sizeof(struct DulNode));
	if (*L){
		(*L)->next = (*L)->prior = *L;
		return OK;
	}
	else{
		return OVERFLOW;
	}
}
Status DestroyList(DuLinkList *L)
{ /* 操作结果：销毁双向循环链表L */
	DuLinkList p = (*L)->next; /* p指向第一个结点 */
	DuLinkList q = NULL;
	while(p != *L){ /* p没到表头 */
		q = p->next;
		free(p);
		p = q;
	}
	free(*L);
	*L = NULL;
	return OK;
}
Status ClearList(DuLinkList L) /* 不改变L */
{ /* 初始条件：L已存在。操作结果：将L重置为空表 */
	DuLinkList p = L->next; /* p指向第一个结点 */
	DuLinkList q = NULL;
	while(p != L){ /* p没到表头 */
		q = p->next;
		free(p);
		p = q;
	}
	L->next = L->prior = L; /* 头结点的两个指针域均指向自身 */
	return OK;
}
Status ListEmpty(DuLinkList L)
{ /* 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
	if (L->next == L && L->prior == L){
		return TRUE;
	}
	else{
		return FALSE;
	}
}
int ListLength(DuLinkList L)
{ /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
	DuLinkList p = L->next; /* p指向第一个结点 */
	int count = 0;
	while(p != L){ /* p没到表头 */
		p = p->next;
		count++;
	}
	return count;
}
Status GetElem(DuLinkList L,int i,ElemType *e)
{ /* 当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */
	DuLinkList p = L->next; /* p指向第一个结点 */
	int count = 1;
	if (i < 1){
		return ERROR;
	}
	while(p != L && count < i) /* 顺指针向后查找,直到p指向第i个元素或p指向头结点 */
	{
		p = p->next;
		count++;
	}
	if( p == L || count > i ){ /* 第i个元素不存在 */
		return ERROR;
	}
	*e = p->data; /* 取第i个元素 */
	return OK;
}
int LocateElem(DuLinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{ /* 初始条件：L已存在，compare()是数据元素判定函数 */
   /* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */
   /*           若这样的数据元素不存在，则返回值为0 */
	DuLinkList p = L->next; /* p指向第一个结点 */
	int pos = 1;
	while (L != p){
		if (compare(e, p->data)){/* 找到这样的数据元素 */
			return pos;
		}
		pos++;
		p = p->next;
	}
	return 0;
}
Status PriorElem(DuLinkList L,ElemType cur_e,ElemType *pre_e)
{	/* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */
	/*           否则操作失败，pre_e无定义 */
	DuLinkList p = L->next->next; /* p指向第2个元素 */
	while (L != p){
		if (cur_e == p->data){/* 找到这样的数据元素 */
			*pre_e = p->prior->data;
			return TRUE;
		}
		p = p->next;
	}
	return FALSE;
}
Status NextElem(DuLinkList L,ElemType cur_e,ElemType *next_e)
{	/* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
	/*           否则操作失败，next_e无定义 */
	DuLinkList p = L->next; /* p指向第1个元素 */
	while (L != p){
		if (cur_e == p->data && p->next != L){/* 找到这样的数据元素 */
			*next_e = p->next->data;
			return TRUE;
		}
		p = p->next;
	}
	return FALSE;
}
DuLinkList GetElemP(DuLinkList L,int i) /* 另加 */
{	/* 在双向链表L中返回第i个元素的位置指针(算法2.18、2.19要调用的函数) */
	int j;
	DuLinkList p = L;
	for(j = 1; j <= i; j++){
		p = p->next;
	}
	return p;
}
Status ListInsert(DuLinkList L, int i, ElemType e) /* 改进算法2.18 */
{ /* 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1 */
	if(i < 1 || i > ListLength(L) + 1 ){ /* i值不合法 */
		return ERROR;
	}
	/* 在L中确定第i-1个元素的位置指针p */
	DuLinkList p = GetElemP(L, i - 1);
	if( !p ){ /* p=NULL,即第i-1个元素不存在 */
		return ERROR;
	}
	DuLinkList newNode = (DuLinkList)malloc(sizeof(struct DulNode));
	newNode->data = e;/* 在第i-1个元素之后插入 */
	newNode->next = p->next;
	newNode->prior = p;
	p->next->prior = newNode;
	p->next = newNode;
	return OK;
}
Status ListDelete(DuLinkList L,int i,ElemType *e) /* 算法2.19 */
{ /* 删除带头结点的双链循环线性表L的第i个元素,i的合法值为1≤i≤表长+1 */
	if(i < 1 || i > ListLength(L)){ /* i值不合法 */
		return ERROR;
	}
	/* 在L中确定第i-1个元素的位置指针p */
	DuLinkList p = GetElemP(L, i);
	if( !p ){ /* p=NULL,即第i-1个元素不存在 */
		return ERROR;
	}
	*e = p->data;
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	return OK;
}
void ListTraverse(DuLinkList L,void(*visit)(ElemType))
{ /* 由双链循环线性表L的头结点出发,正序对每个数据元素调用函数visit() */
	DuLinkList p = L->next; /* p指向头结点 */
	while (p != L){
		visit(p->data);
		p = p->next;
	}
	printf("\n");
}
void ListTraverseBack(DuLinkList L,void(*visit)(ElemType))
{ /* 由双链循环线性表L的头结点出发,逆序对每个数据元素调用函数visit()。另加 */
	DuLinkList p = L->prior; /* p指向尾结点 */
	while (p != L){
		visit(p->data);
		p = p->prior;
	}
	printf("\n");
}
Status compare(ElemType c1,ElemType c2) /* 数据元素判定函数(判定相等) */
{
	if(c1 == c2){
		return TRUE;
	}
	else{
		return FALSE;
	}
}
void vd(ElemType c) /* ListTraverse()调用的函数(类型一致) */
{
	printf("%d ",c);
}
int _tmain(int argc, _TCHAR* argv[])
{
   DuLinkList L;
   int i,n;
   Status j;
   ElemType e;
   InitList(&L);
   for(i=1;i<=5;i++)
     ListInsert(L,i,i); /* 在第i个结点之前插入i */
   printf("正序输出链表：");
   ListTraverse(L,vd); /* 正序输出 */
   printf("逆序输出链表：");
   ListTraverseBack(L,vd); /* 逆序输出 */
   n=2;
   ListDelete(L,n,&e); /* 删除并释放第n个结点 */
   printf("删除第%d个结点，值为%d，其余结点为：",n,e);
   ListTraverse(L,vd); /* 正序输出 */
   printf("链表的元素个数为%d\n",ListLength(L));
   printf("链表是否空：%d(1:是 0:否)\n",ListEmpty(L));
   ClearList(L); /* 清空链表 */
   printf("清空后，链表是否空：%d(1:是 0:否)\n",ListEmpty(L));
   for(i=1;i<=5;i++)
     ListInsert(L,i,i); /* 重新插入5个结点 */
   ListTraverse(L,vd); /* 正序输出 */
   n=3;
   j=GetElem(L,n,&e); /* 将链表的第n个元素赋值给e */
   if(j)
     printf("链表的第%d个元素值为%d\n",n,e);
   else
     printf("不存在第%d个元素\n",n);
   n=4;
   i=LocateElem(L,n,compare);
   if(i)
     printf("等于%d的元素是第%d个\n",n,i);
   else
     printf("没有等于%d的元素\n",n);
   j=PriorElem(L,n,&e);
   if(j)
     printf("%d的前驱是%d\n",n,e);
   else
     printf("不存在%d的前驱\n",n);
   j=NextElem(L,n,&e);
   if(j)
     printf("%d的后继是%d\n",n,e);
   else
     printf("不存在%d的后继\n",n);
   DestroyList(&L);
	return 0;
}

 

C++:关键字：explicit：错误 conversion from ‘int’ to non-scalar type ‘abc’ requested
mzhan017的博客
11-25 4711
文章目录错误如果带上这个explicit 关键字从编译器看这个功能y 错误 class abc { //abc(int a): a(a){} 、、copy-initialization selects abc::abc(int) explicit abc(int a): a(a){} 、、、 这里使用了explicit } int main() { abc c=1; abc b(1.01); explict.cpp:22:7: error: conversion from ‘int’ to n
考研系列-数据结构第二章、线性表
最新发布
Nelson_hehe的博客
06-09 2520
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
[数据结构]第二章--线性表(读书笔记1)
千月星跡
01-23 1290
第二章--线性表 2.1 线性表的类型定义 □什么是线性表结构的特点 存在唯一的一个被称作第一个的数据元素。存在唯一的一个被称作最后一个的数据元素，除第一个之外，集合中的每个数据元素均只有一个前驱也均只有一个后继。 □什么是线性表 线性表(linear_list)是最常用且最简单的一种数据结构，简言之一个线性表是n个数据元素的有限序列。在稍复杂的线性表中，一个数据元素可以由若干个数据项(
数据结构(C语言版)第二章读书笔记
weixin_33895604的博客
12-21 250
1.带头结点单链表的长度计算？ intListLength(LinkListL){inti=0;LinkListp=L->next;while(p){++i;p=p->next;}returni;} i的初值设为0而非1，p指针设为头指针L的下一个节点，即链表除头...
c++中的explicit与隐式转换注意事项（错误代码:conversion from ‘int‘ to non-scalar type ‘Date‘ requested）
qq_52144697的博客
04-27 1807
“类名 对象名 = 传参” 有两个含义： 1.隐式转换 2.赋值 ## 先定义一个类，后续以此类作讲解 class 类名 { private: int num; public: 类名 （int n）:num(n) //有参构造，并把传入的n赋值类num { } . . . . }； 隐式转换含义 c++中，对类定义对象，并向有参构造函数传参时， 若以下式写法： int main(int argc,int* argv) { 类名 对象名 =
C编译问题解决
qq_41550480的博客
08-27 1035
编译问题解决： memset(g_log,0,XX_LOG_LEN); error: ‘xxErrLog’ undeclared (first use in this function) 错误：“xxErrLog”未声明（首次在此函数中使用） conversion to non-scalar type requested 请求转换为非标量类型类型，强制转换类型应当转换为指针 ...
第二章 数据结构-线性表
qq_45604925的博客
10-08 740
注：这是本人观看B站王卓老师讲的数据结构与算法的学习笔记
2022王道考研数据结构笔记--第二章 线性表
weixin_41170125的博客
05-23 775
第二章 线性表 2.1 线性表的定义和基本操作 要点： 线性表的基本操作——创销、增删、改查 传入参数时，何时要用引用 & 2.2 线性表的顺序表示 2.2.1 顺序表的定义 顺序表的实现———静态分配 #include <stdio.h> #define MaxSize 10 //定义最大长度 typedef struct{ int data[MaxSize]; //用静态的“数组”存放数据元素 ElemType:int int Length;
【2月第四周学习记录】数据结构与算法王卓-第二章线性表-单链表（函数定义篇）
”好的程序员不应该花大量时间在程序调试上，bug从一开始就不该被引入“
02-24 1288
1.单链表的存储结构与定义 存储结构 typedef说明：typedef int status。第一个是类型，第二个是赋予的对象。在下例中，赋予的是一个指针Linklist，之后可以直接用Linklist代表类似图中L，p的指向结点的指针。Linklist L = Lnode *L，更简单。 函数定义 链表一般用Linklist，定义指针用LNode。其实都对，但更习惯这样。 例：学生成绩表 为统一操作，一般将数据域单独定义。这样Lnode内只有数据域和指针域。 2. 功能函数定.
C++错误之路：conversion from ...const_iterator ... to non-scalar type ... requested
爱敲键盘的吉他手
09-02 6280
目录Contents出错代码bug原因分析修改方法1修改方法2版权声明 出错代码 #include <vector> #include <map> #include <iterator> using namespace std; template <typename T> void print1DVec(const vector<T>& vec){ typedef typename vector<T>::iterat
静态链表的实现
rujin_shi的博客
03-07 3587
静态链表 用数组来代替指针，来描述单链表 将数组元素分成两个数据域，data和cur。data用来存放数据元素，cur存放该元素的后继在数组中的下标(游标)。&lt;游标实现法&gt; 1.基本结构 /*线性表的静态链表存储结构*/ #define MAXSIZE 1000 typedef struct { ElemType data; int cur; /*游标(Cursor)，...
数据结构第三章 线性表
郑哥哥の博客
07-25 896
线性表：零个或多个数据元素的有限序列 注意： （1）线性表是一个序列，元素之间是有顺序的，若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他每个元素都有且仅有一个前驱和后继。 （2）线性表是有限的，即元素个数是有限的。 （3）线性表元素的个数n(n>=0)定义为线性表的长度，当n=0时，称为空表。 在较复杂的线性表中，一个数据元素可以由若干个数据项组成 线性表的抽象数据类型 ADT 线性表(List) Data Operation InitList(*L); //初始化操作，建立一
静态链表
java web 的专栏
03-19 1735
以前学习的各种链表都是由指针实现的，链表中结点的分配和回收(即释放)都是由系统提供的标准函数malloc和free动态实现的，故称之为动态链表。但是有的高级语言，如BASIC、FORTRAN等，没有提供”指针”这种数据类型，此时若想采用链表做存储结构，就必须使用”游标”来模拟指针，由程序员自己编写”分配结点”和”回收结点”的过程。    用游标实现链表，其方法是：定义一个较大的结构数组作为备用
大话数据结构学习day02
weixin_46350854的博客
06-18 210
线性表的单链表存储结构 typedef struct Node { ElemType data; struct Node* next; } Node; typedef struct Node* LinkList;
数据结构学习之路-第二章：静态单链表
月下的寂寞肖邦
08-27 872
【 声明：版权所有，转载请标明出处，请勿用于商业用途。  联系信箱：libin493073668@sina.com】 前言： 对于指针构造单链表的方法，我们在之前那篇博客里已经学完了，但是我们知道，指针是C/C++特有的神器，那么对于没有指针的其他语言，又该怎么去模拟链表呢？我们就需要使用静态链表的思想了。 接下里我们将要学习的就是如何不用指针来完成单链表的创建与操作。
数据结构面试题
tianya_team
03-04 569
1.单链表的排序 1）冒泡排序： typedef struct Node{ int val; node *next; Node(){ val = 0; next = NULL; } }node; void swap(int &a, int &b) { int temp = a; a = b; b = temp; } int Length(node *head){ int si
数据结构和算法1（线性表）
q1015189243的博客
02-08 257
算法基本特征：输入，输出，有穷性，确定性，可行性
Qt conversion from ‘XXX*’ to non-scalar type ‘XXX’ requested
热门推荐
小鹰信息技术服务部
07-10 1万+
Qt开发, 出现一个提示: conversion from ‘QSqlTableModel*’ to non-scalar type ‘QSqlTableModel’ requested 代码: QSqlTableModel tableModel = new QSqlTableModel(this, DB); 看着提示,好像是和指针有关. 解决方法:把变量声明为指针类型: QSql...
数据结构考研高分笔记精要第一章至第三章
### 第二部分：线性表 #### 2.1 线性表的基本概念与实现 - **线性表的概念**：线性表是最基本、最简单的一种数据结构，它是具有相同类型数据元素的有序集合。它只允许在表的前端进行删除和插入操作，在表的后端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

进击的横打

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

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

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

打赏作者

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

抵扣说明：

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

余额充值