【数据结构】【王道】【线性表】顺序表实现及基本操作（可直接运行）

已于 2022-07-21 09:55:32 修改
阅读量695 收藏 13
点赞数 2
分类专栏： 数据结构 c/c++ 文章标签： 数据结构 c++ 算法
于 2022-07-06 17:06:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/treesorshining/article/details/125643373
版权

总目录

文章目录


各部分的解释已经以注释形式写于代码中。

1.顺序表简介

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
在这里插入图片描述

2.动态分配

动态分配是指分配的空间大小可以在运行时动态决定。

2.1 表的定义

typedef struct {
    int* data;  // 指向动态分配顺序表的指针
    int MaxSize;    // 顺序表最大容量
    int length; // 顺序表当前长度
} SeqList;

2.2 初始化

// 初始化
void InitList(SeqList &L) {
    // 用malloc函数申请一片连续的存储空间
    // 注意：前面部分的强转不能忘记，否则会出错，应转成对应类型的指针
    // c++可通过new来实现
    // L.data = new int[InitList];
	L.data = (int*)malloc(InitSize * sizeof(int)) ;
	L.length = 0;
	L.MaxSize = InitSize;
}

2.3 删除顺序表

// 删除顺序表
void DestroyList(SeqList &L) {
    // 删除顺序表先释放内存，再将data置空、length设为0即可
    // 不能忘记使用free，使用malloc拓展的内存，如果不进行释放，就将指针指向了Null
    // 就会导致之后无法再释放那部分内存（指针指向已经改变），导致内存泄露
    if(L.data != NULL) {
        free(L.data);
        L.data = NULL;
        L.length = 0;
        L.MaxSize = 0;
    }
}

2.4 返回表长

// 返回表长
int Length(SeqList L) {
    // 直接返回length即可
    return L.length;
}

2.5 按值查找

// 按值查找
int LocateElem(SeqList L, int e) {
    for(int i = 0;i < L.length;i++) {
        if(L.data[i] == e) {
            // i为其在顺序表中的位置，i + 1为其位序
            return i + 1;
        }
    }
    // 返回-1表示未找到
    return -1;
}

2.5 按位查找

// 按位查找
int GetElem(SeqList L, int i) {
    //判断i的范围是否有效
    if(i < 1 || i > L.length) 
        return -1;

    // i为位序，即第i个元素
    return L.data[i - 1];
}

2.6 插入操作

在这里插入图片描述

// 顺序表插入操作
bool ListInsert(SeqList &L, int i, int e) {
    // 判断i是否有效
    // 此处之所以为i+1，是因为插入之后长度增加了1
    if(i < 1 || i > L.length + 1) {
        return false;
    }
    // 还需判断目前长度是否与最大容量值相等，是否需要进行空间扩充
    if(L.length >= L.MaxSize) {
        // 表已满，不能插入
        // return false;
        // 也可以选择扩充空间，此处扩充一个初始值空间
        int *p = (int *)malloc((L.MaxSize + InitSize) * sizeof(int));
        for(int i = 0;i < L.length;i++) {
            p[i] = L.data[i];
        }
        // 释放data所占用空间
        free(L.data);
        // 修改data指向并修改最大长度值
        L.data = p;
        L.MaxSize = L.MaxSize + InitSize;
    }
    // 插入操作
    // 先将第i个元素及之后元素后移
    for(int j = L.length;j >= i;j--) {
        L.data[j] = L.data[j - 1];
    }
    // 在位置i处插入e
    L.data[i - 1] = e;
    // 长度增加
    L.length++;
    return true;
}

2.7 删除操作

在这里插入图片描述

// 顺序表删除操作
// 此处e为引用变量的原因是e可在外部定义，而只有通过引用变量才能将值的变化保留下来
// 即在完成删除操作之后，外部的e值即会变为所删除的元素的值
bool ListDelete(SeqList &L, int i, int &e) {
    // 判断i是否有效
    if(i < 1 || i > L.length) {
        return false;
    }
    // e为即将删除的元素
    e = L.data[i - 1];
    // 删除操作
    // 将第i个元素之后的元素前移
    for(int j = i;j < L.length;j++) {
        L.data[j - 1] = L.data[j]; 
    }
    // 注意长度值的修改
    L.length--;
    return true;
}

2.8 判空操作

