数据结构笔记（二）：线性表的抽象和代码实现

晓风残月淡

已于 2022-08-05 19:08:39 修改

阅读量462

点赞数

分类专栏：数据结构和算法文章标签：数据结构

于 2022-08-04 22:57:10 首次发布

本文链接：https://blog.csdn.net/qq_40610003/article/details/125781278

版权

数据结构和算法专栏收录该内容

5 篇文章 1 订阅

订阅专栏

1.什么是线性表？

线性表是最常用且最简单的一种数据结构。例如一串数字，一本书，字母表。

总之，线性表是n个数据元素的有限序列。具有如下特点：

（1）数据元素可以由若干数据项组成
（2）数据元素被称为记录，含有大量记录的线性表称为文件。
（3）数据元素必定具有相同特性，既属于同一数据对象。
（4）线性表是线性结构，除第一个外，只有一个直接前驱，除最后一个外，只有一个直接后继
（5）线性表中元素的个数定义为线性表的长度
（6）在非空表中，每个数据元素都有一个确定的位置。
（7）线性表是相当灵活的数据结构，长度可增长或缩短，数据元素可访问，还可插入和删除等。

1.1 线性表的类型定义


ADT List {
	数据对象：{ai|ai∈ElemSet,i=1,2,...,n,n≥0}
	数据关系：{<ai,ai-1>|ai-1,ai∈D,i=2,...,n}
	基本操作：
		InitList(&L)
			操作结果：构造一个空的线性表L
		DestroyList(&L)
			初始条件：线性表已存在
			操作结果：销毁线性表L
		ClearList(&L)
			初始条件：线性表L
			操作结果：将L重置为空表
		ListEmpty(L)
			初始条件：线性表L已存在
			操作结果：若L为空表，则返回true，否则返回false
		ListLength(L)
			初始条件：线性表L已存在
			操作结果：返回L中数据元素个数
		GetElem(L,i,&e)
			初始条件：线性表L已存在
			操作结果：用e返回L中第i个数据元素的值
		LocateElem(L,e)
			初始条件：线性表L已存在
			操作结果：返回L中第1个值域e相同的元素在L中的位置，若这样的数据元素不存在，则返回值为0
		PriorElem(L,cur_e,&pre_e)
			初始条件：线性表L已存在
			操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回其前驱，否则操作失败，pre_e无定义
		NextElem(L,cur_e,&next_e)
			初始条件：线性表L已存在
			操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回其后继，否则操作失败，next_e无定义
		ListInsert(&L,i,e)
			初始条件：线性表L已存在，且1≤i≤ListLength(L)+1
			操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
		ListDelete(&L,i,e)
			初始条件：线性表L已存在，且1≤i≤ListLength(L)
			操作结果：删除L的第i个数据元素，L的长度减1
}ADT List

1.2线性表的顺序存储结构和表示

顺序表具有以下特点：

地址连续
依次存取
随机存取
类型相同

根据这些特点，可以用一维数组表示顺序表。
数组长度不可动态定义，而线性表的长度是可以变得，因此，可以用一个变量表示顺序表的长度属性。

以多项式的顺序存储为例：
在这里插入图片描述

#define MAXSIZE 1000 //多项式可能达到的最大值

typedef struct {//多项式非零项的表示
	float p;//系数
	int e;//指数
}Polynomial;

typedef struct {
	Polynomial *elem;//存储空间的基地址
	int length;//多项式当前项的个数
}SqList;//多项式的顺序存储结构类型为SqList

一般，线性表的定义模板

#define LIST_INIT_SIZE 1000 //线性表存储空间的初始分配量

typedef struct {
	ElemType elem[LIST_INIT_SIZE];
	int length;//当前长度
}SqList;

元素类型补充说明:其中ElemType 可以是int，float的简单类型，也可以是类似Polynomial的复杂类型。

typedef struct {
	ElemType data[];
	int length;//当前长度
}SqList;

数组定义补充说明：数组可分为静态分配，也可分为动态分配。

//数组静态分配
typedef struct {
	ElemType data[MaxSize];
	int length;
}SqList;
//数组动态分配
typedef struct {
	ElemType *data;
	int length;
}SqList;
//动态分配的方式
SqList L;
L.data=(ElemType )malloc(sizeof(ElemType)*MaxSize);

