数据结构--笔记--线性表

于 2023-08-22 21:32:10 发布
阅读量177 收藏 2
点赞数
文章标签： 数据结构 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tao0212/article/details/132428861
版权

2.1线性表定义

线性表------逻辑结构

线性表是具有相同（每个数据元素所占空间一样大）数据类型的n（n≥0）个数据元素的有限 序列（有次序），其中n为表长，当n = 0时线性表是一个空表。

在这里插入图片描述

注：数据结构三要素——逻辑结构、数据的运算、存储结构（物理结构）

线性表的基本操作

InitList(&L)：初始化表。构造一个空的线性表L，分配内存空间。

DestroyList(&L)：销毁操作。销毁线性表，并释放线性表L所占用的内存空间。

ListInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e。

ListDelete(&L,i,&e)：删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。

LocateElem(L,e)：按值查找操作。在表L中查找具有给定关键字值的元素。

GetElem(L,i)：按位查找操作。获取表L中第i个位置的元素的值。
其他常用操作：

Length(L)：求表长。返回线性表L的长度，即L中数据元素的个数。

PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。

Empty(L)：判空操作。若L为空表，则返回true，否则返回false。

在这里插入图片描述

2.2线性表存储/物理结构

顺序表（顺序存储）

顺序表——用顺序存储的方式实现线性表顺序存储。把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。

顺序表结构体

typedef
struct {
	int num ;	//号数
	int people;	//人数
} Customer;

顺序表—静态分配

#include <stdlib.h>

#define MaxSize10	//定义最大长度
typedef struct{
	ElemType data[MaxSize];	//用静的“数组”存放数据元素
	int length;	//顺序表的当前长度
}SgList;	//顺序表的类型定义(静态分配方式)

//基本操作一初始化一个顺序表
void InitList(SqList &L){
	for(int i=0;i<MaxSize; i++)
		L.data[i]=0;	//将所有数据元素设置为默认初始值
	L.length=0;	//顺序表初始长度为9
}

顺序表—动态分配

#include <stdlib.h>

#define InitSize 10	//顺序表的初始长度
typedef struct{
	ElemType *data;	//指示动态分配数组的指针
	int MaxSize;	//顺序表的最大容量
	int length;	//顺序表的当前长度
} SeqList;	//顺序表的类型定义(动态分配方式)

void InitList(SeqList &L){
//用 malloc 函数申请一片连续的存储空间
	L.data=(int *)malloc(InitSize*sizeof(int));
	L.length=0;
	L.MaxSize=InitSize;
}

//增加动态数组的长度
void IncreaseSize(SeqList &L， int len){
	int *p=L.data;
	L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));
	for(int i=0; i<L.length; i++){
		L.data[i]=p[i];	//将数据复制到新区域
	}
	L.MaxSize=L.MaxSize+len;	//顺序表最大长度增加 len
	free(p);	//释放原来的内存空间
}

顺序表的特点：
①随机访问，即可以在 O(1) 时间内找到第 i 个元素。
②存储密度高，每个节点只存储数据元素
③拓展容量不方便（即便采用动态分配的方式实现，拓展长度的时间复杂度也比较高）
④插入、删除操作不方便，需要移动大量元素

在这里插入图片描述

顺序表----插入

ListInsert(&L,i,e)：插入操作。在表L中的第i个位置（位序）上插入指定元素e。

#include <stdlib.h>

#define MaxSize10	//定义最大长度
typedef struct{
	ElemType data[MaxSize];	//用静态的“数组”存放数据元素
	int length;	//顺序表的当前长度
}SgList;	//顺序表的类型定义(静态分配方式)

void ListInsert(SqList &L,int i,int e){	//基本操作：在L的位序 i 处插入元素e	
	if(i<1 i>L.length+1)	//判断i的范围是否有效
		return false;
	if(L.length>=MaxSize)	//当前存储空间已满，不能插入
		return false;
	 for(int j=L.length;j>=i;j--) //将第个元素及之后的元素后移
 		L.data[j]=L.data[j-1];	//注意位序、数组下标的关系，并从后面的元素依次移动
	L.data[i-1]=e;	//在位置i处放入e
	L.length++;	//长度加1
	return true;
}


