408计算机考研--数据结构--线性表学习(C语言)

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

线性表的学习

1.线性表的顺序表示–顺序表

1.1、顺序表的定义–静态分配
#include <stdio.h>
#define MaxSize 10 //定义最大长度 

typedef struct{
	int data[MaxSize];//用数组存储数据元素 
	int length;//顺序表的当前长度 
}SeqList;//顺序表的类型定义 


//基本操作--初始化一个顺序表
void InitList(SeqList &L){
	for(int i=0;i<MaxSize;i++){
		L.data[i]=0;//将所有的数据元素设置为默认初始值 
	}
	L.length=0;//顺序表的初始长度为0 
} 
int main(){
	SeqList L;//声明一个顺序表
	InitList(L);//初始化顺序表
	return 0; 
}
1.2、顺序表的定义–动态分配
#include <stdio.h>
#include <stdlib.h>
#define InitSize 100 //表长度的初始定义长度 

typedef struct{
	int *data;//指示动态分配数组的指针 
	int MaxSize,length;//数组的最大容量和当前个数 
}SeqList;//顺序表的类型定义 


//基本操作--初始化一个顺序表
void InitList(SeqList &L){
	L.data=(int *)malloc(sizeof(int)* InitSize);
	L.length=0;//顺序表的初始长度为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); 
}
int main(){
	SeqList L;//声明一个顺序表
	InitList(L);//初始化顺序表
	//测试数据 
	L.data[0]=1;
	L.data[1]=2;
	L.data[2]=3;
	L.length=3;
	//测试打印 
	printf("1:%d,2:%d,3:%d\n",L.data[0],L.data[1],L.data[2]);
	//测试扩容 
	IncreaseSize(L,5);
	//测试扩容后打印 
	printf("1:%d,2:%d,3:%d",L.data[0],L.data[1],L.data[2]);
	return 0; 
}
1.3、顺序表静态分配的插入、删除、按位查找和按值查找
#include <stdio.h>
#define MaxSize 10 //定义最大长度 

typedef struct{
	int data[MaxSize];//用数组存储数据元素 
	int length;//顺序表的当前长度 
}SeqList;//顺序表的类型定义 


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

//基本操作--在顺序表L的位序i处插入元素e
bool ListInsert(SeqList &L,int i,int 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--){//将第i个元素之后的元素后移 
		L.data[j]=L.data[j-1];
	}
	L.data[i-1]=e;//在位置i处放入e 
	L.length++;//长度加1 
	return true;
} 
bool ListDelete(SeqList &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++){
		L.data[j-1]=L.data[j];
	} 
	L.length--;
	return true;
	
}
//按位查找
int GetElem(SeqList L,int i){
	if(i<1||i>L.length){//判断查找位是否有效 
		return false;
	}
	return L.data[i-1];
} 
//按值查找 
int LocateElem(SeqList L,int e){
	if(L.length<=0){
		printf("查找的顺序表为空！");
		return -1;
	}
	for(int j=0;j<L.length;j++){
		if(L.data[j]==e){
			return j+1;
		}
	}
	return -1;
} 
//打印链表中的数据 
void PrintList(SeqList L){
	for(int i=0;i<L.length;i++){
		printf("%d:%d ",i,L.data[i]);
	}
	printf("\n");
}
int main(){
	SeqList L;//声明一个顺序表
	InitList(L);//初始化顺序表
	//测试数据 
	L.data[0]=1;
	L.data[1]=2;
	L.data[2]=3;
	L.data[3]=4;
	L.data[4]=5;
	L.data[5]=6;
	L.length=6;
	PrintList(L);//测试打印 
	//测试插入
	ListInsert(L,3,3);
	PrintList(L);//测试打印 
	//测试删除
	int e=0;
	ListDelete(L,3,e);
	PrintList(L);//测试打印 
	
	printf("查找第五个元素：%d\n",GetElem(L,5)); 
	printf("查找元素6所在的位置：%d\n",LocateElem(L,6)); 
	printf("查找元素7所在的位置素：%d\n",LocateElem(L,7)); 
	return 0; 
}

2.线性表的链式表示–链表

2.1、单链表的定义及基本操作
#include<stdio.h>
#include<stdlib.h>

typedef struct LNode{//定义单链表结点类型 
	int data;//数据域 
	struct LNode *next;//指针域 
}LNode,*LinkList;

