顺序表的实现与基本操作

最新推荐文章于 2022-12-15 11:52:45 发布
最新推荐文章于 2022-12-15 11:52:45 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： c++ c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50330658/article/details/126727871
版权
本文介绍了C和C++两种语言实现顺序表的操作，包括静态分配和动态分配方式的初始化，以及顺序表的插入、删除和查找功能。动态分配方式中，通过`malloc`函数申请内存，并提供了动态增加顺序表长度的函数。示例代码详细展示了如何在顺序表中进行元素操作，并给出了相应的运行结果。
摘要由CSDN通过智能技术生成

1 顺序表定义

1.1 顺序表定义（静态分配）

    1. c语言实现
#include <stdio.h>
#define MaxSize 10 //定义最大长度
// #define ElemType int
typedef int ElemType;
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;    //顺序表初始长度为0
}
// Sqlist InitList(Sqlist *L){
//     for (int i = 0; i < MaxSize; i++)
//         L->data[i]=0;   //将所有数据元素设置为默认初始值
//     L->length = 0;    //顺序表初始长度为0
//     return *L;
// }

int main(){
    Sqlist L;   //声明一个顺序表
    InitList(&L);    //初始化顺序表,通过传顺序表的地址初始化顺序表
    //打印顺序表
    for(int i = 0; i < MaxSize; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    return 0;
}
    1. c++实现
#include <stdio.h>
#define ElemType int
#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;    //顺序表初始长度为0
}
// Sqlist InitList(Sqlist &L){
//     for (int i = 0; i < MaxSize; i++)
//         L.data[i]=0;   //将所有数据元素设置为默认初始值
//     L.length = 0;    //顺序表初始长度为0
//     return L;
// }
int main(){
    Sqlist L;   //声明一个顺序表
    InitList(L);    //初始化顺序表
    //打印顺序表
    for(int i = 0; i < MaxSize; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    return 0;
}

注意：C语言无&引用类型，所以采用结构体指针。
运行结果如下：
顺序表初始化

1.2 顺序表定义（动态分配）

  • c++实现
#include <stdio.h>
#include <stdlib.h>
#define ElemType int
#define InitSize 10 //默认最大长度
typedef struct 
{
    ElemType *data; //指示动态分配数组的指针
    int MaxSize;    //顺序表的最大容量
    int length; //顺序表当前长度
}Sqlist;    //顺序表类型定义

//初始化顺序表
void InitList(Sqlist &L){
    //用malloc函数申请一片连续的存储空间
    L.data = (int *)malloc(InitSize*sizeof(int));
    for (int i = 0; i < InitSize; i++)
        L.data[i]=0;   //将所有数据元素设置为默认初始值0
    L.length = 0;    //顺序表初始长度为0
    L.MaxSize = InitSize;
}
//增加动态数组的长度
void IncreaseSize(Sqlist &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);
}

