数据结构 第二章 线性表

最新推荐文章于 2024-07-24 15:28:00 发布
最新推荐文章于 2024-07-24 15:28:00 发布
阅读量72 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70463877/article/details/130310839
版权

数据结构 第二章 线性表

1.线性表基础

1.1线性表的定义

线性表是具有相同数据类型的n个数据元素的有限序列

1.2线性表的特点

  • 存在唯一一个开始结点

  • 存在唯一一个终端结点

  • 除第一个结点外，每一个结点都有且只有一个直接前驱

  • 除最后一个结点外，每个结点都有且只有一个直接后继

2.线性表的顺序存储

2.1顺序表的定义与初始化

2.1.1静态分配
//顺序表的实现--静态分配

#include<stdio.h>
#define MaxSize 10   //定义表的最大长度 
typedef struct{
	int data[MaxSize];//用静态的"数组"存放数据元素
	int length; //顺序表的当前长度  
}SqList;        //顺序表的类型定义（静态分配方式） 
void InitList(SqList &L){
	 for(int i=0;i<MaxSize;i++){
	 	L.data[i]=0;  //将所有数据元素设置为默认初始值
		  
	 }
	 L.length=0;
}
int main(){
	SqList L;//声明一个顺序表
	InitList(L);//初始化一个顺序表
	for(int i=0;i<MaxSize;i++){
		printf("data[%d]=%d\n",i,L.data[i]);
	}
	return 0; 
}
2.1.2动态分配
//顺序表的实现——动态分配
#include<stdio.h>
#include<stdlib.h>//malloc、free函数的头文件 
#define InitSize 10 //默认的最大长度
typedef struct{
	int  *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);  //释放原来的内存空间 
	
} 
int main(void){
	SeqList L; //声明一个顺序表
	InitList(L);//初始化顺序表
	IncreaseSize(L,5);
	return 0; 
}

2.2顺序表的特点

  1. 随机访问 ，可以在O(1)时间内找到第i个元素。

  2. 存储密度高，每个节点只存储数据元素

  3. 拓展容量不方便

  4. 插入、删除操作不方便，需要移动大量元素

2.3顺序表的基本操作

2.3.1顺序表的建立
void CreateList(SeqList *L,int n)
{/*建立顺序表并键入多个元素*/
	int i;
	printf("请输入%d个整数：",n);
	for(i=0;i<n;i++)
		scanf("%d",&L->data[i]);
	L->Length=i;
}
2.3.2插入操作
bool ListInsert(SqList &L, int i, int 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--){    //将第i个元素及其之后的元素后移
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=e;  //在位置i处放入e
    L.length++;      //长度加1
    return true;
}
2.3.3删除操作
bool LisDelete(SqList &L, int i, int &e){ // e用引用型参数 
    //判断i的范围是否有效
    if(i<1||i>L.length) 
        return false;

    e = L.data[i-1]    //将被删除的元素赋值给e

    for(int j=L.length; j>=i; j--){    //将第i个后的元素前移
        L.data[j-1]=L.data[j];
    }
    L.length--;      //长度减1
    return true;
}
2.3.4按位查找
#define MaxSize 10            //定义最大长度 
typedef struct{
    ElemType data[MaxSize];  //用静态的“数组”存放数据元素 
    int Length;              //顺序表的当前长度
}SqList;                     //顺序表的类型定义

ElemType GetElem(SqList L, int i){
    // ...判断i的值是否合法
    return L.data[i-1];      //注意是i-1
}
2.3.5按值查找
#define InitSize 10            //定义最大长度 
typedef struct{
    ElemTyp *data;  //用静态的“数组”存放数据元素 
    int Length;              //顺序表的当前长度
}SqList;   

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

3.线性表的链式存储

3.1链表基本概念

  • 结点：数据元素的存储映像。 由数据域和指针域两部分组成