//头插法建立单链表
LinkList List_HeadInsert(LinkList &L){//逆向建立单链表 
	LNode *s;int x;
	L=(LinkList)malloc(sizeof(LNode));//创建头结点
	L->next=NULL;//初始为空链表
	scanf("%d",&x);//输入结点的值
	while(x!=9999){//输入9999表示结束
		s=(LNode*)malloc(sizeof(LNode));//创建新结点
		s->data=x;
		s->next=L->next;
		L->next=s;//将新结点插入表中，L为头指针 
		scanf("%d",&x);
	} 
} 

//尾插法建立单链表
LinkList List_TailInsert(LinkList &L){
	LNode *s;int x;
	LNode *cur;
	L=(LinkList)malloc(sizeof(LNode));//创建头结点
	L->next=NULL;//初始化头结点
	cur=L;//记录当前指针位置，从头结点开始 
	scanf("%d",&x);//输入值
	while(x!=9999){//当输入x为9999时结束创建链表
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		
		cur->next=s;
		cur=s; 
		scanf("%d",&x);
	} 
	cur->next=NULL;//尾指针置为NULL 
	return L;
	 
} 
//打印链表的方法
void Print_LinkList(LinkList L){
	if(L->next==NULL){
		printf("空链表！！！");
		return;
	}
	LinkList temp=L->next;
	while(temp!=NULL){
		printf("%d->",temp->data);
		temp=temp->next;
	}
	printf("\n");
	return;
}
//按序号查找结点值 
LinkList  GetElem(LinkList &L,int i){
	LNode* temp=L->next;
	if(temp==NULL){
		printf("空链表！！！");
		return temp;
	}
	if(i<1){
		printf("位置i无效！！！");
		return NULL;
	}
	while(temp!=NULL&&i-1>0){
		temp=temp->next;
		i--;
	}
	return temp;
}
//按值查找结点值
LinkList  LocateElem(LinkList &L,int e){
	LNode* temp=L->next;
	if(temp==NULL){
		printf("空链表！！！");
		return temp;
	}
	while(temp!=NULL&&temp->data!=e){
		temp=temp->next;
	}
	return temp;
}
//插入结点操作（后插法） 
bool List_RearInsert(LinkList &L,int i,LinkList &e){
	LinkList L1;//查找位置的结点 
	L1=GetElem(L,i-1);
	if(L1!=NULL){
		e->next=L1->next;
		L1->next=e;
		return true;
	} else{
		return false;
	}
}
bool List_NodeDelete(LinkList &L,int i){
	LinkList temp,LElem;//临时变量 
	if(L->next==NULL){//空链表不操作
	 	printf("空链表！！！");
		return   false;
	}
	if(i==1){//删除头结点需要特殊处理 
		if(L->next->next==NULL){
			L->next=NULL;
		}else{
			temp=L->next;
			L->next=temp->next;
			free(temp); 
		}
		return true;
	}
	//删除头结点后的结点 
	LElem=GetElem(L,i-1);
	if(LElem!=NULL){
		temp=LElem->next;
		LElem->next=temp->next;
		free(temp); 
		return true;
	} else{
		return false;
	}
}
int main(){
//	头插法测试 
//	LNode *L1;
//	List_HeadInsert(L1);
//	Print_LinkList(L1);

//	尾插法测试 	
	LNode *L2;
	LNode *item1,*item2;
	List_TailInsert(L2);
	Print_LinkList(L2);
	
	//查询测试 
//	item1=GetElem(L2,3);
//	printf("按次序查找到的值：%d\n",item1->data);
//	item2=LocateElem(L2,4);
//	printf("按值查找到的值：%d\n",item2->data);

	
	//插入测试 
//	LinkList e=(LinkList)malloc(sizeof(LNode));
//	e->data=999;
//	List_RearInsert(L2,3,e);
//	Print_LinkList(L2);
	
	//删除测试
	List_NodeDelete(L2,7);
	Print_LinkList(L2);
}
2.2、双链表的定义及基本操作
#include<stdio.h>
#include<stdlib.h>

typedef struct DNode{
	int data;//数据域
	struct DNode *prior,*next;//前后指针 
}DNode,*DLinkList; 

