数据结构学习--第2章

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

线性表

一、线性表的定义

线性表是具有相同数据类型的n（n>=0）个数据元素的有限序列。
相同：各数据元素所占空间一样大。
有序序列：有先后次序

线性表和顺序表、链表关系：
线性表：是一种逻辑结构，表示元素之间一对一相邻的关系。
顺序表、链表：是指存储结构。

位序与数组下标的区别：
位序：从1开始
数据下标：从0开始

二、线性表的顺序表示

顺序表的顺序存储又称顺序表。（用顺序存储方式实现的线性表）
顺序存储：逻辑上相邻的两个元素在物理位置上也相邻（逻辑顺序与物理顺序相同）

顺序表的特点：

  1. 顺序表支持随机存取 O(1) ，通常用数组来描述线性表的顺序存储结构。
  2. 存储密度高
  3. 扩展容量不方便
  4. 插入、删除不方便

静态分配与动态分配

静态分配：
数组大小和空间事先固定。

#define MaxSize 50 //静态分配下的顺序表最大长度
typedef struct {
	int data[MaxSize]; //静态数组存放元素
	int lenght; //当前长度
}SqList; //顺序表定的类型定义

动态分配：
存储数组的空间是在程序执行过程中通过动态分配语句分配的，可扩展存储空间

#define InitSize 50 //动态分配下的顺序表初始长度
typedef struct {
	int *data; //动态分配数组的指针
	int MaxSize，lenght; //最大容量和当前长度
}SqList; //顺序表定的类型定义

初始化动态分配语句

L.data = (int*)malloc(sizeof(int) * InitSize);

malloc：申请存储空间
free： 释放存储空间

插入操作

按位序插入

bool ListInsert(SqList &L,int i,int e){//i--位序，e--元素
//将e插入在第i个位置
	if(i<1||i>l.length+1) return false;
	
	if(L.length>=MaxSize) return false;
	
	for(int j = L.length;j>=i;j--){
		L.data[j] = L.data[j-1];
		//最后一次循环：j==i 将data[i-1]放到data[i]
	}
	L.data[i-1] = e;
	L.length++;
	return true;
}

时间复杂度关注深层循环语句循环次数：移动元素
最好情况：
在表尾插入：（i=length+1）O(1)
最坏情况：
在表头插入： （i==1）O(n)
平均情况：
pi=1/(n+1)
移动的平均次数：n*p+(n-1)*p+(n-2)p+…+1p+0p=n/2
O(n)=2/n

删除操作

按位序删除

bool ListDelete(SqList &L,int i,int &e){
	//将第i个元素删除，并返回删除元素e
	if(i<1||i>L.length) return false;//i范围是否有效
	
	e = L.data[i-1];
	
	for(int j = i;j<length;j++){//从下标为i的元素依次往前挪
		data[j-1] = data[j];
	}
	L.length--;
	return true;
}

最好情况：
在表尾删除：（i=length）O(1)
最坏情况：
在表头删除： （i==1）O(n-1)=O(n)
平均情况：
pi=1/n
移动的平均次数：(n-1)*p+(n-2)*p+(n-3)p+…+1p+0p=(n-1)/2
O(n)=(n-1)/2

查找

按位查找

查找第一个元素值等于e的元素，并返回位序

int LocateElem(SqList L,int e){//不用加&
	for(int i = 0;i<L.length;i++){
		if(L.data[i]==e) return i+1;
	}
	return 0;
}

复杂度：比较元素
最好情况：
在表头：比较一次 O(1)
最坏情况：
在表尾（不存在）：比较length次 O(n)
平均情况：
pi=1/n
比较的平均次数：n*p+(n-1)*p+(n-2)*p+…+1p=(n+1)/2
O(n)=(n+1)/2

按位查找

int GetElem(SqList L,int i){//不用加&
	return L.data[i];
}

时间复杂度：O(1)

三、线性表的链式表示

线性表的链式存储又称单链表 （不需要使用地址连续的存储单元）
链表节点内容：
①元素自身信息
②指向后续的指针

单链表表的特点：

  1. 不支持随机存取（非随机存储）
  2. 删除、插入不需要移动元素，只需修改指针
  3. 不需要大量连续的存储空间，但是链表附加指针域，存在浪费存储空间的缺点。

