数据结构（考研）第二章 线性表

已于 2022-05-06 16:03:37 修改
阅读量379 收藏 2
点赞数 2
分类专栏： 计算机考研 文章标签： 数据结构 c语言 算法
于 2022-05-06 15:35:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bestkasscn/article/details/124611590
版权

第二章 线性表

2.1 线性表的定义和基本操作

2.1.1 线性表的定义

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

其中，线性表的第一个元素称为表头元素，最后一个元素称为表尾元素，除了第一个元素外，线性表中每一个元素都有直接后继，除了最后一个元素外，线性表中每一个元素都有直接前驱。

image-20220506155201493

2.1.2 线性表的基本操作

InitList(&L):初始化表。构造一个空的线性表。

DestroyList(&L):销毁操作。销毁线性表，并释放线性表L所占用的内存空间。

LocateElem(L,e):按值查找操作。在表中L查找具有给定关键字值的元素。

GetELem(L):按位查找操作。获取表L中第i个位置的元素的值。

Listlnsert(&L,i,e):插入操作。在表L中的第i个位置上插入指定元素e.

LlstDelete(&L,i,&e):删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。

PrintList(L):输出操作。按前后顺序输出线性表L的所有元素值。
Empty(L):判空操作。若l为空表，则返回TRUE,否则返回FALSE。

Length(L):求表长。返回线性表L的长度，即L中数据元素的个数。

2.2 线性表的顺序表示

顺序表的实现–静态分配

#define MaxSize 10
typedef struct{
    ElemType 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);
}

顺序表的实现–动态分配

#define InitSize 10//顺序表的初始长度
#define <stdlib.h>
typedef struct{
    ElemType *data;//指示动态分配数组的指针
    int MaxSize;
    int length;
}SeqList;
void InitList(SeqList &L){//初始化
    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;
    free(p);
}

顺序表的实现–插入操作

bool listInsert(SeqList &L, int i, ElemType e) {
    if (i < 1 || i > L.maxSize + 1) {
        return false;
    }
    if (L.length >= MaxSize) {
        return false;
    }
    //将第i个元素及之后的元素右移
    for (int j = L.length; j >= i; j--) {
        L.data[j] = L.data[j - 1];
    }
    L.data[i - 1] = e;
    L.length++;
    return true;
}

顺序表的实现–删除操作

bool listDelete(SeqList &L,int i,ElemType &e){
    if (i<1 || i>=L.length + 1) return false;
    if(L.length >= L.maxSize) return false;
    e = L.data[i-1];
    for (int j = i; j < L.length; ++j) {
        L.data[j-1] = L.data[j];
    }
    L.length--;
    return true;
}

顺序表的实现–尾插法

void listInsert(SeqList &L, ElemType e) {
    L.data[L.length] = e;
    L.length++;
}

顺序表的实现–按值查找操作

ElemType LocateElem(SeqList L,ElemType e){
    for (int i = 0; i < L.length; ++i) {
        if (L.data[i] == e){
            return i+1;
        }
    }
    return -1;
}

main函数

int main() {
    initList(L);
    listInsert(L, 0);
    listInsert(L, 1);
    listInsert(L, 2);
    listInsert(L, 3);
    listInsert(L, 4);
//    int p;
//    bool flag = listDelete(L,2,p);
//    std::cout<< flag << std::endl;
    printf("%d",LocateElem(L,3));
    for (int i = 0; i < L.length; ++i) {
        printf("%d\n", L.data[i]);
    }
    return 0;
}

特点：

  • 随机访问
  • 存储密度高
  • 拓展容量不方便
  • 插入删除元素不方便

2.3 线性表的链式表示

2.3.1 单链表的定义

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

2.3.1 单链表的实现

定义头文件

#ifndef DATASTRUCTURE_SINGLELINKEDLIST_H
#define DATASTRUCTURE_SINGLELINKEDLIST_H
#define ElemType int
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkedList;
#endif //DATASTRUCTURE_SINGLELINKEDLIST_H

单链表的实现–初始化

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

单链表的实现–头插法

LinkedList List_HeadInsert(LinkedList &L){
    LNode *s;int x;
    L = (LinkedList)malloc(sizeof(LNode));//创建头结点
    L->next = nullptr;
    scanf("%d",&x);
    while (x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        scanf("%d",&x);
    }
    return L;
}