//双链表初始化 
void Init_DLinkList(DLinkList &L){
	L=(DLinkList)malloc(sizeof(DNode));//分配头结点地址
	L->next=NULL;
	L->prior=NULL;
	return;
} 
//尾插法创建链表 
DLinkList DList_HeadInsert(DLinkList &L){
	DLinkList temp,LN;//临时变量、每个新结点变量 
	temp=L;
	int x;//新结点数据变量 
	scanf("%d",&x);
	while(x!=9999){
		LN=(DLinkList)malloc(sizeof(DNode));
		LN->data=x;
		LN->next=NULL;
		LN->prior=temp;
		temp->next=LN;
		temp=LN;
		scanf("%d",&x);
	}
	return L;
}
//打印链表的方法
void Print_LinkList(DLinkList L){
	if(L->next==NULL){
		printf("空链表！！！");
		return;
	}
	DLinkList temp=L->next;
	while(temp!=NULL){
		printf("%d->",temp->data);
		temp=temp->next;
	}
	printf("\n");
	return;
}
//获取双链表位序i的结点 
DLinkList GetElem(DLinkList &L,int i){
	if(L->next==NULL||i<1){//排除空表和i输入不可能的情况 
		return NULL;
	}
	DLinkList temp=L->next;//获取当前链表 
	while(temp!=NULL&&i-1>0){
		temp=temp->next;
		i--;
	}
	return temp;
} 
//插入结点操作
bool Node_Insert(DLinkList &L,int i,DLinkList &e){
	if(L->next==NULL||i<1){//排除空表和i输入不可能的情况 
		return false;
	}
	DLinkList elem=GetElem(L,i);//获取查找到的结点
	if(elem!=NULL){
		//查询到该结点后在该结点之前插入e结点 
		elem->prior->next=e;
		e->prior=elem->prior;
		e->next=elem;
		elem->prior=e;
		return true;
	}else{
		return false;
	}
} 

//删除结点操作
bool Node_Delete(DLinkList &L,int i){
	if(L->next==NULL||i<1){//排除空表和i输入不可能的情况 
		return false;
	}
	DLinkList elem=GetElem(L,i);//获取查找到的结点
	if(elem!=NULL){
		//查询到该结点后删除 
		if(elem->next!=NULL){
			elem->prior->next=elem->next;
			elem->next->prior=elem->prior;
		}else{
			elem->prior->next=NULL;
		}
		free(elem);
		return true;
	}else{
		return false;
	}
}

 
int main(){
	//定义双链表L1,e为插入的变量 
	DLinkList L1,e;
	//初始化 
	Init_DLinkList(L1);
	Init_DLinkList(e);
	e->data=0; 
	DList_HeadInsert(L1);
	Print_LinkList(L1); 
	
	//测试插入结点 
//	Node_Insert(L1,3,e);
//	Print_LinkList(L1); 
	
	//测试删除结点 
	Node_Delete(L1,3);
	Print_LinkList(L1);
	Node_Delete(L1,7);
	Print_LinkList(L1);
	
}

循环单链表、循环双链表只是在处理头结点指向和尾节点指向时有些不同，需要将首尾相连，但是操作大体一致

2.3、静态链表的定义
#include<stdio.h>
#include<stdlib.h>

#define MaxSize 50 //静态链表的最大长度
typedef struct StaticList{//静态链表结构类型的定义
	int data;//存储数据元素，可以是其它类型数据
	int next;//下一个元素的数组下标
}StaticList;

int main(){
	//定义静态链表
    StaticList a[MaxSize];
}

3.顺序表和链表的比较

3.1、存取（读写）方式

​ 顺序表可以顺序存取，也可以随即存取，链表只能从表头顺序存取元素。例如在第i个位置上执行存或取的操作，顺序表仅需一次访问，而链表则需要从表头开始依次访问i次。

3.2、逻辑结构与物理结构

​ 采取顺序存储时，逻辑上相邻的元素，对应的物理存储位置也是相邻的。而采取链式存储时，逻辑上相邻的元素，物理存储位置不一定相邻，对应的逻辑关系时通过指针来表示的。

3.3、查找、插入和删除操作

​ 对于按值查找，顺序表无序时，两者的事件复杂度均为O(n)；顺序表有序时，可采用折半查找，此时的时间复杂度为O(log2n)。

​ 对于按序号查找，顺序表支持随机访问，时间复杂度仅为O(1)，而链表的平均复杂度为O(n)。顺序表的插入、删除操作，平均需要移动半个表长的元素。链表的插入、删除操作，只需要修改相关结点的指针即可。由于链表的每个结点都带有指针域，故而存储密度不够大。

