线性表基本操作总结_顺序表_链表

已于 2023-04-07 21:58:04 修改
阅读量265 收藏 2
点赞数 1
文章标签： 链表 数据结构 算法
于 2023-04-07 18:43:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liaoai/article/details/130018519
版权

文章目录

线性表

存储结构

1.顺序表（顺序存储）

① 静态分配

定义

#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    //初始长度
typedef struct{
    ElemType *data;    //指示动态分配数组的指针
    int MaxSize;        //最大容量
    int length;        //当前长度
}SeqList;

初始化

void InitList(SeqList &L){
    L.data = (int *)malloc(InitSize * sizeof(int));    //设int型
    L.length = 0;
    L.MaxSize = InitSize;
}

增加动态数组的长度

//malloc 动态扩展顺序表的最大容量，最后需要free函数释放原区域
void IncreaseSize(SeqList &L, int len){
    int *p = L.data;    //用p指向原来的数组的起始地址
    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);    //释放原来的内存空间
}
基本操作
① 插入
//将元素e插入到L的第i个位置    1 <= i <= length+1
bool ListInsert(SqList &L,int i,int e){
    if(i<1 || i > L.length+1) return false;
    if(L.length >= MaxSize) return false;
    for(int j = L.length; j >= i; j--) L.data[j] = L.data[j-1];    //从最后一个元素开始后移一位
    L.data[i-1] = e;
    L.length++;
    return true;
}
② 删除
//删除表L中第i个位置的元素，并用e返回       1 <= i <= length
bool ListDelete(SqList &L, int i, int &e){
    if(i<1 || i > L.length) return false;
    e = L.data[i-1];
    for(int j = i; j < L.length; j++) L.data[j-1] = L.data[j];    //从第i+1位置开始，向前移动
    L.length --;
    return true;
}

tips： 添加时移动元素是从最后一个元素开始后移，删除时是从第i+1个位置开始前移

③ 按位查找
int GetElem(SqList L, int i){
    return L.data[i-1]
}
④ 按值查找
int LocateElem(SqList L,int e){
    for(int i = 0; i < L.length; i++)
        if(L.data[i] == e) return i+1;
    return 0;
}

2.链表（链式存储）

① 单链表

定义

typedef struct LNode{
    ElemType data;
    struct Node *next;
}LNode, *LinkList;

tips： 使用LNode*用于强调是结点，使用LinkList用于强调是单链表

初始化
//不带头结点
bool InitList(LinkList &L){
    L = NULL;    //用此判空
    return true;
}
//带头结点
bool InitList(LinkList &L){
    L = (LNode*)malloc(sizeof(LNode));
    if(L == NULL) return false;    //分配失败
    L->next = NULL;    //用此判空
    return true;
}
插入
  • 按位序插入
//有头结点，对于在第一个位置插入不需特殊处理，因为0号结点就是头结点，相当于在头结点后插
bool ListInsert(LinkList &L,int i,ElemType e){
    if(i<1) return false;
    LNode *p;    //指向当前扫描到的结点
    int j =0;    //当前p指向的是第几个结点
    p = L;        //p指向头结点
    while(p != NULL && j < i-1){    //找到第i-1个结点，即插入位置的前一个结点
        p = p->next;
        j++;
    }
    if(p == NULL) return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s -> data = e;
    s -> next = p -> next;
    p -> next = s;
    return true;
}
//无头结点，当在第一个位置插入需要特判
bool ListInsert(LinkList &L,int i,ElemType e){
    if(i<1) return false;
    if(i == 1)
    {
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s -> data = e;
        s -> next = L;
        L = s;        //头指针指向第一个结点
        return true;
    }
    LNode *p;    //指向当前扫描到的结点
    int j = 1;    //当前p指向的是第几个结点
    p = L;        //p指向第一个结点
    while(p != NULL && j < i-1){    //找到第i-1个结点，即插入位置的前一个结点
        p = p->next;
        j++;
    }
    if(p == NULL) return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s -> data = e;
    s -> next = p -> next;
    p -> next = s;
    return true;
}
  • 指定结点的后插
bool InsertNextNode(LNode *p, ElemType e){
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s -> data = e;
    s -> next = p -> next;
    p -> next = s;
    return true;
}
  • 指定结点的前插
//法1：引入头指针，从头指针遍历找到p的前驱结点q，再对q后插
//法2：偷天换日，实际是尾插，但将其data替换
bool InsertPriorNode(LNode *p, ElemType e){
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s -> next = p -> next;
    p -> next = s;
    s -> data = p -> data;
    p -> data = e;
    return true;
}
删除