单链表的实现–尾插法

LinkedList List_TailInsert(LinkedList &L){
    int x;
    LNode *s, *r = L;
    L = (LinkedList)malloc(sizeof(LNode));//创建头结点
    s = (LNode *)malloc(sizeof(LNode));
    scanf("%d",&x);
    while (x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        scanf("%d",&x);
    }
    r->next = nullptr;
    return L;
}

Note:使用LinkList强调这是一个单链表，使用LNode * 强调这是一个结点

单链表的实现–按位序插入

bool ListInsert(LinkedList &L,int i,ElemType e){
    if (i<1) return false;
    LNode *p;
    int j = 0;//当前p指向的是第几个结点
    p = L;
    while (p!= nullptr && j < i-1){
        p = p->next;
        j++;
    }
    if (p== nullptr)return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

单链表的实现–指定结点的前插操作

bool InsertPriorNode(LNode *p,LNode *s){
    if (p == nullptr || s == nullptr)return false;
    s->next = p->next;
    p->next = s;
    ElemType temp = p->data;
    p->data = s->data;
    s->data = temp;
    return true;
}

单链表的实现–指定结点的后插操作

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

单链表的实现–按位序删除

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

单链表的实现–指定结点删除

bool DeleteNode(LNode *p){
    if (p== nullptr)return false;
    LNode *q = p->next;
    p->data = p->next->data;
    p->next = q->next;
    free(q);
    return true;
}

单链表的实现–按位查找

LNode * GetElem(LinkedList L,int i){
    int j = 1;
    LNode *p = L->next;
    if (i == 0)return  L;
    if (i < 1) return nullptr;
    while (p!= nullptr && j<i){
        p = p->next;
        j++;
    }
    return p;
}

单链表的实现–按值查找

LNode * LocateElem(LinkedList L,ElemType e){
    LNode *p = L->next;
    while (p!= nullptr && p->data != e){
        p = p->next;
    }
    return p;
}

带头结点和不带头结点的比较：
不带头结点：写代码麻烦！对第一个数据节点和后续数据节点的处理需要用不同的代码逻辑，对空表和非空表的处理也需要用不同的代码逻辑; 头指针指向的结点用于存放实际数据;
带头结点：头指针指向的头结点不存放实际数据,头结点指向的下一个结点才存放实际数据;

2.3.2 双链表的实现

双链表的实现–初始化双链表

bool InitDLinkList(DLinklist &L){
    L = (DNode *)malloc(sizeof(DNode));
    if (L== nullptr)return false;
    L->prior = nullptr;
    L->next = nullptr;
    return true;
}

双链表的实现–在p结点之后插入s结点

bool InsertNextDNode(DNode *p,DNode *s){
    s->next = p->next;
    if (p->next != nullptr)p->next->prior = s;
    s->prior = p;
    p->next = s;
}

双链表的实现–双链表的删除

bool DeleteNextDNode(DNode *p){
    if (p == nullptr) return false;
    DNode *q = p->next;
    if (q == nullptr) return false;
    p->next = q->next;
    if (q->next != nullptr)
        q->next->prior = p;
    free(q);
    return true;
}

循环链表–循环单链表

最后一个结点的指针不是NULL,而是指向头结点

typedef struct LNode{            
    ElemType data;               
    struct LNode *next;  
}DNode, *Linklist;

/初始化一个循环单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode)); //分配一个头结点
    if(L==NULL)             //内存不足，分配失败
        return false;
    L->next = L;            //头结点next指针指向头结点
    return true;
}

//判断循环单链表是否为空（终止条件为p或p->next是否等于头指针）
bool Empty(LinkList L){
    if(L->next == L)
        return true;    //为空
    else
        return false;
}

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

循环链表–循环双链表

表头结点的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;
}

静态链表