3.4、空间分配

​ 顺序存储在静态存储分配的情况下，一旦存储空间装满就不能扩充，若再加入新元素，则会出现内存溢出，因此需要预先分配足够大的存储空间。预先分配过大，可能会导致顺序表后部大量闲置；预先分配过小，又会造成内存溢出。动态存储分配虽然存储空间可以扩充，但需要移动大量的元素，导致操作效率低，而且若内存中没有更大块的连续存储空间，则会导致分配失败。链式存储的结点空间只在需要时申请分配，只要内存有空间就可以分配，操作灵活、高效。

Immature_7
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
王道考研数据结构顺序表代码
05-15
自己写的王道考研数据结构顺序表例题和习题代码，所有函数运行都没问题。
408计算机考研--数据结构--栈学习（C语言）
Inmaturity_7的博客
07-02 693
栈学习（C语言） 一、栈的基本概念 ​ 栈（Stack）是只允许在一端进行插入或删除操作的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（top）:线性表允许进行插入和删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 二、栈的顺序存储结构 #include<stdio.h> #include<stdlib.h> #define MaxSize 10 //定义栈中元素的最大个数 typed
PTA 6-17 加头链表的插入和删除
最新发布
LgdCjp的博客
05-18 279
其中ins完成在链表h中将元素x插入到表中，del完成在甸表h中完成删除元素x的操作。
408计算机考研--数据结构--2016年统考真题（C语言）
Inmaturity_7的博客
07-16 2405
标题408数据结构–2016年统考真题（C语言） 一、题目描述 已知由n(n>=2)个正整数构成的集合A={ak|0<=k<n},将其划分为两个不相交的子集A1和A2,元素个数分别是n1和n2，A1和A2中的元素之和分别为S1和S2。设计一个尽可能高效的划分算法，满足|n1-n2|最小且|S1-S2|最大。要求： 给出算法的基本设计思想。 根据设计思想，采用C或C++语言描述算法，关键之处给出注释 说明你所设计的算法的平均时间复杂度和空间复杂度。 二、解决思路 1. 暴力法–排序 直接
408计算机考研--数据结构--二叉树学习（C语言）
Inmaturity_7的博客
07-08 285
二叉树学习 一、二叉树的前中后序递归遍历及应用（求树深度） #include<stdio.h> #inlcude<stdlib.h> typedef struct BiTNode{ int data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; //先序遍历 void PreOrder(BiTree T){ if(T!=NULL){ visit(T);//访问根节点 PreOrder(T.lchild);//
408计算机考研--数据结构--图的学习（C语言)
Inmaturity_7的博客
07-15 788
图的学习 一、图的存储及BFS、DFS算法 1.1、邻接矩阵法 特点： 无向图的邻接矩阵一定是一个对称矩阵（并且唯一）。因此，在实际存储邻接矩阵时只需存储上（或下）三角矩阵的元素。 对于无向图，邻接矩阵的第i行（或第i列）非零元素（或非∞元素）的个数正好是顶点i的度TD(vi)。 对于有向图，邻接矩阵的第i行非零元素（或非∞元素）的个数正好是顶点i的出度OD(vi)；第i列非零元素（或非∞元素）正好是顶点i的入度ID(vi)。 用邻接矩阵存储图，很容易确定图中任意两个顶点之间是否有边相连。但是，要确定图中
线性表顺序存储（C语言实现）每行都有注释-----考研数据结构必备
07-15
本资源是针对考研数据结构学习者提供的一种线性表顺序存储的C语言实现，且每行代码都有详细的注释，对于理解和掌握相关知识点非常有帮助。 顺序存储是指将线性表的元素在内存中按照它们的逻辑顺序依次存储，通常...
考研专业课-数据结构-思维导图
12-30
 “数据结构”是计算机、软件工程等计算机类专业考研时，最经常考的科目之一，也是很多同学头疼的科目。数据结构往往令很多考生望而生畏的，这其实也不能全部责怪考生，究其根本原因是，数据结构是一门很特殊的课程...