// 判空操作
bool Empty(SeqList L) {
    // 直接根据长度判断即可
    if(L.length == 0) {
        return true;
    }
    return false;
}

2.9 输出操作

// 顺序表的输出操作
bool PrintList(SeqList L) {
    // 若表为空，则不能输出
    if(Empty(L)) {
        return false;
    }
    // 循环遍历输出
    for(int i = 0;i < L.length;i++) {
        printf("data[%d]=%d\n", i, L.data[i]);
    }
    return true;
}

2.10 增加数组长度

// 增加数组长度
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];
	}
    // 顺序表最大容量增加len
	L.MaxSize = L.MaxSize + len;
    //释放原来的内存空间
	free(p);
}

2.11全部代码

// 顺序表实现——动态分配
#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函数申请一片连续的存储空间
    // 注意：前面部分的强转不能忘记，否则会出错，应转成对应类型的指针
    // c++可通过new来实现
    // L.data = new int[InitList];
	L.data = (int*)malloc(InitSize * sizeof(int)) ;
	L.length = 0;
	L.MaxSize = InitSize;
}

// 删除顺序表
void DestroyList(SeqList &L) {
    // 删除顺序表先释放内存，再将data置空、length设为0即可
    // 不能忘记使用free，使用malloc拓展的内存，如果不进行释放，就将指针指向了Null
    // 就会导致之后无法再释放那部分内存（指针指向已经改变），导致内存泄露
    if(L.data != NULL) {
        free(L.data);
        L.data = NULL;
        L.length = 0;
        L.MaxSize = 0;
    }
}

// 返回表长
int Length(SeqList L) {
    // 直接返回length即可
    return L.length;
}

// 按值查找
int LocateElem(SeqList L, int e) {
    for(int i = 0;i < L.length;i++) {
        if(L.data[i] == e) {
            // i为其在顺序表中的位置，i + 1为其位序
            return i + 1;
        }
    }
    // 返回-1表示未找到
    return -1;
}

// 按位查找
int GetElem(SeqList L, int i) {
    //判断i的范围是否有效
    if(i < 1 || i > L.length) 
        return -1;

    // i为位序，即第i个元素
    return L.data[i - 1];
}

// 顺序表插入操作
bool ListInsert(SeqList &L, int i, int e) {
    // 判断i是否有效
    // 此处之所以为i+1，是因为插入之后长度增加了1
    if(i < 1 || i > L.length + 1) {
        return false;
    }
    // 还需判断目前长度是否与最大容量值相等，是否需要进行空间扩充
    if(L.length >= L.MaxSize) {
        // 表已满，不能插入
        // return false;
        // 也可以选择扩充空间，此处扩充一个初始值空间
        int *p = (int *)malloc((L.MaxSize + InitSize) * sizeof(int));
        for(int i = 0;i < L.length;i++) {
            p[i] = L.data[i];
        }
        // 释放data所占用空间
        free(L.data);
        // 修改data指向并修改最大长度值
        L.data = p;
        L.MaxSize = L.MaxSize + InitSize;
    }
    // 插入操作
    // 先将第i个元素及之后元素后移
    for(int j = L.length;j >= i;j--) {
        L.data[j] = L.data[j - 1];
    }
    // 在位置i处插入e
    L.data[i - 1] = e;
    // 长度增加
    L.length++;
    return true;
}

// 顺序表删除操作
// 此处e为引用变量的原因是e可在外部定义，而只有通过引用变量才能将值的变化保留下来
// 即在完成删除操作之后，外部的e值即会变为所删除的元素的值
bool ListDelete(SeqList &L, int i, int &e) {
    // 判断i是否有效
    if(i < 1 || i > L.length) {
        return false;
    }
    // e为即将删除的元素
    e = L.data[i - 1];
    // 删除操作
    // 将第i个元素之后的元素前移
    for(int j = i;j < L.length;j++) {
        L.data[j - 1] = L.data[j]; 
    }
    // 注意长度值的修改
    L.length--;
    return true;
}

// 判空操作
bool Empty(SeqList L) {
    // 直接根据长度判断即可
    if(L.length == 0) {
        return true;
    }
    return false;
}

// 顺序表的输出操作
bool PrintList(SeqList L) {
    // 若表为空，则不能输出
    if(Empty(L)) {
        return false;
    }
    // 循环遍历输出
    for(int i = 0;i < L.length;i++) {
        printf("data[%d]=%d\n", i, L.data[i]);
    }
    return true;
}