C语言的内存动态分配和C++的内存动态分配

malloc(m):开辟m字节的地址空间，并返回空间的首地址
sizeof(x):计算变量x的长度
free(p):释放指针p所指变量的存储空间
所需加载头文件：<stdlib.h>
//
new 类型名T(初值列表)
功能：申请存放T类型的内存空间，并依初值列表赋一初值
结果值：T类型的指针，指向新分配的内存
失败：0(null)
delete 指针P
功能：释放指针P所指的内存。P必须是new操作的返回值。

操作算法中用到的预定义常量和类型

//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
//定义类型
typedef int Status;
typedef char ElemType;

1.1线性表的初始化

#include<stdlib.h>
#define MAXSIZE 100  //线性表存储空间的初始分配量

//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
//定义类型
typedef int Status;
typedef char ElemType;

#define LIST_INIT_SIZE 1000 
typedef struct {
	ElemType *elem;//动态分配内存
	int length;//当前长度
}SqList;
//1.线性表的初始化
Status InitList_Sq(SqList &L){ //构造一个空的顺序表
	L.elem=new ElemType[MAXSIZE]; //为顺序表分配存储空间
	if(!L.elem) exit(OVERFLOW);  //存储分配失败
	L.length=0;   //空表长度为0
	return OK;
}
//2.销毁线性表L
void DestroyList(SqList &L){
	if(L.elem) delete L.elem;//释放存储空间
}
//3.清空线性表L
void ClearList(SqList &L){
	L.length=0;//将线性表的长度设置为0
}
//4.球线性表L的长度
int GetLength(SqList &L){
	return L.length;
}
//5.判断线性表是否为空
int isEmpty(SqList &L){
	if(L.length==0)return 1;
	return 0;
}
//6.获取某个元素
int getElem(SqList &L,int i,ElemType &e){
	if(i<1||i>L.length) return ERROR;
	e=L.elem[i-1];
	return OK;
}
//7.返回某个元素的位置
int LocateElem(SqList L,ElemType e){
	for(int i=0;i<L.length;i++)
		if(L.elem[i]==e) return i+1;
	return 0;
}
//8.向某个位置插入元素
Status ListInsert(SqList &L,int i ,ElemType e){
	if (i<1||i>L.length) return ERROR;//检测位置是否越界
	if (L.length==MAXSIZE) return ERROR;//检测存储空间是否已满
	for (int j = L.length-1; j >= i-1; j--)L.elem[j+1]=L.elem[j];//从第i个位置的元素起后面的元素全部后移
	L.elem[i-1]=e;
	L.length++;//表长增加
	return OK;
}
//9.删除某个位置的元素
Status ListDelete(SqList &L,int i){
	if (i<1||i>L.length) return ERROR;//检测位置是否越界
	for(int j=i;j<=L.length;j++)
		L.elem[j-1]=L.elem[j];
	L.length--;//表长减少
	return OK;
}

顺序存储表的优缺点：
优点：

存储密度大
可以随机存取表中任一元素
缺点：
在插入和删除时，需要移动大量元素
存储空间不灵活，需要准备很大的存储空间，比较浪费
属于静态存储，数据元素的个数不能自由扩充

1.2顺序表的链式存储结构

1.2.1链表的存储结构

在这里插入图片描述
单链表：结点只有一个指针域的链表
双链表：结点有两个指针域的链表
循环链表：首尾相接的链表

1.2.2链表的表示

在这里插入图片描述
头指针：指向链表中第一个结点的指针
首元结点：立案表中存储第一个元素的结点
头结点：在首元结点之前附设的一个结点

如何表示空表？

无头结点，头指针为空表示空表
有头结点，头结点的指针域为空表示空表

在链表设置头结点有什么好处？

便于首元结点的处理：链表的第一个位置上的操作和其他位置一致，不需特殊处理
便于空表和非空表的同意处理：无论链表是否为空，头指针都市指向头结点的非空指针。

头结点的数据域内装的是什么？

在这里插入图片描述

单链表的定义和表示