#define MaxSize 50
#define ElemType int
typedef struct {
    ElemType data;
    int next;
}SlinkList[MaxSize];
bestkasscn
关注
专栏目录
考研系列-数据结构第二章、线性表
Nelson_hehe的博客
06-09 2175
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
(王道408考研数据结构)第二章线性表-第一节：线性表的定义和基本操作
快乐江湖的博客
11-07 2979
文章目录一：线性表的定义二：线性表的基本操作 一：线性表的定义 线性表(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
【考研·数据结构-＞线性表】2 顺序表删除元素
最新发布
weixin_62690215的博客
03-29 390
假如你要从一个顺序线性表删除某个元素，实现 ListDelete(SqList *L,int i,ElemType *e)，即在L中的第i个位置删除一个元素e，应该如何操作呢?3.删除元素位置开始遍历到最后一个元素位置，分别将它们向前移动一个位置4．表长减去1。1.如果删除的元素位置不正确，结束程序，输出异常信息。2.取出删除元素，放在元素e中。
考研数据结构--线性表
Maverick_曲流觞的博客
04-15 693
顺序表的定义,初始化,插入,删除,查找,输出,判空,销毁 单链表的定义,初始化,头插法,尾插法,按序号查找,按值查找,插入,删除,逆置,输出,判空,销毁 双链表的定义,初始化,头插法,尾插法,按序号查找,插入,删除,判空,打印 循环单链表,循环双链表,稀疏多项式
数据结构-线性表（考研篇）
Weightlessly的博客
01-29 1515
线性表 定义 具有相同数据类型的n个数据元素的有限序列（有次序） 几个概念： ai是线性表中“第i个”元素线性表中的位序 a1是表头元素，an是表尾元素 除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直接后继。 基本运算 顺序存储（顺序表） 定义：用顺序存储的方式实现的线性表。 顺序存储：逻辑上相邻的元素存储在物理位置上也相邻的存储单元中。 如何计算一个数据元素的大小？ 答：C语言中的sizeof(** **)函数 静态分配 #include <stdi
考研数据结构—线性表
纸城的博客
02-09 180
走出失恋的最好办法就是开始一项新的工程并全力以赴。 线性表：具有相同数据类型的数据元素的有限序列。 1定义 /*静态定义*/ #define Maxsize 100 // to define a SqList's length statically typedef int Elemtype typedef struct{ Elemtype data[Maxsize]; ...
基于C++实现顺序表 增删查改等基本功能 全实现 代码整洁 注释详细
weixin_47212736的博客
05-09 1226
文章目录实现的东西一、各函数<1>顺序表的初始化<2>顺序表是否为空<3>求顺序表长度<4>按内容查找<5>按下标插入<6>按下标删除元素<7>打印链表数据<8>移动函数，使链表所有比基准小的数在基准前，比基准大的数在基准后二、完整代码二、代码运行结果展示总结 实现的东西 本文是基于c++实现顺序表的帖子 定义函数一览： 实现了 void InitList(Seqlist* L) ;//顺序表的初始化 i..
【王道数据结构】第二章 线性表
weixin_48434658的博客
07-16 685
线性表(LinearList)的定义线性表的基本操作什么时候要传入参数的引用**“&”**——对参数的修改结果需要“带回来”顺序表的实现——静态分布顺序表的实现——动态分配顺序表特点什么是单链表用代码定义一个单链表🎈结点的表示即后可写为🎈定义一个单链表获取第i位结点（带头结点）两种实现方式🎨不带头结点🎨带头结点🎨不带头结点V.S.带头结点。...
数据结构考研讲义 第二章 线性表.pdf
08-31
【线性表】是数据结构中的基础概念，它是由相同数据类型的 n 个元素构成的有限序列，可以表示为 (a1, a2, ..., ai-1, ai, ai+1, ..., an)，n 称为表的长度，n=0 时为空表。线性表的数据元素之间存在一对一的关系，即...
【408计算机考研】数据结构——第二章 线性表
weixin_52280209的博客
04-16 618
408计算机考研数据结构知识总结分享。用于个人笔记整理，同时希望能够对正在或即将踏上408考研的同学有一丝丝帮助。苦与乐交织，疲惫的肉体需要精神的浇灌。。。
(王道408考研数据结构)第二章线性表-第三节3：循环单链表和循环双链表
快乐江湖的博客
11-10 1382
文章目录一：循环链表定义二：循环单链表三：循环双链表 一：循环链表定义 循环链表：规定好头尾结点的指向形成环状 循环单链表：其尾节点的next指针由原本的空改为指向头结点 循环双链表：其尾节点的next指针由原本的空改为指向头结点，同时头结点的prior指针指向尾节点 二：循环单链表 原来的单链表如果p是尾节点，一定有p->next=NULL; 循环单链表如果p是尾节点，一定有p->next=Head; 注意循环单链表的初始化 bool InitList(LNode*& He
考研数据结构————第二章：线性表
Belief的博客
07-24 4001
2021考研的第二章：线性表！！！冲冲冲 文章目录第二章 线性表2.1 线性表的定义和基本操作2.1.1 线性表的定义2.1.2 线性表的基本操作2.2 线性表的顺序表示2.2.1 顺序表的定义2.2.2 顺序表上基本操作的实现2.2.3本章习题 第二章 线性表 【考纲的内容】 （一）线性表的定义和基本操作 （二）线性表的实现 （三）顺序存储：链式存储；线性表的应用 【知识框架】 2.1 线性表的定义和基本操作 2.1.1 线性表的定义 线性表是具有相同数据类型的n(你>=0)个数
考研笔记-数据结构-线性表-顺序表
Never say never
06-29 551
111
数据结构之线性表（初识）
RDJE56523的博客
03-17 258
定义： 线性表是具有相同类型的n(n>=0)个元素的有限序列，其中n为表长，当n=0时，该表为空表。 若L命名为线性表，则一般表示为L=（a1,a2,…,ai,ai+1,…,an)） 特点： 表中元素个数有限 表中元素具有逻辑上的顺序性，在序列中各个元素排序有其先后次序 表中元素是数据元素，每个元素都是单个元素 表中元素的数据类型都相同，这意味着每个元素占有相同大小的存储空间 表中元素具有抽...
数据结构（C语言版）-线性表（顺序表）
czh2637750821的博客
01-04 1707
线性表一、线性表的基本概率1、线性表的定义2、线性表举例3、线性表的特点4、线性表的基本操作二、线性表的顺序存储1、顺序表的定义2、顺序表的存储特点3、顺序表的类型定义4、顺序表的基本运算的实现。三、配套实验 一、线性表的基本概率 1、线性表的定义 线性表是具有相同数据类型的n(n>= 0)个数据元素的有限序列。 2、线性表举例 （1）简单的线性表。例如，26个英文字母表；一周七天。 （2）复杂的线性表。例如，学生信息登记表。 在复杂的线性表，常把数据元素称为记录（Record），它由若干个数据项（I
考研数据结构——线性表
blljym的博客
05-01 296
线性表一条考研狗的日常坚持顺序表静态实现动态分配顺序表的特点 一条考研狗的日常坚持 从今天起，我就要坚持每天学几课数据结构，争取将每天的代码完全掌握，手敲才是王道，看懂不是真正的懂，相信自己，我可以的！加油！ 这里并不是将每一个知识都会写在上面，我会贴出我每天的代码，我不会将源码贴出来让你们复制哟，因为数据结构学习的最好的方法就是自己敲！我还会写一些重要的点，有兴趣的可以一起哦，参照的教程是《2...
考研数据结构---线性表---顺序表
PigWord的博客
07-04 346
线性表的逻辑结构 定义:线性表示具有相同数据类型的n（n>=0）个数据元素的有限序列 除了第一个元素外，每个元素有且仅有一个直接前驱，出最后一个元素外，每个元素有且仅有一个直接后继 物理结构 线性表的顺序存储结构 定义：线性表的顺序存储使用一组地址连续的存储单元（比如C语言里面的数组）依次存储线性表中的数据元素，顺序存储的线性表也叫顺序表。 顺序表需要的三个部分： 存储空间的起始位置 顺序...
线性表的创建，增加，插入，删除（代码）_数据结构学习记录（一）
我只知道的事
04-27 3597
//线性表的存储结构 #include<stdio.h> #include<iostream> #include<conio.h> #include<stdlib.h> using namespace std; #define LISTSIZE 100 //假设表容量100 typedef int DataType; typedef struct ...
考研笔记之数据结构之线性表（严蔚敏版）
xiao_yan_的博客
05-16 526
顺序表的定义 顺序表的特点为表中元素的逻辑顺序与物理顺序相同。 sizeof(数据类型)：数据元素所占用的存储空间的大小 起始位置为LOC(A),第i个元素为LOC(A)+(n-1)*sizeof(数据类型) 线性表的初始化 静态分配 使用静态数组 大小确定无法改变 #define MaxSize 10 typedef struct { ElemType data[MaxSize]; int length; }mystruct; ElemType:是一个抽象的数据类型，表示我们想使用的所有数据
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

bestkasscn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值