// 增加数组长度
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];
	}
    // 顺序表最大容量增加len
	L.MaxSize = L.MaxSize + len;
    //释放原来的内存空间
	free(p);
} 

int main() {
    SeqList L;
    // 初始化
    InitList(L);
    // 插入数据
    ListInsert(L, 1, 1);
    ListInsert(L, 2, 2);
    ListInsert(L, 1, 3);
    // 输出所有数据
    PrintList(L);
    // 输出表长
    printf("length=%d\n", Length(L));
    // 按值查找
    printf("locate=%d\n", LocateElem(L, 3));
    // 按位查找
    printf("index=%d\n", GetElem(L, 3));
    // 判空操作
    printf("empty=%d\n", Empty(L));
    // 删除数组数据
    int e;
    ListDelete(L, 3, e);
    PrintList(L);
    // 删除顺序表
    DestroyList(L);
    // 判空操作
    printf("empty=%d\n", Empty(L));
}

3.静态分配

静态分配即是一旦顺序表大小和空间确定，之后不可改变。

// 顺序表实现——静态分配
#include<stdio.h>
#define MaxSize 10  // 宏定义 表的最大长度

// 静态分配 数组的大小与空间固定，不可改变
typedef struct {
    int data[MaxSize];  // 顺序表元素
    int length; // 顺序表长度（当前！！！）
} StaticSeqList; // 顺序表类型定义

// 初始化
void InitList(StaticSeqList &L) {
    // 初始表内无元素，长度设为0
    L.length = 0;
    // 将顺序表所有值设为0，防止脏数据
    // 脏数据即是指：在内存被分配后，系统所分配的内存之前可能用于存储其他数据，即可能有残留
    // 如果将此部分删除，直接输出data，不会报错，但输出内容可能会存在问题
    for(int i = 0;i < MaxSize;i++) {
        L.data[i] = 0;
    }
}

