数据结构 第二章 线性表

最新推荐文章于 2024-07-12 14:40:17 发布
最新推荐文章于 2024-07-12 14:40:17 发布
阅读量69 收藏
点赞数 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 9602
广工 AnyviewC 数据结构习题 第二章广工 AnyviewC 数据结构习题 第一章Anyview 数据结构 第二章1【题目】试写一算法，实现顺序栈的判空操作2【题目】试写一算法，实现顺序栈的取栈顶元素操作3【题目】试写一算法，实现顺序栈的出栈操作4 【题目】若顺序栈的类型重新定义如下。试编写算法，5【题目】若顺序栈的类型重新定义如下。试编写算法，6【题目】若顺序栈的类型重新定义如下。试编写算...
数据结构第二章线性表总结
m0_50236851的博客
04-20 929
/*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 981
一些笔记，只有部分操作的代码
数据结构第二章线性表
weixin_51884452的博客
11-12 317
顺序表和单链表的
数据结构 第二章线性表
XINYUNSHU的博客
07-06 130
数据结构
数据结构第二章线性表c++代码
07-14
本压缩包包含的数据结构第二章线性表的C++代码，重点展示了数据结构中的几个基本概念，如静态顺序表、动态顺序表、单链表和双链表。这些数据结构在实际编程中有着广泛的应用，例如在操作系统、数据库系统、编译器...
专升本数据结构第二章 线性表.pdf
01-14
线性表是数据结构的基础部分，它是一种特殊的数据组织形式，由n（n>=0）个相同类型的数据元素构成的有限序列。线性表的每个元素都有一个直接前驱和直接后继，除了首元素（没有前驱）和尾元素（没有后继）。这种结构...
数据结构第二章线性表.pdf
09-30
数据结构第二章线性表.pdf 本章主要介绍了线性表的逻辑结构、顺序存储结构和链式存储结构，并对顺序表和链表进行了比较。学习目的要求学生能够熟悉线性表的逻辑结构和各种存储表示方法，以及定义在逻辑结构上的各种...
数据结构第二章线性表习题.doc
09-24
数据结构第二章线性表习题 本节习题涵盖了数据结构第二章线性表的主要知识点，包括线性表的定义、顺序表和链表的存储结构、插入、删除、查找等基本操作的时间复杂度分析，以及栈的实现和应用。 1. 线性表是有限...
数据结构 第二章 线性表 思维导图
qq_44692304的博客
12-08 1128
@数据结构 思维导图 第一章 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新...
数据结构【顺序表】
qq_67578580的博客
07-12 959
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 651
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
数据结构之单链表在不带标准头的情况下C，C#，C++分别怎么实现？
最新发布
qq_35320456的博客
07-12 274
数据结构是计算机科学中非常重要的一部分，它帮助我们理解和操作数据。单链表是数据结构中的一种基本类型，它由一系列节点组成，每个节点包含数据域和指向列表中下一个节点的指针。在本文中，我们将详细讨论单链表的概念、操作和如何在几种常见的编程语言中实现它。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值