int main(){
	SqList L;	//声明一个顺序表
	InitList(L);//初始化顺序表
	//...此处省略一些代码，插入几个元素
	ListInsert(L，3，3);
	return 0;
}
顺序表----删除
bool ListDelete(SqList &L,int i,int &e){
	if(i<1 i>L.length)//判断i的范围是否有效
		return false;
	e=L.data[i-1];	//将被删除的元素赋值给e
	for(int j=i;j<L.length;j++)//将第i个位置后的元素前移
		L.data[j-1]=L.data[j];	//注意位序、数组下标的关系，并从前面的元素依次移动
	L.length--;		//线性表长度减1
	return true;
}

int main() {
	SqList L;//声明一个顺序表
	InitList(L);//初始化顺序表
	//...此处省略一些代码，插入几个元素
	int e =-1;	//用变量e把删除的元素”带回来“
	if (ListDelete(L，3,e))
		printf("已删除第3个元素，删除元素值为=%d\n"，e);
	else
		printf("位序i不合法，删除失败\n");
	return 0;
}

在这里插入图片描述

顺序表----查找
按位查找

GetElem(L,i)：按位查找操作。获取表L中第i个位置的元素的值。

#include <stdlib.h>

#define MaxSize10	//定义最大长度
typedef struct{
	ElemType data[MaxSize];	//用静态的“数组”存放数据元素
	int length;	//顺序表的当前长度
}SgList;	//顺序表的类型定义(静态分配方式)

//和访问普通数组的方法意义
ElemType GetElem(SqList L, int i){
return L.data[i-1];
}

在这里插入图片描述

在这里插入图片描述

按值查找

LocateElem(L,e)：按值查找操作。在表L中查找具有给定关键字值的元素。

#include <stdlib.h>

#define InitSize 10	//顺序表的初始长度
typedef struct{
	int*data;	//指示动态分配数组的指针
	int MaxSize;	//顺序表的最大容量
	int length;	//顺序表的当前长度
} SeqList;	//顺序表的类型定义(动态分配方式)


//在顺序表L中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SeqList L,ElemType e){
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1; //数组下标为i的元素值等于e，返回其位序i+1
	return 0; //退出循环，说明查找失败
}

在这里插入图片描述

链表（链式存储）

单链表

不带头结点的单链表

typedef	struct LNode{		//定义单链表结点类型（结点）
	ElemType data;		//每个节点存放一个数据元素（数据域）
	struct LNode *next;	//指针指向下一个节点（指针域）
}LNode, *LinkList;


//初始化一个空的单链表
bool InitList(LinkList & ) {
	L = NULL;	//空表，暂时还没有任何结点
	return true;
}

void test(){//声明一个指向单链表的指针
	LinkList L;
	//初始化一个空表
	InitList(L);
	//......后续代码......
}

//判断单链表是否为空
bool Empty(LinkList L) {
	if (L == NULL)
		return true;
	else
		return false;
}//或者
bool Empty(LinkList L) {
	return (L==NULL);
}

struct LNode * p =(struct LNode *)malloc(sizeofstruct LNode));	//增加一个新的结点：在内存中申请一个结点所需空间，并用指针p指向这个结点

在这里插入图片描述
带头结点的单链表

typedef	struct LNode{		//定义单链表结点类型（结点）
	ElemType data;		//每个节点存放一个数据元素（数据域）
	struct LNode *next;	//指针指向下一个节点（指针域）
}LNode, *LinkList;

//初始化一个单链表 (带头结点)
bool InitList(LinkList &L) {
	L = (LNode *) malloc(sizeof(LNode)); //分配一个头结点
	if (L==NULL)		//内存不足，分配失败
		return false;
	L->next = NULL;		//头结点之后暂时还没有节点
	return true;
}

void test(){
	LinkList 	L;
	InitList(L);	
}

在这里插入图片描述
单链表—插入

带头结点

ListInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e。

typedef	struct LNode{		//定义单链表结点类型（结点）
	ElemType data;		//每个节点存放一个数据元素（数据域）
	struct LNode *next;	//指针指向下一个节点（指针域）
}LNode, *LinkList;