数据域：存储元素数值数据
指针域：存储直接后继结点的存储位置

  • 链表： n 个结点由指针链组成一个链表。它是线性表的链式存储映像，称为线性表的链式存储结构

单链表、双链表、循环链表：

结点只有一个指针域的链表，称为单链表或线性链表
有两个指针域的链表，称为双链表
首尾相接的链表称为循环链表

头指针是指向链表中第一个结点的指针

首元结点是指链表中存储第一个数据元素a1的结点

头结点是在链表的首元结点之前附设的一个结点；数据域内只放空表标志和表长等信息

3.2单链表

3.2.1单链表的定义

定义： 线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素。

typedef struct LNode{//定义单链表结点类型
    ElemType data; //数据域
    struct LNode *next;//指针域
}LNode,；
*LinkList;
head=(LinkList *)malloc(sizeof(LinkList));//动态申请结点空间
3.2.2不带头结点的单链表
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

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

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

//判断单链表是否为空
bool Empty(LinkList L){
    if (L == NULL)
        return true;
    else
        return false;
}
3.2.3带头结点的单链表
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);
    //...
}

//判断单链表是否为空（带头结点）
bool Empty(LinkList L){
    if (L->next == NULL)
        return true;
    else
        return false;
}
3.2.4 单链表的建立

头插法：

void CreateListH(LinkList *head,int n)
{/*头插法建立链表函数*/
	LinkList *s;
	int i;
	printf("请输入%d个整数：",n);
	for(i=0;i<n;i++)
	{	s=(LinkList *)malloc(sizeof(LinkList));//生成新结点
		scanf("%d",&s->data);
		s->next=head->next;//将新结点的指针域存放到头结点的指针域
		head->next=s;
		}
		printf("建立链表操作成功！")
}

在这里插入图片描述

尾插法

void CreateListL(LinkList *head,int n)
{	LinkList *s,*last;
	int i;
	last=head;//last始终指向尾结点，开始时指向头结点
	printf("请输入%d个整数：",n);
	for(i=0;i<n;i++){
		s=(LinkList*)malloc(sizeof(LinkList));//生成新结点
		scanf("%d",&ss->data);
		s->next=NULL;
		last->next=s;
		last=s;
		}
		printf("建立链表成功！")
}

在这里插入图片描述

3.2.5单链表上基本操作的实现
3.2.5.1求单链表长度
int Length(LinkList L){
    int len=0;       //统计表长
    LNode *p = L;
    while(p->next != NULL){
        p = p->next;
        len++;
    }
    return len;
}
3.2.5.2按值查找
LNode * LocateElem(LinkList L, ElemType e)//引入链表和数据
{
    LNode *P = L->next;    //p指向第一个结点
    //从第一个结点开始查找数据域为e的结点
    while(p!=NULL && p->data != e){
        p = p->next;
    }
    return p;           //找到后返回该结点指针，否则返回NULL
}
3.2.5.3按位查找
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;               //返回p指针指向的值
}
3.2.5.4指定结点的后插操作
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

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;
}                         //平均时间复杂度 = O(1)


//有了后插操作，那么在第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个结点（不存数据）

    //循环找到第i-1个结点
    while(p!=NULL && j<i-1){     //如果i>lengh, p最后4鸟会等于NULL
        p = p->next;             //p指向下一个结点
        j++;
    }

    return InsertNextNode(p, e)
}
3.2.5.5指定结点的前插操作
//前插操作：在p结点之前插入元素e，通过更换两结点的数据来实现
bool InsertPriorNode(LNode *p, ElenType 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连到p之后
    s->data = p->data; //将p中元素复制到s
    p->data = e;       //p中元素覆盖为e

    return true；
}  //时间复杂度为O(1)
3.2.5.6按位删除结点
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

