408数据结构之线性表(考研复习)

最新推荐文章于 2024-01-17 09:06:11 发布
最新推荐文章于 2024-01-17 09:06:11 发布
阅读量388 收藏 3
点赞数 3
分类专栏： 数据结构 笔记 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43903780/article/details/115175997
版权

目录

线性表

定义：线性表是具有相同数据类型的n个数据元素的有限序列。其中n为表长，当n=0时，线性表为空表。
特点：
1.表中的元素个数有限。
2.表中的元素具有逻辑上的顺序性，表示元素的先后顺序。
3.除了第一个元素外，每个元素有且仅有一个直接前驱;除了最后一个元素外，每个元素有且仅有一个直接后驱。
4.每个元素的数据类型相同。
5.仅讨论元素间的逻辑关系，不考虑元素是什么具体内容。

线性表基本操作

  1. InitList(&L) 初始化表
  2. Length(L) 求表长
  3. LocateElem(L,e) 按值查找
  4. GetElem(L,i) 按位找值
  5. ListInsert(&L,i,e) 插入操作
  6. ListDelete(&L,i,&e) 删除操作
  7. PrintList(L) 输出操作
  8. Empty(L) 判空操作
  9. DestoryList(&L) 销毁操作

线性表的顺序表示——顺序表

在这里插入图片描述

特点：1.顺序表中元素的逻辑顺序和物理顺序相同。2.表中任一元素都可以随机存储。

实现：
#include<stdio.h>
#include<stdlib.h>
#define Size 10

typedef struct{
	int *head;
	int MaxSize;
	int length;
}seqList;

void initList(seqList &L){
	L.head=(int*)malloc(Size*sizeof(int));
	if(!L.head){
		printf("动态分配内存失败");
		exit(0);
	}
	L.MaxSize=Size;
	L.length=0;
}

void input(seqList &L){
	for(int i=0;i<L.MaxSize;i++){
		L.head[i]=rand()%100; 
		L.length++;
	}
}

void display(seqList L){
	for(int i=0;i<L.length;i++){
		printf("%d\n",L.head[i]);
	}
}

int Length(seqList L){
	return L.length;	
}

void ListInsert(seqList &L,int pos,int e){
	if(pos<1||pos>L.length+1){
		printf("插入位置不合理,插入失败"); 
	}
	if(L.length>=L.MaxSize){
		L.head=(int*)realloc(L.head,(L.MaxSize+1)*sizeof(int));
	}
	for(int i=L.length;i>=pos;i--){
			L.head[i]=L.head[i-1];
	}
	L.head[pos-1]=e;
	L.length++;
}

void ListDelete(seqList &L,int pos,int &e){
	if(pos<1||pos>L.length+1){
		printf("删除位置不合理,删除失败"); 
	}
	e=L.head[pos-1];
	for(int i=pos;i<L.length;i++){
		L.head[i-1]=L.head[i];
	}
	L.length--;
}

int LocateElem(seqList L,int e){
	 for(int i=0;i<L.length;i++){
	 	if(L.head[i]==e){
	 		return i+1; 
	 	}
	 }
}

bool Empty(seqList L){
	if(L.length==0){
		return true;
	}
	return false;
}

void DestoryList(seqList &L){
	if(L.head){
		free(L.head);
	} 
}


int GetElem(seqList L,int pos){
	return L.head[pos-1];	
}

线性表的链式表示——链表

单链表

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

实现：
#include<stdio.h>
#include<stdlib.h>

typedef struct LNode{
	int data;
	struct LNode *next;	
}LNode,*LinkList;
 
LinkList HeadInsertLinkList(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode)); 
	int x;
	LNode *s;
	scanf("%d",&x); 
	L->next=NULL;
	while(x!=9999){
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next;
		L->next=s;
		scanf("%d",&x);
	}
	return L;
}

LinkList ToilInsertLinkList(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));
	int x;
	LNode *s,*temp=L;
	scanf("%d",&x);
	L->next=NULL;	
	while(x!=9999){
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		temp->next=s;
		temp=s;
		scanf("%d",&x);
	}
	s->next=NULL; 
	return L;
}

LNode *getElem(LinkList L,int pos){
	LNode *p=L; 
	int j=0;
	if(pos<1){
		return NULL;
	}
	while(p!=NULL&&j<pos){
		p=p->next;
		j++;
	}
	return p;
}

LNode *getElem2(LinkList L,int pos){
	LNode *p=L->next;
	int j=1;
	if(pos<1){
		return NULL;
	}
	if(pos==0){
		return L;
	}
	while(p!=NULL&&j<pos){
		p=p->next;
		j++;
	}
	return p;
}

bool ListInsert(LinkList &L,int pos,int e){
	if(i<1){
		return false;
	}
	LNode *p=getElem(L,i-1);
	if(p==NULL){
		return false;
	}
	LNode *s=(LNode*)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;
}