//单链表的存储结构
typedef struct Lnode{
	ElemType data;//结点的数据域
	struct Lnode *next;//结点的指针域
}Lnode,*LinkList;//LinkList为指向结构体Lnode的指针类型
//定义链表
LinkList L;
//定义指向结点的指针
LNode *p;//虽然等价于LinkList p;但我们不这么使用
//定义结点
typeded Struct {
	char i;
	float j;
	... //数据域
} ElemType;

单链表基本操作实现

typedef struct LNode{
	ElemType data;//结点的数据域
	struct LNode *next;//结点的指针域
}LNode,*LinkList;

Status InitList_L(LinkList &L){
	L=new LNode;//或L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	return OK;
}
int isEmpty(LinkList L){
	if (L->next)
	{
		return 0;
	}else
	{
		return 1;
	}
}
//单链表的销毁，从头指针开始，依次释放所有结点
Status destroy(LinkList &L){
	LNode *p;
	while(L){
		p=L;
		L=L->next;
		delete p;
	}
	return OK;
}
//清空单链表，头指针和头结点依然存在，依次删除所有结点
Status Clear(LinkList &L){
	LNode *p,*q;
	p=L->next;
	while (p){//没到表尾
		q=L->next;		
		delete p;
		p=q;
	}
	L->next = NULL;
	return OK;
}
//求单链表的表长
int getLength(LinkList L){
	LNode *p;
	int length =0;
	p=L->next;
	while(p){
		length++;
		p=p->next;		
	};
	return length;
}
//获取链表中第i个与元素的值
ElemType getElem_L(LinkList L,int i,ElemType &e){
	LNode *p=L->next;int j=1;//初始化
	while (p&&j<i){//当i很大时，遍历到后面p不存在就停止，或者i为0，-1时不执行循环
		p=p->next;
		j++;
	}
	if(!p||j>i) return ERROR;//当i为0，-1，或者很大时，元素不存在
	e=p->data;//取第i个元素
	return OK;

}
//获取链表中某元素的位置,找到则返回指针地址，未找到则返回空
LNode* Locate(LinkList L,ElemType e){
	LNode *p = L->next;
	while(p&&p->data!=e)//如果p存在并且数据域不是要找的值，则执行循环
		p=p->next;
	return p;		
}
//插入——在第i个结点插入值为e的新结点
Status ListInsert(LinkList &L,int i,ElemType e){
	LNode *p=L;	
	int j=0;
	//注意：插入的结点有n+1个结点
	while(p&&j<i-1){
		p=p->next;
		j++;
	}
	if(!p || j>i-1) return ERROR;//当i很大时，遍历到最后p为NULL，当i很小时j大于i-1
	LNode *s=new LNode;
	s->data=e;
	s->next=p->next;
	p->next=s;
	return OK;
}
//删除第i个结点
Status ListDelete_L(LinkList &L,int i){
	LNode *p=L;
	int j=0;
	//注意：删除的结点有n个结点
	while (p->next&&j<i-1){
		p=p->next;
		j++;
	}
	//无结点可删时，返回错误
	if(!(p->next)||j>i-1) return ERROR;
	LNode *s=new LNode;
	s=p->next;
	p->next=s->next;
	delete s;
	return OK;
}

//创建一个单链表:头插法
void CreateList_H(LinkList &L,int n){
	L = new LNode;
	L->next=NULL;//先建立一个带结点的单链表
	for (int i = n; i >0; i--)
	{
		LNode *p= new LNode;
		std::cin >> p->data;
		p->next=L->next;
		L->next=p;
	}
}

晓风残月淡

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
数据结构笔记（二）：线性表的抽象和代码实现

ADT List {数据对象：{ai|ai∈ElemSet,i=1,2,...,n,n≥0}数据关系：{|ai-1,ai∈D,i=2,...,n}基本操作：操作结果：构造一个空的线性表L初始条件：线性表已存在操作结果：销毁线性表L初始条件：线性表L操作结果：将L重置为空表初始条件：线性表L已存在操作结果：若L为空表，则返回true，否则返回false初始条件：线性表L已存在操作结果：返回L中数据元素个数初始条件：线性表L已存在。..............................
复制链接

扫一扫