需要找到前驱节点

  • 按位序删除（带头结点）
bool ListDelete(LinkList &L,int i,ElemType &e){
    if(i<1) return false;
    LNode *p;    //指向当前扫描到的结点
    int j =0;    //当前p指向的是第几个结点
    p = L;        //p指向头结点
    while(p != NULL && j < i-1){    //找到第i-1个结点，
        p = p->next;
        j++;
    }
    if(p == NULL) return false;
    if(p->next == NULL)  return false;
    LNode *q = p -> next;
    e = q -> data;
    p -> next = q -> next; 
    free(q);
    return true;
}
  • 指定结点的删除
//法1：引入头指针，从头指针遍历找到p的前驱结点q
//法2：偷天换日
bool DeleteNod(LNode *p){
    if(p == NULL) return false;
    LNode *q = p->next;
    p -> data = q -> data;    //如果p是最后一个节点，那么q不存在，只能从表头开始寻找p的前驱
    p -> next = q -> next;
    free(q);
    return true;
}
查找
  • 按位查找
LNode * GetElem(LinkList L,int i){
    if(i<0) return false;
    LNode *p;    //指向当前扫描到的结点
    int j =0;    //当前p指向的是第几个结点
    p = L;        //p指向头结点
    while(p != NULL && j < i){    //找到第i个结点
        p = p->next;
        j++;
    }
    return p;
}
  • 按值查找
LNode * LocateElem(LinkList L,ElemType e){
    LNode *p = L->next;
    while(p != NULL && p->data != e)    
        p = p->next;
    return p;
}
建立
  • 尾插法

相当于对尾结点的后插，则可以设立一个表尾指针，每次插入一个结点后将其修改。

LinkList List_TailInsert(LinkList &L){
    int x;
    L = (LinkList)malloc(sizeof(LNode));    //建立头结点
    LNode *s,*r = L;    //r为表尾指针
    cin >> x;
    while(x!=9999)    //设立一个特殊值表示结束
    {
        s = (LNode *)malloc(sizeof(LNode));
        s -> data = x;
        r -> next = s;
        r = s;    //r指向新的表尾
        cin >> x;
    }
    r -> next = NULL;
    return L;
}
  • 头插法（链表的逆置）

相当于对头结点的后插

LinkList List_HeadInsert(LinkList &L){
    int x;
    L = (LinkList)malloc(sizeof(LNode));    //建立头结点
    L -> next = NULL;
    LNode *s;
    cin >> x;
    while(x!=9999)    //设立一个特殊值表示结束
    {
        s = (LNode *)malloc(sizeof(LNode));
        s -> data = x;
        s -> next = L -> next;
        L -> next = s;
        cin >> x;
    }
    return L;
}

