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

已于 2022-05-06 16:03:37 修改
阅读量343 收藏 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
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
(王道408考研数据结构)第二章线性表-第一节：线性表的定义和基本操作
快乐江湖的博客
11-07 2789
文章目录一：线性表的定义二：线性表的基本操作 一：线性表的定义 线性表(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
数据结构考研讲义 第二章 线性表.pdf
08-31
【线性表】是数据结构中的基础概念，它是由相同数据类型的 n 个元素构成的有限序列，可以表示为 (a1, a2, ..., ai-1, ai, ai+1, ..., an)，n 称为表的长度，n=0 时为空表。线性表的数据元素之间存在一对一的关系，即...
2024 王道考研-数据结构（线性表_1）
Xiao_Ya__的博客
10-18 960
2024 王道考研-数据结构 第二章 线性表算法题
考研数据结构--线性表
Maverick_曲流觞的博客
04-15 618
顺序表的定义,初始化,插入,删除,查找,输出,判空,销毁 单链表的定义,初始化,头插法,尾插法,按序号查找,按值查找,插入,删除,逆置,输出,判空,销毁 双链表的定义,初始化,头插法,尾插法,按序号查找,插入,删除,判空,打印 循环单链表,循环双链表,稀疏多项式
【数据结构考研笔记】线性表 顺序表
qq_27846147的博客
03-06 485
考研数据结构笔记 线性表 顺序表
数据结构-线性表（考研篇）
Weightlessly的博客
01-29 1469
线性表 定义 具有相同数据类型的n个数据元素的有限序列（有次序） 几个概念： ai是线性表中“第i个”元素线性表中的位序 a1是表头元素，an是表尾元素 除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直接后继。 基本运算 顺序存储（顺序表） 定义：用顺序存储的方式实现的线性表。 顺序存储：逻辑上相邻的元素存储在物理位置上也相邻的存储单元中。 如何计算一个数据元素的大小？ 答：C语言中的sizeof(** **)函数 静态分配 #include <stdi
【2022---计算机考研】数据结构之线性表总结（超详细适合背诵）
CSDN_Admin0的博客
10-30 811
// 考试时尽量用以下函数名称，方便老师阅卷！！！ 1、InitList(&L) :初始化表,构造一个空的线性表 2、Length (L) :求表长,返回线性表L的长度,即L中数据元素的个 3、LocateElem(L,e) :按值查找操作,在表L中查找具有给定关键字值的元素 4、GetElem(L,i) :按位查找操作获取表L中第i个位置的元素的值 线性表和链表的使用技巧全方位对比！！！
数据结构第二版（清华严蔚敏版）数据结构习题答案
01-24
"数据结构第二版（清华严蔚敏版）数据结构习题答案" 本资源摘要信息涵盖了数据结构的基本概念、逻辑结构、存储结构、抽象数据类型等知识点，并提供了详细的解释和例子。 数据结构基本概念 数据结构是相互之间存在...
408考研数据结构思维导图
01-02
第二章：线性表 线性表是最基础的数据结构之一，包括顺序表和链表两种实现方式。顺序表操作简单，但插入和删除效率较低；链表则在这些操作上具有优势，但内存利用率不高。这一章会深入探讨这两种结构的特点、操作...
考研-数据结构-殷人昆.zip
09-09
1.1 针对考研数据结构的代码书写规范以及C 与C 语言基础1 1.1.1 考研综合应用题中算法设计部分的代码书写规范1 1.1.2 考研中的C 与C 语言基础3 1.2 算法的时间复杂度与空间复杂度分析基础 12 1.2.1 考研中的算法时间...
考研学习笔记序列之数据结构（线性表的定义和基本操作）
08-17
这是我复习过程中的一些资料，不过还没整理好，为了方便存取，需要的朋友可以下载，不需要资源分。
数据结构考研资料--线性表及答案
01-05
2008年5月8日 ... 写出将la 和lb两链表归并成一个结点按元素值非递减有序排列的单链表（其头指针为lc），并计算算法的 ... <br>【北京工业大学1997 一、1 (8分)】<br>（2）设有两个链表，ha为单向链表，hb为单向循环链表。 ... 设Listhead为一单链表的头指针，单链表的每个结点由一个整数域DATA和指针域NEXT组成，整数在单链表中是无序的。
数据结构复习（二）线性表①
qq_46113775的博客
05-31 502
线性表相关内容
考研数据结构—线性表
纸城的博客
02-09 158
走出失恋的最好办法就是开始一项新的工程并全力以赴。 线性表：具有相同数据类型的数据元素的有限序列。 1定义 /*静态定义*/ #define Maxsize 100 // to define a SqList's length statically typedef int Elemtype typedef struct{ Elemtype data[Maxsize]; ...
考研笔记-数据结构-线性表-顺序表
Never say never
06-29 511
111
[考研系列之数据结构]线性表之栈
搬砖专业户的悲惨人生
05-30 1063
​基本概念 栈的定义 限定仅在表尾进行插入或删除的线性表 组成 栈顶 栈底 基本操作 入栈(PUSH) 往栈中插入一个元素 弹栈(POP) 从栈顶删除一个元素 栈的表示 顺序栈 链栈 对于顺序栈，有两
【C语言】数据结构C语言版 实验1 线性表的顺序实现
点滴记忆
11-20 6586
运行环境：Dev-C++ vs2013可能不能运行 首先新建一个头文件sequlist.h #include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 typedef int datatype; typedef struct{ datatype a[MAXSIZE]; int size; ...
严蔚敏数据结构查找的基本操作_数据结构 学习笔记（2）
weixin_39927623的博客
11-23 65
2.1线性表的定义和基本操作线性表的定义线性表是具有相同数据类型的n（n>=0）个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若L命名线性表，则其一般表示为几个概念：线性表的基本操作InitList(&L):初始化表。构造一个空的线性表L，分配内存空间。DestroyList(&L):销毁操作。销毁线性表，并释放线性表L所占用的内存空间。ListInsert...
c语言（7.23）
最新发布
fhgfyrsg的博客
07-23 555
【代码】c语言（7.23）
13 8 D:\study\考研数据结构\第二章线性表\链式表\LinkList.h [Note] expected 'LinkList' but argument is of type 'struct LNode **'
07-25
这个错误提示表明在函数调用时，参数的类型与期望的类型不匹配。你提供的代码片段中，函数调用可能存在问题。在你的代码中，你期望传入一个 `LinkList` 类型的参数，但实际传入的是一个 `struct LNode **` 类型的参数。 可能的原因是你在函数调用时传入了错误的参数。请检查你的代码，确保你在调用函数时传入了正确的参数类型。另外，也可以检查函数声明和定义，确保参数的类型与期望的一致。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

bestkasscn

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

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

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

打赏作者

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

抵扣说明：

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

余额充值