单链表

节点类型描述

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList;
//*LinkList 指向节点的指针

扩展： typedef <数据类型><别名>
强调是单链表：LinkList
强调是节点：LNode *
（LNode * L 和 LinkList L等价，声明了指向单链表的第一个节点的指针）

判空条件：
①不带头节点：
L == Null
②带头结点：
L->next == Null

建立（带头结点）

头插法（单链表的逆置）

新节点插入到单链表表头

在这里插入图片描述

LinkList List_HeadInsert(LinkList &L){
	LNode *s;int x;
	L = (LinkList)malloc(sizeof(LNode));//创建头节点
	L->next = NULL;//避免指向脏数据

	scanf("%d",&x);
	while(x!=9999){
		s = (LinkList)malloc(sizeof(LNode));
		//系统生成一个LNode的节点，并将节点起始位置赋值给s
		s->data = x;
		s->next = L->next;
		L->next = s;
		scanf("%d",&x); 
	}
	return L;
}

重要应用：链表的逆置
每插入一个新节点时间复杂度为：O(1)
总时间复杂度为：O(n)

尾插法(带头结点)

新节点插入到单链表表尾
添加了一个链尾指针
在这里插入图片描述

LinkList List_HeadInsert(LinkList &L){
	int x;
	LNode *s,*r=L;
	L = (LinkList)malloc(sizeof(LNode));//创建头节点
	L->next = NULL;//避免指向脏数据

	scanf("%d",&x);
	while(x!=9999){
		s = (LinkList)malloc(sizeof(LNode));
		//系统生成一个LNode的节点，并将节点起始位置赋值给s
		
		s->data = x;
		s->next = r->next;
		r->next = s;
		r=s;//跟随队尾移动
		scanf("%d",&x); 
	}
	r->next = NULL;
	return L;
}

每插入一个新节点时间复杂度为：O(1)
总时间复杂度为：O(n)

查找

按序号查找

位序查找

LNode *GetElem(LinkList L,int i){
	int j = 1; // 计数，初值为1

	LNode *p = L->next ;
	
	if(i<1) return NULL;

	while(p&&j<i){//从第1个节点开始找，找第i个
	//结束循环是j=i
		p = p->next;
		j++;
	}
	return p;
}

按序号查找：时间平均复杂度 O(n)

按值查找表节点
LNode *LocateElem(LinkList L,int e){
	//查找数据域等于e的节点并，返回该节点
	LNode *p = L->next;
	while(p!=NULL&&p->data!=e){//注意p判空在前
		p = p->next;
	}
	return p;
	//寻找失败返回NULL
}

按值查找：时间平均复杂度 O(n)

插入节点

按位序插入

插入结点将值为x的新节点插入到单链表的第i个位置上。
关键key：找到第i-1个结点

p=GetElem(L,i-1);
s->next = p->next;
p->next = s;

时间开销在查找第i-1个元素，时间复杂度为O(n)；
（ 若在给定结点后插入元素，O(1) ）

bool ListInsert(LinkList &L,int i,int e){
	if(i<1) return false;
	LNode *p;//指向当前扫描到的结点
	int j;//当前是第几个结点
	p=L；
	while(p!=NULL&&j<i-1){//找到第i-1个结点
		p = p->next;
		j++;
	}
	if(p == NULL){return false;}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s->next;
	return true;
}
前插插操作（扩展）

在某一结点前插入一个新的节点

  1. 遍历实现：
    从头节点开始顺序查找到其前驱节点，时间复杂度O(n)
  2. 非遍历：
    仍然将s插入到p后面
    将p->data和s->data交换，时间复杂度O(1)
s->next = p->next;
p->next = s->next;//修改指针域