int main(){
    Sqlist L;   //声明一个顺序表
    InitList(L);    //初始化顺序表
    //打印顺序表
    for(int i = 0; i < InitSize; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    IncreaseSize(L,5);
    printf("++++++++++\n");
    for(int i = 0; i < L.MaxSize; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    return 0;
}

运行效果图如下：

  • 初始化
    在这里插入图片描述
  • 动态增加5的长度
    在这里插入图片描述

2 顺序表插入

  • C++代码如下：
#include <stdio.h>
#include <stdlib.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;    //顺序表初始长度为0
}

bool ListInsert(SqList &L,int i,int e){
    if (i<1||i>L.length+1)//判断i范围是否有效,末尾可以插入
        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;    
}

int main(){
    SqList L;
    InitList(L);
    //打印初始化顺序表
    for(int i = 0; i < MaxSize; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    printf("执行插入操作后\n");
    ListInsert(L,1,1);//初始化将表长度置为0；只能从第一个位置插入
    ListInsert(L,2,2);
    ListInsert(L,3,3);
    ListInsert(L,4,4);
    ListInsert(L,5,3);

    //打印插入操作后的顺序表
    for(int i = 0; i < MaxSize; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    return 0;
}
  • 运行效果图如下：
    在这里插入图片描述

3 顺序表删除

  • C++代码如下：
#include <stdio.h>
#include <stdlib.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;    //顺序表初始长度为0
}

bool ListInsert(SqList &L,int i,int e){
    if (i<1||i>L.length+1)//判断i范围是否有效,末尾可以插入
        return false;
    if(L.length >= MaxSize)//当前存储空间已满，不能插入
        return false;
    for(int j=L.length;j>=i;j--)//末尾插入不移动元素
        L.data[j]=L.data[j-1];//将第i个元素及之后的元素后移
    L.data[i-1]=e;//在位置i处存放e
    L.length++;//长度加一
    return true;    
}

bool ListDelete(SqList &L,int i, int &e){
    if(i<1||i>L.length)//判断i范围是否有效
        return false;
    e = L.data[i-1]; //将被删除的元素赋给e
    for(int j=i;j<L.length;j++)
        L.data[j-1] = L.data[j];//将第i个位置后的元素前移
    L.length--;//线性表长度减一
    return true;
}
int main(){
    SqList L;
    InitList(L);
    //打印初始化顺序表
    for(int i = 0; i < MaxSize; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    printf("执行插入操作后\n");
    ListInsert(L,1,1);//初始化将表长度置为0；只能从第一个位置插入
    ListInsert(L,2,2);
    ListInsert(L,3,3);
    ListInsert(L,4,4);
    ListInsert(L,5,5);
    //打印插入操作后的顺序表
    for(int i = 0; i < L.length; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    printf("执行删除操作后\n");
        int e = -1;
    if(ListDelete(L,3,e))
        printf("已删除第3个元素，删除元素的值为%d\n",e);
    else
        printf("位序i不合法，删除失败！\n");
    //打印插入操作后的顺序表
    for(int i = 0; i < L.length; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    return 0;
}
  • 运行效果图如下：
    在这里插入图片描述

4 顺序表查找

  • C++代码如下：
#include <stdio.h>
#include <stdlib.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;    //顺序表初始长度为0
}
//插入元素
bool ListInsert(SqList &L,int i,int e){
    if (i<1||i>L.length+1)//判断i范围是否有效,末尾可以插入
        return false;
    if(L.length >= MaxSize)//当前存储空间已满，不能插入
        return false;
    for(int j=L.length;j>=i;j--)//末尾插入不移动元素
        L.data[j]=L.data[j-1];//将第i个元素及之后的元素后移
    L.data[i-1]=e;//在位置i处存放e
    L.length++;//长度加一
    return true;    
}
//删除元素
bool ListDelete(SqList &L,int i, int &e){
    if(i<1||i>L.length)//判断i范围是否有效
        return false;
    e = L.data[i-1]; //将被删除的元素赋给e
    for(int j=i;j<L.length;j++)
        L.data[j-1] = L.data[j];//将第i个位置后的元素前移
    L.length--;//线性表长度减一
    return true;
}
//按位查找
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;
}
int main(){
    SqList L;
    InitList(L);
    //打印初始化顺序表
    for(int i = 0; i < MaxSize; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    printf("执行插入操作后\n");
    ListInsert(L,1,1);//初始化将表长度置为0；只能从第一个位置插入
    ListInsert(L,2,2);
    ListInsert(L,3,3);
    ListInsert(L,4,4);
    ListInsert(L,5,5);
    //打印插入操作后的顺序表
    for(int i = 0; i < L.length; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    printf("执行删除操作后\n");
        int e = -1;
    if(ListDelete(L,3,e))
        printf("已删除第3个元素，删除元素的值为%d\n",e);
    else
        printf("位序i不合法，删除失败！\n");
    //打印插入操作后的顺序表
    for(int i = 0; i < L.length; i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    //查找第3位元素
    printf("第3位元素值为：%d\n",GetElem(L,3));
    //查找元素值为4的元素位序
    printf("值为4的元素位序:%d\n",LocateElem(L,4));
    return 0;
}
  • 运行效果图如下：
    在这里插入图片描述
dlhto
关注
专栏目录
【数据结构】顺序表/链表的运算及实现
weixin_44799923的博客
12-01 1057
数据结构的基础知识，包括顺序表/链表运算及实现
顺序表实现基本操作.c
04-30
耽误您时间了。 问题：可能会出现乱码，不过这些都不是问题。 描述：我的代码里面插入、删除、查询等基本操作。
顺序表的各种基本运算
03-17
编写一个程序，实现顺序表的各种基本运算，并在此基础上完成以下功能: 1) 初始化顺序表； 2) 依次采用尾插入法插入a,b,c,d,e元素； 3) 输出顺序表L； 4) 输出顺序表L的长度； 5) 判断顺序表L是否为空； 6) 输出顺序表L的第三个元素； 7) 输出元素a的位置； 8) 在第4个元素位置上插入f元素； 9) 输出顺序表L； 10) 删除L的第3个元素； 11) 输出顺序表L； 12) 释放顺序表。
顺序表的基本操作与实现
Vagrant_pursue的博客
10-19 886
前言 顺序表存储结构容易实现随机存取线性表的第i个数据元素的操作，但在插入或删除操作时要移动大量的数据元素，适合数据相对稳定的线性表。 提示：以下是顺序表的基本操作和实现代码，下面案例可供参考 1.头文件 代码如下（示例）： #include<stdio.h> #include<stdlib.h> #include<math.h> #define FALSE 0 #define TRUE 1 #define ERROR 0 #define OK 1 //线性表的存储
数据结构顺序表的具体实现与运算
qq_42443562的博客
09-18 614
一、线性表的顺序存储实现 1、描述顺序表需要几个属性 存储空间起始的位置：Data 存储的容量:MaxSize 当前长度:last(=n-1) 2、顺序表的数据类型描述 typedef struct{ DataType data[MaxSize]； int last； }SeqList； 说明 ① 若 把顺序表定义为 SeqList L; 则 表长表示为 L.last+1...
【数据结构】二、顺序表的定义和基本操作的实现
最新发布
Yikou的个人技术博客
12-15 811
顺序表的定义，基本操作详细讲解，一文拿下顺序表！
c语言实现顺序表的基本操作
01-20
数据结构顺序表操作 代码如下:#include <stdio>#include <stdlib>#include <malloc>#define LIST_INIT_SIZE 100#define LISINCREMENT 10#define ElemType int#define Status inttypedef struct Sq{ ElemType *elem...
顺序表的实现及基本操作_gas3v5_顺序表的实现及基本操作_
10-02
（ 1 ）创建顺序表 21 、 18 、 30 、 75 、 42 、 56 ，并输出顺序表中的各元素值。（ 2 ）在顺序表的第 3 个位置插入 67 ，并输出此时顺序表中的各元素值。（ 3 ）删除顺序表中的第 6 个数据元素，并输出此时顺序...
实验2.0_顺序表的实现及基本操作_
09-29
创建有若干个元素（可以是整型数值）的顺序表，实现对顺序表的初始化，对已建立的顺序表插入操作、删除操作、遍历输出顺序表。 要求各个操作均以函数的形式实现，在主函数中调用各个函数实现以下操作： （1）创建...
顺序表的实现及其基本操作
Bit_Dong的博客
06-06 1486
线性表的顺序存储又称顺序表。它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。
C++实现顺序表的各种基本运算
henry594xiaoli的博客
03-20 2709
领会顺序表存储结构和掌握顺序表中的各种基本运算算法设计 实现顺序表的各种基本运算和整体建表算法（假设顺序表的元素类型 ElemType 为 char）
顺序表基本运算的实现
孔武的博客
06-19 513
#include&lt;stdio.h&gt;#include&lt;malloc.h&gt;#define  Maxsize 50typedef int ElemType;typedef struct{ ElemType data[Maxsize];    int length;}SqList;//初始化顺序表void InitList(SqList *&amp;L){      L=(SqLi...
顺序表上基本运算的实现
weixin_30856725的博客
03-06 207
1 /* 2 程序功能：顺序表上基本运算的实现 3 1.顺序表L的初始化 4 2.创建一个顺序表L 5 3.求顺序表L的长度 6 4.按序号取顺序表L中的元素 7 5.在顺序表L中查找元素e的位置 8 6.在顺序表L中插入新元素 9 7.在顺序表L中删除元素 10 8.将线性表中元素输出 11 9.顺序表应用举例（求顺序表A和B的交集...
顺序表的基本操作（c++实现）
dingding_coding的博客
11-17 801
1. 头文件LinearList #ifndef _LINEARLIST_H_ #define _LINEARLIST_H_ #include<iostream> using namespace std; template<class T> //T为数据类型 class LinearList //模板名 { private: int length; //当前数组元素个数 int Maxsize; ...
10-顺序表的基本运算实现
网络安全
05-28 2016
1. 顺序表的存储实现   根据前面讲过的顺序表存储类型可知，当要设计顺序表的存储结构时，那么顺序表的数据类型定义如下所示： ypedef int ElemType; //数据元素的类型是int整型 typedef struct { ElemType data[MaxSize]; int length; } SqList;   数据在数组中存储是从最小下标0开始的，我们可...
顺序表的基本运算——入门
qq_63179750的博客
09-21 1941
*****顺序表的基本运算****兄弟姐妹看过来>.
数据结构---顺序表基本操作的实现
m0_71891569的博客
09-19 1311
顺序表基本操作的实现（初始化、输入、输出、删除、查找、插入、合并）。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值