int main() {
    StaticSeqList L;    // 声明一个顺序表
    InitList(L);    // 初始化
    // 输出data内容
    for(int i = 0;i < MaxSize;i++) {
        printf("data[%d]=%d\n", i, L.data[i]);
    }
    return 0;
}
Silver Star
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
考研408-数据结构-线性表之顺序表基础及实现
再难也要坚持的博客
12-30 156
考研408-数据结构-线性表之顺序表基础及实现 考研后遗症,整理一下基础知识.文章的架构来源于王道考研数据结构,因为书上的代码部分代码被省略,所以自己没事整理了一下. #include <iostream> using namespace std; #define MaxSize 50 //线性表最大长度 // 静态分配 struct SqList { int data[MaxSize]; //顺序表的元素 int length; //顺序表的长度 }; //
数据结构之线性表(顺序表与链表)--王道
weixin_64144469的博客
05-21 632
目录 2.1线性表的定义和基本操作 2.1.1线性表的定义 2.1.2线性表的基本操作 2.2线性表的顺序表示 2.2.1顺序表的定义 2.2.2顺序表上基本操作的实现 2.3线性表的链式表示 2.3.1单链表的定义 2.3.2单链表上基本操作的实现 1.用头插法建立单链表 2.用尾插法 3.按序号查找结点值 4.按值查找表结点 5.插入结点操作 6.删除结点操作 7.求表长操作 2.3.3双链表 1.双链表的插入 2.双链表的删除 2.3.4循环链表...
数据结构-顺序表基本操作的实现（含全部代码）
热门推荐
关注网络安全、云原生安全
09-13 21万+
今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。 今天是线性表中的顺序表的实现，主要实现函数如下，读者有需要可以评论，我可以适当加几个。 CreatList(SqList &L,int n) 参数：顺序表L，顺序表长度n 功能：创建长度为的顺序表 时间复杂度：O(n) InitList(SqList &...
数据结构 线性表的定义和基本操作（以顺序表为例）
流苏的博客
06-28 411
线性表的定义和基本操作（以顺序表为例）
【数据结构】【王道】【线性表】循环链表的实现及基本操作（可直接运行）
treesorshining的博客
07-12 506
总目录 由于循环链表尾部并未指向空，而是指向头指针。循环单链表尾结点指针域指向头结点；循环双链表尾结点后继指针指向头结点，头结点前驱指针指向尾节点。故而各类基本操作与之前单链表、双链表基本操作相差不大，主要就是在于对尾结点的处理问题，之前非循环链表尾结点指向空，如果要执行插入、删除等可能需要对后继结点取指针域的操作会导致报错，而循环链表就没有这个问题，因为它尾结点并非指向空。综上，在此处不会给出全部的基本操作，仅给出简单插入和删除作为示例，可与博主之前实现单链表、双链表的文章参照查看，改动主要是对于尾结点的
2024年王道考研数据结构线性表—顺序表题目
qq_51536841的博客
07-13 631
24王道考研复习书的题
【数据结构】【王道】【线性表】双链表的实现及基本操作（可直接运行）
treesorshining的博客
07-12 653
总目录 1.2 初始化 1.3 判空 1.4 结点后插入_1 1.5 结点后插入_2 1.6 按位序插入 1.7 删除后继结点 1.8 按位查找 1.9 按值查找 1.10 销毁链表 1.11 输出所有链表元素 2.完整代码 3.运行截图
考研数据结构——线性表（顺序表&链表）最全！含代码！
给你糖ya的博客
03-20 1046
和顺序表相比，单链表是链式存储而不是顺序存储，即在内存中是离散存储的，每个结点除了存放数据元素外还要存放指向下一个节点的指针；不需要大片连续空间，改变容量方便；但是不可随机存取，要耗费一定空间存放指针。typedef struct DNode { //定义单链表的结点类型int data;//每个结点存放一个数据元素//prior指向前驱结点，next指向后继结点单链表的各个结点离散地分布在内存中的各个地方；静态链表会分配一整块连续的内存空间来存放各个结点，各个结点不一定连续但都在这一块内存中。
王道数据结构笔记【线性表(顺序表、链表）】
Dys_debug的博客
08-18 1196
2022年7月整理
王道数据结构-线性表中顺序表的一些综合应用题 王道操作系统-PV操作综合大题总结
12-31
在本文中，我们将探讨线性表中顺序表的几种综合应用问题，以及如何使用C++来实现这些操作。顺序表是一种基本的数据结构，它在线性表中存储元素的方式是连续的内存空间。这里我们主要关注如何在顺序表中进行高效地...
王道计算机考研数据结构线性表代码
10-03
王道计算机考研数据结构线性表代码 顺序表 单链表 双链表 循环链表 静态链表 带头节点和不带头节点链表的初始化 链表的节点增加、删除节点、销毁链表、双链表正向打印逆向打印！ 静态链表的初始化以及插入操作
线性表.zip
09-09
在本压缩包"线性表.zip"中，包含的是王道数据结构教程中关于线性表的基本操作的代码实现，以及针对线性表的典型问题的解法。这些实现是在Devc++环境下编写的，这是一款免费的C++集成开发环境，适合初学者学习和实践...
王道第二章 -线性表的操作
07-16
线性表是数据结构中的基础概念，它是一个包含相同数据类型的有限序列，具有明确的前后顺序。线性表的特点包括：表长n大于等于0，空表时n为0；每个元素除了第一个之外都有唯一的直接前驱，除了最后一个之外都有唯一的...
王道计算机考研 数据结构 笔记（包括PPT内容和笔记内容）
10-12
本资源摘要信息总结了数据结构的基本概念、存储结构、算法设计、时间复杂度分析、线性表、顺序表、链表、插入和删除等知识点。这些知识点是计算机科学的基础，理解这些知识点对于计算机科学的学习和应用具有重要意义...
【数据结构】单链表的增删改查
2302_78914800的博客
07-25 753
链表是有序的列表，但是它在内存中是如下存储的：①链表以节点的方式进行存储，是链式存储的②每个节点包含 data 域、next 域：指向下一节点③链表的各个节点不一定是连续存放的④链表分为有头节点的链表和没有头节点的链表head节点1.不存放具体数据2.作用就是表示单链表头。
c语言（7.23）
fhgfyrsg的博客
07-23 633
【代码】c语言（7.23）
Linux嵌入式学习——数据结构——线性表的链式结构
m0_71703182的博客
07-24 773
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
《Java初阶数据结构》----7.＜优先级队列PriorityQueue＞
最新发布
m0_73456341的博客
07-25 832
本篇博客主要讲解Java基础语法中的 优先级队列、PriorityQueue的特性、常用方法介绍、编程题练习
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Silver Star

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

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

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

打赏作者

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

抵扣说明：

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

余额充值