bool ListDelete(LinkList &L, int i, ElenType &e){
    if(i<1) return false;

    LNode *p;       //指针p指向当前扫描到的结点 
    int j=0;        //当前p指向的是第几个结点
    p = L;          //L指向头结点，头结点是第0个结点（不存数据）

    //循环找到第i-1个结点
    while(p!=NULL && j<i-1){     //如果i>lengh, p最后会等于NULL
        p = p->next;             //p指向下一个结点
        j++;
    }

    if(p==NULL) 
        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;
}
3.2.5.7指定结点的删除
bool DeleteNode(LNode *p)//通过交换数据域实现
{
    if(p==NULL)
        return false;
    
    LNode *q = p->next;      //令q指向*p的后继结点
    p->data = p->next->data; //让p和后继结点交换数据域
    p->next = q->next;       //将*q结点从链中“断开”
    free(q);
    return true;
} //时间复杂度 = O(1)
3.2.5.8链表的逆置
LNode *Inverse(LNode *L)
{
	LNode *p, *q;
	p = L->next;     //p指针指向第一个结点
	L->next = NULL;  //头结点指向NULL

	while (p != NULL){
		q = p;
		p = p->next;
		q->next = L->next;  //头插法输入到逆置链表
		L->next = q;
	}
	return L;

3.3循环链表

循环链表的操作和单链表基本一致，差别仅在于判别链表中最后一个结点的条件不再是"后继是否为空"（p!=NULL或p->next!=NULL）,而是"后继是否为头结点"（p!=head或p->next!=head）。

3.4双向链表

3.4.1双向链表的定义
struct DuLNode{
    EtypedeflemType   data; //数据域          
    struct DuLNode  *prior; //前驱 
    struct DuLNode  *next;  //后继
}DuLNode, *DuLinkList

在这里插入图片描述

3.4.2双向链表的插入
void DuIns_Elem(DuLinkList *p,DataType x)
{//双向链表的插入结点函数
	DuLinkList *s;
	s=(DulinkList *)malloc(sizeof(DuLinkList));//生成新结点
	s->data=x;
	s->prior=p->prior;
	p->prior->next=s;
	s->next=p;
	p->prior=s;
	}
3.4.3双向链表的删除
void DuDel_Elem(DuLinkList *p,DataType *x)
{//双向链表删除结点的函数
	*x=p->data;
	p->prior->next=p->next;
	p->next->prior=p->prior;
	free(p);
	}
3.4.4双链表的遍历操作
while(p!=NULL){
    //对结点p做相应处理，eg打印
    p = p->prior;//向前遍历，p指向next为向后遍历
}
3.4.5循环双链表

表头结点的prior指向表尾结点，表尾结点的next指向头结点

typedef struct DNode{          
    ElemType data;               
    struct DNode *prior, *next;  
}DNode, *DLinklist;

//初始化空的循环双链表
bool InitDLinkList(DLinklist &L){
    L = (DNode *) malloc(sizeof(DNode));    //分配一个头结点
    if(L==NULL)            //内存不足，分配失败
        return false;  
    L->prior = L;          //头结点的prior指向头结点
    L->next = L;           //头结点的next指向头结点
}

void testDLinkList(){
    //初始化循环单链表
    DLinklist L;
    InitDLinkList(L);
    //...
}

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

//判断结点p是否为循环双链表的表尾结点
bool isTail(DLinklist L, DNode *p){
    if(p->next == L)
        return true;
    else
        return false;
}

3.4静态链表

3.4.1定义

静态链表：用数组的方式来描述线性表的链式存储结构: 分配一整片连续的内存空间，各个结点集中安置，包括了——数据元素and下一个结点的数组下标(游标)

3.4.2 代码实现
#define MaxSize 10        //静态链表的最大长度

typedef struct{           //静态链表结构类型的定义
    ELemType data;        //存储数据元素
    int next;             //下一个元素的数组下标
}SLinkList[MaxSize];

void testSLinkList(){
    SLinkList a;
}

4.顺序表和链表的比较

在这里插入图片描述

好像是脆脆鲨
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
广工anyview数据结构第2章
戮漠
01-04 4344
第二章 PE03 /********** 【题目】试写一算法，实现顺序栈的判空操作 StackEmpty_Sq(SqStack S)。 顺序栈的类型定义为： typedef struct { ElemType *elem; // 存储空间的基址 int top; // 栈顶元素的下一个位置，简称栈顶位标 int size; // 当前分配的存储容量 int increme...
广东工业大学 数据结构 anyview 作业系统 第二章答案
11-18
广东工业大学 数据结构 anyview 作业系统 第二章答案
广工anyview数据结构第二章(2021.12)
热门推荐
凛_Lin~~的博客
01-20 1万+
广工anyview数据结构第二章 （2021.12）
广工 AnyviewC 数据结构习题 第二章
雁过留痕的博客
12-28 9612
广工 AnyviewC 数据结构习题 第二章广工 AnyviewC 数据结构习题 第一章Anyview 数据结构 第二章1【题目】试写一算法，实现顺序栈的判空操作2【题目】试写一算法，实现顺序栈的取栈顶元素操作3【题目】试写一算法，实现顺序栈的出栈操作4 【题目】若顺序栈的类型重新定义如下。试编写算法，5【题目】若顺序栈的类型重新定义如下。试编写算法，6【题目】若顺序栈的类型重新定义如下。试编写算...
数据结构第二章线性表总结
m0_50236851的博客
04-20 938
/*2.1线性表的定义和基本操作 InitList(&L);初始化表。 DestroyList(&L);销毁操作 LisInsert(&L,i,e);插入操作 LocateElem(L,e);按值查找 GetElem(L,i);按位查找 */ //2.2顺序表 // //2.21 //1 #define MaxSize 10 typedef struct { ElemType data[MaxSize]; int length; }SqList;//静态分配方式 void
数据结构第二章 线性表
bshsjjasb的博客
07-09 988
一些笔记，只有部分操作的代码
数据结构第二章线性表
weixin_51884452的博客
11-12 321
顺序表和单链表的
数据结构 第二章线性表
XINYUNSHU的博客
07-06 132
数据结构
数据结构第二章线性表c++代码
07-14
本压缩包包含的数据结构第二章线性表的C++代码，重点展示了数据结构中的几个基本概念，如静态顺序表、动态顺序表、单链表和双链表。这些数据结构在实际编程中有着广泛的应用，例如在操作系统、数据库系统、编译器...
专升本数据结构第二章 线性表.pdf
01-14
线性表是数据结构的基础部分，它是一种特殊的数据组织形式，由n（n>=0）个相同类型的数据元素构成的有限序列。线性表的每个元素都有一个直接前驱和直接后继，除了首元素（没有前驱）和尾元素（没有后继）。这种结构...
数据结构第二章线性表.pdf
09-30
数据结构第二章线性表.pdf 本章主要介绍了线性表的逻辑结构、顺序存储结构和链式存储结构，并对顺序表和链表进行了比较。学习目的要求学生能够熟悉线性表的逻辑结构和各种存储表示方法，以及定义在逻辑结构上的各种...
数据结构第二章线性表习题.doc
09-24
数据结构第二章线性表习题 本节习题涵盖了数据结构第二章线性表的主要知识点，包括线性表的定义、顺序表和链表的存储结构、插入、删除、查找等基本操作的时间复杂度分析，以及栈的实现和应用。 1. 线性表是有限...
数据结构 第二章 线性表 思维导图
qq_44692304的博客
12-08 1132
@数据结构 思维导图 第一章 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新...
c语言（7.23）
fhgfyrsg的博客
07-23 593
【代码】c语言（7.23）
【算法与数据结构】并查集
2301_79728896的博客
07-23 345
合并和查询集合的数据结构，KruskalLCA查询的时间复杂度：小于O(log2​n)近乎O(1)
Linux嵌入式学习——数据结构——线性表的链式结构
最新发布
m0_71703182的博客
07-24 768
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值