LNode *LocateElem(LinkList L,int e){
	LNode *p=L->next; 
	while(p!=NULL&&p->data!=e){
		p=p->next;
	}
	return p;
}

int Length(LinkList L){
	int len=0;
	LNode *p=L;
	while(p->next!=NULL){
		p=p->next;
		len++;
	}
	return len;
}

bool InsertLinkListWithHead(LinkList &L,int pos,int e){
	if(pos<1){
		return false;
	}
	LNode *p=L;
	int j=0;
	while(p!=NULL&&j<pos-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 s;
}

bool ListInsertWithoutHead(LinkList &L,int pos,int e){
	if(pos<1){
		return false;
	} 
	if(pos==1){
		LNode *s=(LNode*)malloc(sizeof(LNode));
		s->data=e;
		s->next=L;
		L=s;
		return true;
	}
	LNode *p=L;
	int j=1;
	while(p!=NULL&&j<pos-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;
}

bool InsertNextNode(LNode *p,int e){
	if(p==NULL){
		return false;
	}
	LNode *s=(LNode*)malloc(sizeof(LNode));
	if(s==NULL){
		return false;
	}
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;
} 

bool InsertPriorNode(LNode *p,int e){
	if(p==NULL){
		return false;
	}
	LNode *s=(LNode*)malloc(sizeof(LNode));
	if(s==NULL){
		return false;
	}
	s->next=p->next; 
	p->next=s;
	s->data=p->data;
	p->data=e;
	return true;
}

bool ListDelete(LinkList &L,int pos,int &e){
	if(i<1){
		return false;
	}
	LNode *p=L;
	int j=0;
	while(p!=NULL&j<pos-1){
		p=p->next;
		j++;
	}
	if(p==NULL)
		return false;
	if(p->next=NULL)
		return false;
	LNode *q=p->next;
	e=q->data;
	p->next=q->next;
	free(q);
	return true;
}

bool DeleteNode(LNode *p){   //不考虑删除的结点是最后一个结点的情况 
	if(p==NULL){
		return false;
	}
	LNode *q=p->next;
	p->data=q->data;
	p->next=q->next;
	free(q);
	return true;
}

双链表

实现：
#include<stdio.h>
#include<stdlib.h>

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

//初始化双链表:
bool InitDLinkList(DLinkList &L){
	L=(DNode*)malloc(sizeof(DNode));
	if(L==NULL){
		return false
	}
	L->prior=NULL;
	L->next=NULL;
	return true;
}

//判断双链表是否为空 
bool Empty(DLinkList L){
	if(L->next=NULL){
		return true;
	}
	else
		return false;
}

//双链表的插入:P结点之后插入S结点 
bool InsertNextDNode(DNode *p,DNode *s){
	if(p==NULL||s==NULL){
		return false;
	}
	s->next=p->next;
	if(p->next!NULL)
		p->next->prior=s;
	s->prior=p;
	p->next=s;
} 

//删除P结点的后继结点
bool DeleteNextDNode(DNode *p){
	if(p==NULL)
		return false;
	DNode *q=p->next;
	if(q==NULL)
		return false; 
	p->next=q->next;
	if(q->next!=NULL)
		q->next->prior=p;
	free(q);
	return true;
} 

void DestoryList(DLinkList &L){
	while(L->next!=NULL){
		DeleteNextDNode(L);
	}
	free(L);
	L=NULL; 
}

//往后遍历 
void traversal1(DNode *p){
	while(p!=NULL){
		p=p->next
	}
}

//往前遍历 
void traversal2(DNode *p){
	while(p!=NULL){
		p=p->prior;
	}
}

//往前遍历，跳过头结点 
void traversal3(DNode *p){
	while(p->prior!=NULL){
		p=p->prior;
	}
}

循环链表

循环单链表
实现：
#include<stdio.h>
#include<stdlib.h>

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList; 

bool InitList(LinkList &L){
	L=(LNode*)malloc(sizeof(LNode));
	if(L==NULL){
		return false;
	}
	L->next=L;	
	return true;
} 

bool Empty(LinkList L){
	if(L->next==L){
		return true;
	}
	else
		return false;
}

bool isTail(LinkList L,LNode *p){
	if(p->next==L){
		return true;
	}
	else
		return false;
}
循环双链表
实现：
#include<stdio.h>
#include<stdlib.h>

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

bool InitList(DLinkList &L){
	L=(LNode*)malloc(sizeof(LNode));
	if(L==NULL){
		return false;
	}
	L->prior=L;
	L-next=L;	
}

bool Empty(DLinkList L){
	if(L->next==L){
		return true;
	}
	else
		return false;
}

bool isTail(DLinkList L,DNode *p){
	if(p->next==L){
		return true;
	}
	else
		return false;
}

bool InsertList(DNode *p,DNode *s){
	s->next=p->next;
	p->next->prior=s;
	s->prior=p;
	p->next=s;
	return true;
}

bool DeleteList(DNode *p){
	DNode *q=p->next;
	p->next=q->next;
	p->next->prior=p;
	free(q);
	return true;
}

静态链表

略

呵乌誒
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
考研复习知识笔记-数据结构
04-16
数据结构笔记-考研复习 数据结构是计算机科学中的一门重要学科，研究如何组织、存储和使用数据。下面是考研复习笔记中的一些重要知识点： 1. 数据结构定义：数据结构是指数据元素之间的逻辑关系、数据的运算和存储...
408复习笔记——数据结构（二）：线性表
qq_44161734的博客
06-20 727
408考研笔记系列（二）（PS：本人使用的是王道四本书和王道视频） 数据结构：（二）线性表前言一、简介二、主要内容2.1 顺序表2.2 链表2.2.1 单链表3、常见题及易错题归纳 前言 绪论中介绍了什么是数据结构，并用图书管理系统的例子进行了解释说明，数据结构包括三个部分：逻辑结构、存储结构和数据的运算；今天，我们便开始学习第一个数据结构：线性表。 一、简介 线性表其实是一种逻辑结构，它指的是具有相同数据类型的n个数据元素的有限序列，一般是从1开始的； 线性表从存储结构而言可以分为以顺序存储的顺
408数据结构知识点——第二章 线性表
最新发布
tridoron6的博客
01-17 1009
线性表是算法题命题的重点。这类算法题的实现比较容易且代码量较少，但是要求具有最 优的性能（时间/空间复杂度），才能获得满分。因此，应牢固掌握线性表的各种基本操作（基于两种存储结构），在平时的学习中多注重培养动手能力。另需提醒的是，算法最重要的是思想！考场上的时间紧迫，在试卷上不一定要求代码具有实际的可执行性，因此应尽力表达出算法的思想和步骤，而不必过于拘泥所有细节
408数据结构——线性表
学习积累
11-19 999
线性表 考纲内容 线性表的定义和操作 线性表的实现 要求内容 会线性表及链表的基本操作 多种方法分析设计并比较复杂度，熟悉代码思路 思维导图索引
王道408数据结构——第二章 线性表
weixin_45668903的博客
09-25 1429
文章目录一、线性表的定义和基本操作线性表顺序表1.插入操作2.删除操作3.按值查找（顺序查找）二、单链表1. 头插法2. 尾插法3. 按序号查找4. 按值查找5. 插入结点6. 删除结点7. 求表长三、 双链表1. 插入2. 删除四、循环链表五、静态链表六、顺序表和链表的比较 一、线性表的定义和基本操作 线性表 线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长，n=0是为一个空表。除第一个元素外，每一个元素有且仅有一个直接前驱，除最后一个元素外，每一个元素有且仅有一个直接后驱。 顺序表 线性表
历年408统考数据结构线性表大题破解方法（一）（附C代码
master_hunter的博客
12-20 1553
关于线性表408考的还是挺频繁的，其实总体来说并不难（暴力破解），要是最优算法在考场上那种气氛还是蛮难想到的。本文主要总结在2010年-2020年的408考试中考过的关于线性表大题破解方法以及代码，废话不多说直接上真题： 2010年大题： 算法思路：这是一道很经典的逆置算法题，可以通过数学的思路设前面的X0，X1，...Xp-1为a序列，后面的Xp，Xp+1...Xn-1为b，则我们知道原序列为，通过逆置我们可以得到，随后对整个数列进行逆置。根据这个思路我们可以来构建算法。 代码： int .
408考研— 数据结构概念知识点思维导图—所有章节
06-29
"408考研— 数据结构概念知识点思维导图—所有章节" 数据结构是计算机科学中的一门重要课程，涵盖了数据的存储、表示和操作等方面。它是计算机科学的基础理论之一，对于计算机科学和信息技术专业的学生来说，是必修...
数据结构复习总结心得最终版.pdf
12-28
本复习总结涵盖了数据结构的基础知识，主要针对研究生考研复习，特别是408计算机考研大纲的要求。 首先，第一章绪论讨论了不同类型的存储结构。顺序存储是最简单的形式，元素在内存中连续存放，便于随机访问，但...
考研数据结构代码大全
10-26
【考研数据结构代码大全】是针对计算机专业考研者准备的一份综合性的数据结构代码集合，主要涵盖数据结构的基础部分，包括列表、栈、队列、树、图、查找、字符串和排序等多种数据结构的C语言实现。这些内容是408...
考研计算机复习资料数据结构.pdf
12-08
在考研计算机复习中，数据结构是必不可少的一部分。本篇复习资料主要聚焦于数据结构中的线性表。 首先，理解数据结构的基本概念至关重要。数据结构包括逻辑结构（如线性、树形、图形、集合）、物理（存储）结构以及...
【数据结构复习】408数据结构中线性表大题整理
zhangzm0128
09-13 6565
（两个有序顺序表的中位数）一个长度为L(L≥1)的升序序列S，处在第[L／2]个位置的数称为S的中位数。例如列S1=(11，13，15，17，19)，则S1中的中位数是15。两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若92=(2，4，6，8，20)，则．S1和S2的中位数是11。现有两个等长升序序列A和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A和B的中位数。...
(王道408考研数据结构)第二章线性表-第一节：线性表的定义和基本操作
快乐江湖的博客
11-07 2701
文章目录一：线性表的定义二：线性表的基本操作 一：线性表的定义 线性表(Linear List)：零个或多个数据元素的有限序列 元素之间是有顺序的 若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他元素都有且只有一个前驱和后继 线性表强调有限，“所有的整数按递增次序排列”很明显不是线性表 线性表可以表示为 L=(a1,a1,...,ai+1,...,an)L=(a_{1},a_{1},...,a_{i+1},...,a_{n})L=(a1​,a1​,...,ai+1​,...,an​) a
408-数据结构-线性表、栈、队列（一）
不知道是谁的博客
04-02 409
数据结构复习笔记 基础 时间复杂度 算法中基本运算的频度 f(n) 来分析时间复杂度 Q：什么是 “基本运算”？ A：最坏和最好描述的运算对象 不仅与问题规模有关，还与代输入数据的性质（初始状态）有关，根据不同的初始状态，可将算法时间复杂度分为以下三类： 最好时间复杂度 平均时间复杂度 最坏时间复杂度：一般考虑这种情况 常见复杂度比较： O(1)<O(log2n)<O(n)&l...
408 数据结构复习线性表
dat_stick的博客
03-23 77
顺序表 静态分配 // 顺序表的创建 // 静态分配 数组长度固定 #include<iostream> using namespace std; const int MaxSize = 10; typedef struct { int data[MaxSize]; int length; }SqlList; void InitList(SqlList& L) { for (int i = 0; i < MaxSize; i++) { // 初始化每个元素为0 L.d
408数据结构------2.线性表
阿柠xn
01-03 201
408数据结构------2.线性表存储结构顺序存储结构（顺序表）链式存储结构（链表） 存储结构 顺序存储结构（顺序表） 概念： 在逻辑上相邻的元素在物理上也相邻 特点：1. 随机访问 2. 占用连续的存储空间 3.存储密度高 4. 插入删除不方便 操作： 1. 插入 ：从目标位置开始，将元素向后移动一个位置，空出一个位置 2. 删除：从目标位置开始，将后面的向前移动一个位置 3. 查找：顺序遍历查找 链式存储结构（链表） 单链表 判断是否为空： ...
408统考真题--线性表(2013年)
Inmaturity_7的博客
07-01 924
[2013统考真题] 已知一个整数序列A=(a0,a1,···,an-1),其中0<=ai<n(0<=i<n)。若存在ap1=ap2=···=apm=x且m>n/2(0<=pk<n,1<=k<=m),则称x为A的主元素。例如A=(0,5,5,3,5,7,5,5)，则5为主元素；又如A=(0,5,5,3,5,1,5,7)，则A中没有主元素。假设A中的n个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出A的主元素。若存在主元素，则输出该元素；否则输
计算机考研408如何复习
栗少的博客
10-04 7764
数据结构->操作系统->计组->网络->数据结构 第一遍配套课本和视频，同时把单科书上的选择题做完 第二遍从头刷单科书，看知识点讲解，这时候要把选择题和大题都做，第一次错的第二次还错那就是难点，要注意。最好在9月中旬前结束第二遍。 数据结构 数据结构从9月开始复习算法时间是完全足够的。因为408算法的重点在于线性表，把王道的线性表题目刷完是可以应付考试的。二叉树的算法建议也...
数据结构——线性表408习题解析
欢迎来到小骆的空间
04-03 4925
线性表 线性表定义：线性表是具有相同特性数据元素的有限序列。 线性表的长度=数据元素的个数(n≥0) 线性结构(线性表)的特点： 1．集合中必存在唯一的一个“第一元素”。 2．集合中必存在唯一的一个 “最后元素” 。 3．除最后一个元素之外，均有唯一的后继(后件)。 4．除第一个元素之外，均有唯一的前驱(前件)。 线性表的ADT：访问、插入和删除 顺序表和链表的比较： 顺序表 链表 ...
数据结构线性表考研题
10-18
数据结构中的线性表是一种数据结构，它是由n个数据元素a1,a2,...,an组成的有限序列。线性表的考研题目主要包括对于某个节点进行修改、顺序置换等操作。其中，链表是线性表的一种实现方式，它是由一系列节点组成的，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值