//给定一个L，如何逆置
LinkList List_HeadInsert(LinkList L,LinkList &L2){
    int x;
    L2 = (LinkList)malloc(sizeof(LNode));    //建立头结点
    L2 -> next = NULL;
    LNode *s;
    LNode *p = L->next;
    while(p != NULL){
        x = p -> data;
        s = (LNode *)malloc(sizeof(LNode));
        s -> data = x;
        s -> next = L2 -> next;
        L2 -> next = s;
    }
    return L2;
}
```
② 双链表

定义

typedef struct LNode{
    ElemType data;
    struct Node *prior,*next;
}LNode, *DLinkList;
初始化
L->prior = NULL;
L->next = NULL;
插入
//p结点后插入s结点
s->next = p->next;
if(p->next != NULL) p->next->prior = s;    //如果p有后继
p->next = s;
s->prior = p;
删除
//删除p结点的后继结点
DNode *q = p->next;
p->next = q->next;
if(q->next != NULL) q->next->prior = p;
free(q);
遍历
//后向
while(p!=NULL) p=p->next;
//前向
while(p!=NULL) p=p->prior;
//前向（跳过头结点）
while(p->prior!=NULL) p=p->prior;
③ 循环单链表
初始化
L->next = L;    //判空

判断p是否为表尾结点

p->next == L;
④ 循环双链表
初始化
L->prior = L;
L->next = L;    //判空

判断p是否为表尾结点

p->next == L;

插入删除时，不用判断

//p后插入s
s->next = p->next;
p->next->prior = s;   
p->next = s;
s->prior = p;

//删除p结点的后继结点
DNode *q = p->next;
p->next = q->next;
q->next->prior = p;
free(q);
⑤ 静态链表

定义

typedef struct{
    ElemType data;
    int next;    //下一个元素的数组下标
}SLinkList[MaxSize];
SLinkList a;
初始化
a[0] = -1;
liaoai
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线性表基本操作
Yangchenju的博客
07-28 2516
数据在代码中被处理和操作的最小单位动作是增、删、查。他们是深入学习数据结构的根基，通过“增删查”操作，我们可以选择更合适的数据结构来解决实际工作中遇到的问题。例如几个客户端分别分别向服务端发送请求，服务端要采取先到先得的处理方式，应该如何设计数据结构呢？本文介绍数据结构之一，线性表。 1.什么是线性表 数据结构是数据的组织方式。那么线性表就是数据的组织方式之一。线性表是n个数据元素的有限列表，最常用的是链式表达，通常也叫作线性链表或链表。 在链表中存储的数据元素叫做结点，一个结点存储的就是一条数据记录。每个
数据结构实验线性表（用java创建顺序表与链表并解决实验题目）
05-10
实验内容： （1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度均为 O(n)）。 （2）建立一个循环单链表，其节点有 prior，data 和 next 三个域，其中 data 为数 据域，存放元素的有效信息，next 域为指针域，指向后继节点，prior 为指针域，它的值为 NULL。编写一个算法将此表改为循环双链表。
顺序表和链表的基本操作和实际应用
07-20
此为线性表应用实例代码集合，包括顺序表和链表的各种基本操作、以及顺序表链表在多项式和图书管理系统中的应用
实验一终稿_基本操作_C++_线性表_
10-01
根据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。线性表存储结构（五选一）：1、 带头结点的单链表2、 不带头结点的单链表3、 循环链表4、 双链表5、 静态链表线性表的基本功能：1、 构造：使用头插法、尾插法两种方法2、 插入：要求建立的链表按照关键字从小到大有序（静态链表不要求该项）3、 删除4、 查找5、 获取链表长度6、 销毁7、 其他：可自行定义编写测试 main()函数测试线性表的正确性。
数据结构实验2———线性表及其应用
weixin_56665183的博客
10-28 1512
实验内容 （1）编程实现顺序表的如下操作，并设计菜单完成调用。 ①表的建立、输出、求长度、取值、查找、插入、删除等基本操作（必做） ②表的逆置（要求利用原表的存储空间）。（选做） ③删除表中所有值为x的元素。（选做） ④将两个递增有序表合并成一个递增有序表。（算法2.16，P43）【考虑：数据不重复，或者合并为递减有序表的情况）】 （2）编程实现单链表的如下操作，并设计菜单完成调用。 ①表的建立、输出、求长度、取值、查找、插入、删...
线性表总结
Six23333的博客
09-05 617
文章目录一、线性表的定义三、线性表的顺序表示（顺序表）3.1顺序表存储类型3.2顺序表的插入操作总结 一、线性表的定义 线性表是具有相同数据类型的n个数据元素的有限序列。 其中第一个元素称为表头元素，最后一个元素称为表尾元素。 除表头元素外，每个元素都有自己的直接前驱。 除表尾元素外，每个元素都有自己的直接后继。 # 二、线性表的特点 元素个数有限 逻辑上具有顺序 元素都是数据元素 每个元素数据类型相同，意味着占有相同大小的存储空间 具有抽象性 三、线性表的顺序表示（顺序表） 线性表的顺序存
线性表基本操作整理
oldxmtang的博客
04-06 240
///为了方便阅读，我直接把注释写在了程序里，如果发现我写的有问题，欢迎各位巨佬指导。 #include<iostream> using namespace std; typedef int elemtype;///elemtype就是线性表中的元素类型 ///我们暂时把类型设为int const int maxsize=100;///startsize就是线性表的大小 const int nstep=10; struct mylist { elemtype *node;///线性表中..
线性表的基本操作
weixin_35748962的博客
01-05 796
线性表的基本操作包括： 插入：向线性表中添加一个新元素。 删除：从线性表中删除一个元素。 查找：在线性表中查找某个特定的元素。 修改：修改线性表中的某个元素。 遍历：逐个访问线性表中的每一个元素。 这些操作在不同的数据结构中可能有所不同，但是都是线性表的基本操作。 ...
C、C++线性表基本操作的详细介绍
12-16
前言 线性表包括两部分顺序表和链表，是数据结构的基础，在此主要就算法进行分析和总结，作为记忆了解，未做具体实现。 提示：以下是本篇文章正文内容，下面案例可供参考 一、顺序表 #define LISST_INIT_SIZE 100 #define LISTINCREMENT 10 #define OK 0 #define OVERFLOW 1 typedef int ElemType; typedef int Status; 1、定义 typedef struct{ int* elem; //定义存储基地址 int length; //当前顺序表长度 int lis
数据结构快速入门—线性表的基本操作详解【C++】
m0_56003861的博客
01-26 3262
小白入门数据结构，用最精简的C++语言来运行
实验报告1.2.2顺序表基本操作应用实验2
12-25
实验报告1.2.2顺序表基本操作应用实验2
线性表的基本操作实现及其应用实验报告
12-31
该程序的功能是实现单链表的定义和操作。该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。其中，程序中的单链表（带头结点）结点为结构类型，结点值为整型。单链表操作的选择以菜单形式出现，如下所示： 1.初始化 2.清空 3.求链表长度 4.检查链表是否为空 5.检查链表是否为满 6.遍历链表（设为输出元素）7.从链表中查找元素 8.从链表中查找与给定元素值相同的元素在表中的位置 9.向链表中插入元素 10. 从链表中删除元素
数据结构学习--线性表及其应用--顺序表
06-25
在众多数据结构当中，线性表是最简单、也是最...本实验相对比较简单，通过本实验，对顺序表基本操作及 其组合应用的演练，加深对线性表顺序存储方法及其基本操作的理解，为以后进一步学习更 复杂的数据结构打下基础。
实验一 线性表基本操作的编程实现
02-09
线性表基本操作的编程实现（2学时，验证型），掌握线性表的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找、逆序、排序等操作，存储结构可以在顺序结构或链表结构中任选，可以完成部分主要...
对线性表的总结（c语言实现）
最新发布
zeuris的博客
12-02 51
总的来说，线性表是一种常见的数据结构。线性表就是由n（n>=0）个相同类型的数据元素组成的有序序列。集合中的数据元素具有线性关系，即元素之间有前后顺序关系。除了第一个数据元素外，每一个数据元素只有一个直接前驱。除了最后一个数据元素外，每一个数据元素只有一个直接后继。满足这些特点的集合就可以被称为线性表，而在这之后学习的树，图等数据结构都有其各自的特点，这些数据结构都有其适合的应用场景，在工作中都会起到不可或缺的作用，所以当前的学习需要对这些数据结构的实现掌握牢固。
数据结构实验-线性表的基本操作
m0_54570435的博客
04-27 1173
5.在链表插入时，先录入要插入的位置，然后用input函数将数据存在c结点中，再用ListInsert函数将结点插入链表，先查找插入位置的前一个结点，将指针p指向该结点。生成一个新节点s，将结点s的数据域置为输入的c结点，将 结点s的指针域指向下一个结点，将结点p的指针域指向结点s。链表删除时先找到要删除元素前一个元素，指针p指向该结点，临时保存被删除结点的地址以备释放，将要删除结点的前驱结点指针域指向要删除结点的直接后继结点，释放删除结点空间。程序代码LinkList。程序代码SqList。
线性表的总结
hzcx777的博客
10-28 1068
一．线性表（ Linear List ）的定义：线性表是零个或多个具有相同类型的数据元素的有限序列。数据元素的个数定义为线性表的 长度 。长度等于零时称为空表，一个非空表通常记为 L ＝ ( a 1 ， a 2 ，……， a n ) 其中， a i （ 1 ≤ i ≤ n ）称为数据元素，下标 i 表示该元素在线性表中的位置或序号， 称元素 a i 位于表的第 i 个位置，或称 a i 是表中的第...
数据结构实训报告(线性表+栈和队列+二叉树+图+排序)
我们都有光明的未来
12-02 3206
数据结构实训报告，实验报告(线性表+栈和队列+二叉树+图+排序)
线性表实验报告
m0_54015435的博客
06-05 4656
线性表 基本概念 线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。数据元素是一个抽象的符号，其具体含义在不同的情况下一般不同。 在稍复杂的线性表中，一个数据元素可由多个数据项（item）组成，此种情况下常把数据元素称为记录（record），含有大量记录的线性表又称文件（file）。 线性表中的个数n定义为线性表的长度，n=0时称为空表。在非空表中每个数据元素都有一个确定的位置，如用ai表示数据元素，则i称为数据元素ai在线性表中的位序。 线性表的相邻元素之
链表操作nav 第1关:顺序构建线性表
09-24
在链表的操作中，第一关是顺序构建线性表。构建线性表的目标是按照一定的顺序将节点依次连接起来。 首先，我们需要声明一个链表的数据结构，包含节点的定义和指针的定义。节点由数据和指针两个部分组成。数据部分...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值