中国地质大学(武汉)考研大纲-830计算机软件综合.doc
12-21
本大纲涵盖了计算机软件综合知识点，包括C语言程序设计、数据结构、算法设计等方面的内容。通过学习和掌握这些知识点，考生可以具备基本的计算机科学与技术知识和技能，从事软件开发、数据分析、算法设计等工作。 ...
2025计算机考研408-启航入门导学
01-16
总的来说，2025计算机考研408的启航入门导学是帮助考生建立基础，理解考试大纲，熟悉考试形式的重要学习资源。卞振海主讲的课程可能会详细讲解各个科目的基础知识，解析历年真题，提供备考策略，帮助考生顺利通过这...
广工11-19年数据结构与C语言（831）考研试卷与题目解析.zip
06-15
《广东工业大学数据结构与C语言考研历年真题详解》 广东工业大学作为国内知名的理工科高校，在计算机科学领域有着深厚的学术底蕴。对于准备考取该校数据结构与C语言831科目的研究生而言，掌握历年真题是至关重要的...
408之一------数据结构（C语言版）(一)
m0_55753482的博客
09-02 609
数据结构
考研数据结构：C语言代码实现之线性表（单链表）
weixin_42678370的博客
04-06 345
头文件及结构体类型定义 #include<stdio.h> #include<stdlib.h> typedef struct LNode{ int data;//数据域 struct LNode *next;//指针域 }LNode,*LinkList;//头指针与头节点，头指针指向一个LNode类型的节点。 头插法创建链表 LinkList hea...
【考研408数据结构】数据类型（一）
qq_38841848的博客
01-01 1089
数据类型 对于基本数据类型来说，如整型int、long、。。。（面试中所涉及到的题目，如果没有特殊要求，int类型足够了），同理，字符型char，浮点型float，此处不做赘述，本文主要说的是结构型和指针型。 结构型 结构型可以理解为用户用已有的数据类型（int、char、float）为原料制作的数据类型。（我将其理解为Java中的类）。其实，数组也可以理解为一个结构型，不过数组是多个相同数据类型...
挑战408——数据结构（16）——树的概念
redAnt的博客
11-01 535
从这一篇开始，进入一种新的数据结构，称为树。其实在学习树之前我们就接触过这个结构。 树的概念 现在我们从一幅图中来了解一下什么是树状结构： 这幅图主要说明cart这个单词的所有可能的组合结构，按照常理，我们先考虑三个字母的排列，然后由三个字母的排列中再进行拆分，最后重复拆分直到仅有一个字母。这个套路是不是很像我们之前学过的devide —— conquer算法？对的，这是一个递归的过程，也是计算...
C语言/数据结构-顺序表的实现
DreamGui的博客
11-07 919
3. 线性表-顺序表 线性表的定义 零个或者多个数据源函数的有限序列. 一个元素节点中,它前面的叫前驱,后面的叫后继. 我们的顺序表需要实现以下几个函数功能 // 初始化一个线性表 ElemType initializeList(SqList *L); // 清空一个线性表 ElemType ClearList(SqList *L); // 判断一个线性表是否为空 ElemType IsEmpty(SqList *L); // 查找一个元素,有则返回下标,没有则返回 0 ElemT.
Python实用编程技巧
铁马冰河入梦来
10-20 135
1.列表筛选 data = [-1, 2, 3, -4, 5] data2 = [ x for x in data if x>0]#列表生成式+条件判断 print(data2) data3 = filter(lambda x:x>0,data)#filter函数 print(data3) 2.字典筛选 dict1 = {"book%s"%i:randint(50,100) ...
数据结构 ，第一章，绪论
wofengyun的专栏
09-18 1334
一、基本概念和术语 l       数据(Data)：是指所有能输入到计算机中并被计算机程序处理的符号的总称。是计算机加工的“原料”。 l       数据元素(Data Element):是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。有些情况下，数据元素也称为元素、结点、顶点、记录。有时数据元素可以由若干数据项（也称为字段、域、属性）组成，数据项是数据的有独立含义的最小
C语言企业常问面试题
m0_45463480的博客
05-26 6037
C语言面试题大全 ------------------------C语言试题1START------------------- 一、选择题 二、填空题 三、简答题 四、编程 ------------------------C语言试题1END----------------------- ------------------------C语言试题2START-------------------- 一、选择题 二、填空题 三、简答题 四、编程 ------------------------C语言试题2END
谭浩强C语言数据结构(“关键字”文档)共94张.pptx
11-15
谭浩强C语言数据结构(“关键字”文档)共94张.pptx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值