temp = s->data;
s->data = p->data;
p->data = temp;//修改数据域
位序插入 （不带头节点）
bool ListInsert(LinkLst &L ,int i,int e){
	if(i<1) return false;
	
	if(i==1){//特殊处理
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s->data = e;
		s->next = L->next;
		L=s;
		return true;
	}
	LNode p = L;
	int j=1;
	while(p!=NULL&&j<i-1){
		p=p->next;
		j++;
	}
	if(p==NULL){return false;}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

删除

按位序删除

关键：找到第i-1个结点，既被删除结点的前驱结点

p = GetElem(L,i-1);
q = p->next;
p->next = q->next;
free(q);

时间耗费在查找上，时间复杂度：O(n)

删除指定结点*p
  1. 从链表头节点开始顺序找到p的前驱节点，然后执行删除操作。
    时间复杂度：O(n)
  2. 将后续结点值赋给自身，再删除p的后续结点
q=p->next;
p->data =q-data;
p->next = q->next;
free(q);

时间复杂度：O(1)

求表长

时间复杂度：O(n)

int getSize(LinkList &L){
	LinkList p=L;
	int j=0;
	while(p->next!=NULL){
		j++;
		p=p->next;
	}
	return j;
}

双链表

  1. 双链表结点中有两个指针prior(前驱节点)和next(后续结点)。
  2. 不支持随机存取

结点类型描述

typedef struct DNode{
	int data;
	struct LNode *prior,*next;
}DNode,*DLinkList;

查找

其按值查找和按位查找与单链表一致
只能遍历实现；O(n)

插入

在p结点之后插入*s

s->next = p->next;
if(p->next!=NULL)p->next->piror = s;//若p为最后一个结点跳过
p->next = s;
s->piror = p;

在p结点之前插入*s

s->next = p;
s->piror = p->piror;
if(p->piror!=NULL)p->piror->next = s;
p->piror = s;

删除

删除结点*p的后续结点 *q

p->next = q->next;
if(q->next!=NULL)q->next->prior = p;
free(q);

删除结点*p的前驱结点 *q

p->piror = q->piror;
if(q->prior!=NULL)q->piror->next = p;
free(q);

循环链表

  1. 表中最后一个结点指向头节点
    （初始化：L->next = L）
  2. 表中没有指针域为空的指针
    （判空： L->next==L。是否到队尾：p->next == L）
  3. 循环双链表在任何一个地方删除和插入操作都是等价的，不用判断是否是表尾
  4. 双链表可以从表中任意一个结点开始遍历整个链表
  5. 若常对表头、表尾进行操作；可以对循环单链表不设头指针，设尾指针r。(r->next 既头指针)
  6. 此时对头尾操作时间复杂度：O(1)；若只设头指针，对队尾操作时间复杂度：O(n)

循环双链表

  1. 头结点的prior指针指向表尾结点，表尾结点的next指针指向头节点
    (初始化：L->prior=L;L-next = L;)
  2. 当循环链表为空表时，其头结点piror和next都等于L。
  3. 插入与删除与双链表相同，不会出现NULL报错。

静态链表

定义：

  1. 借组数组来描述线性表的链式存储结构。
  2. 结点有data数据域和next指针域（结点的相对地址-数组下标(游标)）。
  3. 与顺序表一样，需要事先分配一块连续的内存空间

0号结点充当头指针，-1表示表尾，游标充当指针。

不支持随机存取，容量固定不变

扩展：
应用：放置在索引块的FAT（文件配置表）。
FAT支持随机访问（指不用依次访存），文件扩展也易实现。

结构类型描述

#define MaxSize 50
typedef struct{
	int data;
	int next;
}SLinkList[MaxSise];//可以用SLinkList来定义一个长为maxSize的数组
//struct Node a[maxSize] ~SLinkList a;

操作

  1. 初始化：a[0].next = -1;
  2. 按位序查找：从头结点开始依次遍历：O(n)
  3. 插入位序为i的结点：（与单链表类是）
    ①、找到一个为空的结点，存入数据
    ②、找到第i-1个结点
    ③、修改新结点的next值
    ④、修改i-1结点的next值

四、顺序表与链表的比较

都是线性结构

存取方式

  1. 顺序表可以顺序存取和随机存取~O(1)
  2. 链表只能从头顺序存取~O(n)

结构

  1. 顺序表：
    逻辑上相邻，物理存储位置上也相邻。(大片连续空间，存储密度高)
  2. 链表：
    逻辑上相邻，物理存储位置不一定相邻。（离散小空间）

操作

  1. 按值查找和，顺序表无序：O(1);有序时（折半）：O(log2n)
  2. 顺序表插入和删除，平均移动半个表长的元素（移动元素）：O(n)。
    链表的插入删除、删除修改相关指针域即可（查找目标元素）：O(n)

空间分配

  1. 顺序表：
    需预先分配足够大的存储空间。扩充效率低。
  2. 链式节点空间只在需要时申请分配。
–顺序表链表
可扩容—✔
增删—✔
查✔—
静静等花开
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-41
08-03
第 四 章 串学习要点1 了解串的基本操作，了解利用这些基本操作实现串的其它操作的方法；2 掌握在串的堆分配存储结构下，串的基本操作算法；3 掌握在串的模式匹配
Java程序设计与数据结构第二章习题答案
11-05
为学习Java程序设计的基础同学提供习题代码的参考，便于他们掌握多种方法，得到解决问题的思路与想法，Java程序设计与数据结构第二章习题答案！！！
《数据结构》（C++）之第二章：线性表
吃了么没吃回家吃点儿
12-15 406
概述：线性表是一种最基本、最简单的数据结构，数据元素之间仅具有前驱与后继关系 2.1 线性表的逻辑结构 2.1.1 线性表的定义 定义：线性表（linear list）简称表，是n（n &amp;gt;= 0）个 具有相同类型的数据元素 的 有限序列 长度：线性表中数据元素的个数 空表：长度为零时 非空表：L = (a1, a2, ···, an)，其中，a(i) （1 &amp;lt;= i ...
数据结构知识点总结(1).pdf
07-11
第一章 复杂度分析 时间复杂度 ： 大 o 表示法：c<log2 n<n<n*log2 n<n^2<n^3<n!<n^n 加法原理：Omax(f(n),g(n),h(n)……)\乘法原理： Omax(f(n )*g(n)) 空间复杂度： 第二章 数组存储 数组：( s:一个元素的大小、t:某个维度的长度） 1 维： &a[i]=a[0]+i*s 2 维： a[i][j]= & a[0][0]+( i * t2 +j)* s\ & a[0][0]+(j * t 1 + i)* s(列优先) 3 维： a[x][y][z]=&a[0][0][0]+(x*t2*t3+y*t3+z)*s n 维：&a[0][0]···[0]+Σij*cj (cj:j 后的维的长度的累乘） ps: 在首地址不是（00……）时，用减法求元素之间的空隙，"减后"+1 求维 的长度 （三）对角矩阵： 性质:3n-2 个元素 a[i][j]=&a[0][0]+( 2*i+j)*s=&a[0][0]+(3*i+(j-i))*s 对称矩阵（只存上（下）三角）： 下三角： ( i+1)* i/2+j（i>=j） j *(j+
数据结构教程第二章知识总结
qq_42148307的博客
06-04 573
线性表(linear list)是具有相同特性的数据元素的一个有限序列。该序列中所含元素的个数叫线性表的长度,用n表示，n≥0。当n=0时，表示线性表是一个空表，即表中不包含任何元素。在线性表中每个数据元素由逻辑序号唯一确定,设序列中的第i(i表示逻辑序号)个元素为(1≤i≤n),则线性表的一般表示为：其中为第一个元素,又称为表头元素,为第2个元素,为最后一个元素，又称为表尾元素。当一个线性表元素有序(从小到大或者从大到小)排列时，称为有序线性表，简称为有序表。有序表属于逻辑结构(包括有序顺序表和有序链表)
区别顺序表的位序和数组下标：为何判断插入位置是否合法时if语句中用length+1，而移动元素的for语句中只用length？
wei_weiyang_yang的博客
08-05 1149
区别顺序表的位序和数组下标：为何判断插入位置是否合法时if语句中用length+1，而移动元素的for语句中只用length？
顺序表中序号与对应数组下标区别详解
weixin_47219110的博客
07-27 3668
顺序表 数组下标 a1 0 a2 1 a3 2 … … an n-1 由上表可以直观看到，顺序表中的序号是从1开始的，而数组下标是从0开始的，所以，在代码的编写过程中，要格外注意这个区别。 下列顺序表中的插入元素e操作为例： bool ListInsert(SqList &L,int i,ElemType e) { if(i<1IIi>L.length+1) return false; if(L.length>MaxSize) return fa...
数据结构第二章
惟愿一生无悔也无憾
10-01 436
数据结构第二章——开启数据结构的正文内容 第一章那个 绪论在这里：数据结构总结一 写得挺详细的（数据，数据项，数据元素，数据对象，数据结构，逻辑结构，存储结构，操作，算法和算法优劣性的评价（常考算法的性质，算法的评价标准））。 前话 数据结构的章节结构： 线性表 线性表的定义 ■ 线性表是n个具有相同类型数据元素的有限序列。 属于线性结构，如果是非空表（n>0），只有一个表首元素，一个表尾元素。并且除表首元素以外，每一个元素都有一个直接前驱，除表尾元素以外，每一个元素都有一个直接后继。 ■ 线性表具
数据结构-第2章-线性表.doc
10-10
数据结构-第2章-线性表.doc
数据结构 第七章-图2PPT学习教案.pptx
10-08
数据结构 第七章-图2PPT学习教案.pptx
数据结构——顺序表的基本操作
wrncxcy的博客
10-10 573
数据结构中顺序表的静态存储和动态存储
区别顺序表的位序和数组下标。为何在插入操作中判断插入位置是否合法时 if语句中用length+1,而移动元素的for语句只用length?
热门推荐
qq_45257495的博客
06-29 1万+
首先请看在顺序表中进行插入操作的代码实现： 要注意，位序是从1开始的，而数组是从0开始的。 这里为什么 if语句中用length+1，而for语句只用length？ 答：因为这里的i应该是位置，而不是下标。当i的值是[1,L->length+1]时，都是有效的插入位置。1表示用待插入元素取代第1个元素，L->length+1表示插入到最后一个元素的后面，实际上就是追加一个元素。只有当i<1 || i>L->length+1时插入位置才无效。如果改成i<1 || i&gt
浅了解数组
Aspect of Twilight的博客
10-26 483
如果我们想要存储1~10的数字，应该怎么存呢?int b = 2;int c = 3;int d = 4;int e = 5;int f = 6;int g = 7;int h = 8;int i = 9;int j = 10;return 0;我们发现，这样存储十分麻烦。这时我们又发现存储的类型都是整型，那么我们可否一次性创建一个大的存储空间来存放这些整数。
数据结构——第二章（线性表）
XiaoQi's Blog
01-29 512
线性表 1. 线性表的逻辑结构 定义：线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列。其中n为表长。当n=0时 线性表是一个空表 除第一个元素，其余元素都有一个直接前驱 除最后一个元素，其余元素都有一个直接后继 线性表中的元素从1开始，位序也就是指在第几个位置 2. 线性表的基本操作 初始化表、销毁、插入、删除、按值查找、按位查找、求表长、输出、判空 *2.1 &变量的介绍 对参数的修改结果需要带回来，则需要使用**&**引用类型 形参是引用类型，则与main函数
数据结构基础-单链表
xiongyuqing的博客
08-02 142
单链表 - xiongyuqing - 博客园 (cnblogs.com) 单链表 采用动态链表的方式： struct Node { int val; Node *next; } new Node(); // 非常慢 会非常慢，在算法竞赛中常常采用数组模拟链表，也叫静态链表 head：表示头节点下标 e[N]: 每个节点的值 ne[N]：每个节点的下一个节点编号(下标) 例如下面的链表： 初始化 // head：表示头节点的下标 // e[i]: 表示第i个节点的值 // ne[i]:
# 关于位序i与数组下标i的区别
ID__10086的博客
10-25 1336
什么时候是位序i，什么时候是下标i? 一般，在for循环条件语句内，i都表示为位序，这样方便人来计数，因为人都是从1开始计数； 计算机不是，计算机是从0开始的，这也就是为什么，同一个元素，在位序中它是就是i，而在数组下标中，它却是i-1； 譬如之前静态链表的插入与删除 L.data[i-1]=e;此处是在第i个位置插入元素e的代码；同样，e=L.data[i-1];是将第i个位置上的元素赋值给e，好将删除元素值返回。 ...
详解顺序表
最新发布
D3540987120的博客
10-02 508
线性表的顺序表示又称为顺序存储结构或顺序映像。百度百科：顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。
数据结构与算法第ba章笔记整理
09-02
数据结构与算法是计算机科学的基础和核心领域之一，第ba章介绍了数据结构的相关内容。 本章主要包括以下几个方面的内容： 1. 线性结构：线性结构是指数据元素之间存在一对一的关系，包括线性表、栈和队列。线性表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值