//在第 i个位置插插入元素 e(带头结点)
bool ListInsert(LinkList &L， int i, ElemType e){
	if(i<1)
		return false;
	LNode *p;		//指针p指向当前扫描到的结点
	int j=0;		//当前p指向的是第几个结点
	p=L;			//L指向头结点，头结点是第0个结点 (不存数据)
	while (p!=NULL && j<i-1){ 	//循环找到第 i-1 个结点
		p=p->next;
		j++;
	}
	if(p==NULL)	//i值不合法头
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next=p->next;	
	p->next=s;		//将结点s连到p之后
	return true;	//插入成功

不带头结点

```c
typedef	struct LNode{		//定义单链表结点类型（结点）
	ElemType data;		//每个节点存放一个数据元素（数据域）
	struct LNode *next;	//指针指向下一个节点（指针域）
}LNode, *LinkList;


//在第 i个位置插插入元素 e(带头结点)
bool ListInsert(LinkList &L， int i, ElemType e){
	if(i<1)
		return false;
	if(i==1){	//插入第1个结点的操作与其他结点操作不同
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s->data = e;
		s->next=L;
		L=s;	//头指针指向新结点
		return true;
	}
	LNode *p;		//指针p指向当前扫描到的结点
	int j=1;		//当前p指向的是第几个结点
	p=L;			//L指向头结点，头结点是第0个结点 (不存数据)
	while (p!=NULL && j<i-1){ 	//循环找到第 i-1 个结点
		p=p->next;
		j++;
	}
	if(p==NULL)	//i值不合法头
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next=p->next;	
	p->next=s;		//将结点s连到p之后
	return true;	//插入成功

指定结点的后插操作

//后插操作:在p结点之后插入元素e
bool InsertNextNode (LNode *p，ElemType e){
	if (p==NULL)
		return false;
	LNode_*s=LNode_*)malloc(sizeof(LNode));
	if (s==NULL)	//内存分配失败
		return false;
	s->data = e;	//用结点s保存数据元素e
	s->next=p->next;
	p->next=s;		//将结点s连到p之后
	return true;
}

指定结点的前插操作

//前插操作:在p结点之前插入元素e
bool InsertPriorNode (LNode *p，ElemType e){
	if (p==NULL)
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if (s==NULL)/内存分配失败
		return false;
	s->next=p->next;	//新结点 s连到 p之后
	p->next=s;		//将p中元素复制到s中
	s->data=p->data;p->data=e;	//p中元素覆盖为e
	return true;
}

单链表—删除

按序位删除（带头结点）

ListDelete(&L,i,&e)：删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。

bool ListDelete(LinkList &L，int i,ElemType &e）{
	if(i<1)
		return false;//指针p指向当前扫描到的结点
	LNode *p;
	int j=0;	//当前p指向的是第几个结点
	p=L;	//L指向头结点，头结点是第0个结点 (不存数据)
	while (p!=NULL && j<i-1){//循环找到第 i-1 个结点
		p=p->next;
		j++;
	}
	if(p==NULL)	//i值不合法
		return false;
	if(p->next == NULL)		//第i-1个结点之后已无其他结点
		return false;
	LNode *q=p->next;	//令q指向被删除结点
	e=q->data;			//用e返回元素的值
	p->next=q->next;	//将*q结点从链中“断开
	free(q);			//释放结点的存储空间
	return true;		//删除成功
}

指定结点删除

//删除指定结点 p
bool DeleteNode (LNode *p){
	if (p==NULL)
		return false;
	LNode *q=p->next;	//令q指向*p的后继结点金企金自
	p->data=p->next->data;	//和后继结点交换数据域
	p->next=q->next;	//将*q结点从链中“断开
	free(q);	//释放后继结点的存储空间
	return true;
}

在这里插入图片描述
单链表的查找

按位查找

//按位查找，返回第 个元素 (带头结点)
LNode * GetElem(LinkList L,int i){
	if(i<0)
		return NULL;
	LNode *p;	//指针p指向当前扫描到的结点
	int j=0;	//当前p指向的是第几个结点
	p=L;	//L指向头结点，头结点是第0个结点 (不存数据)
	while (p!=NULL && j<i){ 	//循环找到第 i 个结点
		p=p->next;
		j++;		
	return p;
}

按值查找

//按值查找，找到数据域==e 的结点
LNode * LocateElem(LinkList L,ElemType e) {
	LNode *p = L->next;
//从第1个结点开始查找数据域为e的结点
	while (p != NULL && p->data != e)
		p = p->next;
	return p;	//找到后返回该结点指针，否则返回NULL
}

求表的长度

//求表的长度
int Length(LinkList L){
	int len = 0;	//统计表长
	LNode *p = L;
	while (p->next != NULL){
		p = p->next;
		len++;
	return len;
}

在这里插入图片描述

单链表的建立

尾插法
在这里插入图片描述

头插法
在这里插入图片描述

双链表

双链表的初始化（带头结点）

typedef struct DNodef{	//定义双链表结点类型
	ElemType data;	//数据域
	struct DNode *prior*next;	//前驱和后继指针
}DNode，*DLinklist;

//初始化双链表
bool InitDLinkList(DLinklist&L){
	L=(DNode *)malloc(sizeof(DNode));  //分配一个头结点
	if (L==NULL)	//内存不足，分配失败
		return false;
	L->prior = NULL;	//头结点的prior 永远指向 NULL
	L->next = NULL;		//头结点之后暂时还没有节点
	return true;
}

双链表的插入

在这里插入图片描述
双链表的删除
在这里插入图片描述
双链表的遍历
在这里插入图片描述
在这里插入图片描述

循环链表

在这里插入图片描述
在这里插入图片描述
双链表的插入

//在p结点之后插入s结点
bool InsertNextDNode(DNode *p，DNode *s){//将结点*S插入到结点*p之后
	s->next=p->next;
	p->next->prior=s;
	s->prior=p;
	p->next=s;
}

双链表的删除
//删除p的后继结点q
p->next=q->next;
q->next->prior=p;
free(q);

在这里插入图片描述

静态链表

在这里插入图片描述

tao0212
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
考研数据结构-学习笔记
05-17
综上所述，线性结构是数据结构的基础，通过对线性表、栈、队列等的理解，可以为后续更复杂的非线性结构的学习打下坚实的基础。在实际应用中，根据问题的具体需求选择合适的存储方式和操作方法至关重要。
数据结构--线性表的销毁,逆置
fly
10-07 7244
c语言进行多次输入时可采用EOF来实现 while(scanf("%c%c%c",&ah,&ch,&bh)!=EOF)//进行多次输入用EOF
数据结构相关算法
Atkx's Blog
10-24 1213
顺序表基本运算的实现 假设ElemType为char类型，使用自定义类型语句 typdef char ElemType; 数组大小一般定义为一个整型常量，例如，把MaxSize定义为50 #define MaxSize 50 定义结构体SqList typedef struct { ElemType data[MaxSize]; //存放顺序表元素 int length; //存放顺序表的长度 } SqList; //顺序表的类型定义 1.建立顺序表 void Creat
数据结构与算法基础-学习-03-线性表之链式表-初始化、销毁、清理、获取长度、判断为空、获取元素等实现
qq_45111959的博客
11-28 941
数据结构与算法基础-学习-03-线性表之链式表-初始化、销毁、清理、获取长度、判断为空、获取元素等实现
数据结构———线性表（考研：第二章）
L093117l的博客
04-28 468
数据结构——线性表（考研）一、线性表的基本概念二、线性表的实现1.顺序存储2.链式存储（1）单链表（2）双链表（3）循环链表（4）静态链表（借助数组实现）三、线性表的应用 一、线性表的基本概念 1.线性表的定义 线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长。 2.线性表的基本操作 InitList(&L):初始化表。构造一个空的线性表。 Length（L）：求表长。返回线性表L的长度，即L中数据元素的个数 LocateElem（L，e）：按值查找操作。在表L中查找具有给定关键值的
线性表的顺序存储的介绍 — 基本运算(销毁线性表、输出线性表、增删查等)和 静态分配和动态分配
weixin_53161762的博客
03-11 2339
一、什么是线性表？ 线性表是由n(n≥0)个属性相同的数据元素a1,a2…an组成的一个有限序列。 可以表示为 A= (a1, a2, a3, … ai … an) 二、线性表的特征： 1、有且只有一个表头元素a1，它无前驱； 2、有且只有一个表尾元素an，它无后继； 3、表头元素与表尾元素外，其它所有元素有且只有一个前驱，也有且只有一个后继。 4、线性表中结点的个数n称为线性表的长度。当n＝0时，称为空表。 线性表 A= (a1, a2, a3, … ai … an) ，以线性表A为例，a2的前驱是a1，
笔记-数据结构.docx
08-07
数据结构笔记 数据结构是一门基础学科，它是计算机科学和技术的核心组成部分。数据结构是指在计算机中存储、组织和管理数据的方式，它是计算机程序设计和算法实现的基础。 一、 线性表 线性表是数据结构的基本...
考研复习知识笔记-数据结构
04-16
数据结构笔记-考研复习 数据结构是计算机科学中的一门重要学科，研究如何组织、存储和使用数据。下面是考研复习笔记中的一些重要知识点： 1. 数据结构定义：数据结构是指数据元素之间的逻辑关系、数据的运算和存储...
计算机数据结构笔记-计算机数据结构
最新发布
05-26
6. 线性表是一种基础的数据结构，由n个（n≥0）数据元素组成的有限序列。线性表的操作包括初始化、获取长度、查找、插入和删除等。顺序表是线性表的一种存储结构，元素在内存中连续存放，插入和删除操作可能导致大量...
数据结构与算法笔记-线性表定义和特点
01-07
线性表示相当灵活的数据结构，其长度可以根据需要适当的增长或者缩短，即对线性表的数据元素不仅可以进行访问，而且可以进行擦汗如和删除等操作。 一、下列给出线性表的抽象数据类型定义： ADT 线性表 （list） Data...
销毁线性表
m0_47058889的博客
04-14 4433
销毁i线性表 void DestroyList(Link node*&L) { Linknode*pre=L,*p=L-> next; while(p!=Null) { 加粗样式free(pre); pre=p; p=pre->next; } free(pre); } 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习...
线性表的销毁
qq_45543503的博客
12-02 2936
v oid DestroyList(List &L) { if (L.elems) delete []L.elems;//释放存储空间 L.length = 0; L.size = 0; }
c语言如何销毁线性表
weixin_35750747的博客
01-13 679
在 C 语言中，可以使用 free() 函数来销毁线性表。在使用前需要先使用 malloc() 或者 calloc() 函数为线性表分配内存，然后再在不再使用该线性表时，使用 free() 函数释放该线性表占用的内存。 例如： int* list = (int*) malloc(sizeof(int) * 10); // 使用线性表 ... free(list); ...
数据结构与算法基础（王卓）（3）：关于线性表的操作
Zz_zzzzzzz__的博客
12-01 1105
j >= i - 1;j--)//j为下标。按照书上的写法：（不要忘了： return OK;{//insert:插入//i:插入位置(位置序号)原因不在我写的操作函数里，而是在前面的类体当中；有关于线性表的所有基本操作到此为止，完结撒花。//把插入位置后面的元素全部往后移。下一节，我们开关于链表的学习。
数据结构摧毁线性表用c语言,[简述]数据结构-线性表(c语言实现)
weixin_27252001的博客
05-24 1424
[简述]数据结构-线性表(c语言实现)second60 201804221.线性表的定义线性表是具有相同特性的数据元素的一个有限序列。2.线性表抽象数据类型描述ADT List{数据对象：D = { ai | 1<= i <= n,n>=0,ai 属于ElemType类型}数据关系：R={ | ai, ai+1属于D, i=1...n-1}基本运算：initList(&am...
数据结构C语言-线性表的定义、销毁及增删改查（数据运算）
T1cH9的博客
05-26 1300
声明部分： #include <stdio.h> #include <stdlib.h> #define INIT_SIZE 1 #define BOLCK_SIZE 10 typedef struct { int *data; int length; int MaxSize; } SqList; SqList CreateListInt(); //创建线性表 void DestoryList(SqList *L); //销毁线性表 void Inc
线性表的代码实现（基于c语言）
m0_71772987的博客
03-15 668
printf("前驱值:%d\n后继值:%d", PriorElem(&L, cur_e), NextElem(&L, cur_e));定义：一个线性表是n个数据元素的有限序列，当n=0时称为空表，除了第一个元素和最后一个元素，其它元素都有直接前驱和直接后继元素。#返回表中与e相等的元素的序号。1、头文件(list.h)#调用线性表相关操作示例。#返回第i个数据元素的值。源文件(list.c)
线性链表的操作（查找、插入、删除、销毁）
CODEING一场空的博客
01-21 2517
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef int elemtype; typedef struct LNode { elemtype data; elemtype len; struct LNode *next; }LNode, *Linklist; Linklist Initlist()//初始化线性表 { ...
数据结构-线性表的链式表示--单链表的基本操作（初始化；销毁；头插法，尾插法创建；按序号，按值查找；求长度；插入；删除；合并；打印）（带注解）
qq_62630363的博客
11-19 344
为了避免顺序表在做插入，删除操作时，要移动大量元素，我们用链式存储结构来标识线性表，但它同时也失去了顺序表的可随机存取的优点。
C++实现线性表：数据结构电子笔记2
"这是一份关于数据结构的C++版电子笔记，主要涵盖了线性表的逻辑结构和顺序存储结构，并提供了相应的操作实现。" 在数据结构中，线性表是一种基本且重要的数据组织形式。线性表是由零个或多个相同类型的数据元素...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值