静态数组顺序表

最新推荐文章于 2025-02-10 16:36:37 发布
最新推荐文章于 2025-02-10 16:36:37 发布
阅读量680 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/adorable_/article/details/78720919
版权

实现基于静态数组的顺序表的以下基本操作:
1. 初始化
2. 尾插
3. 尾删
4. 头插
5. 头删
6. 读任意位置元素
7. 修改任意位置元素
8. 查找指定元素值的下标
9. 在任意位置插入元素

实现在顺序表中增删查改需注意以下几点：
  1.初始化时不用将所有元素赋值为0，那样会降低代码效率
  2.插入元素时应该判断顺序表是否已经满了
  3.删除元素时只需将需删除的元素覆盖，使之无效即可

以下是实现代码：

SeqList.h

#pragma once     //防止头文件重复包含

#include <stdlib.h> 

#define SeqListMaxNum 1000    //数组最大元素个数

typedef char SeqListType;    //重定义类型
typedef struct SeqList
{
    SeqListType SeqListArr[SeqListMaxNum];
    size_t size;      //元素个数
}SeqList;

void SeqListInit(SeqList* seq);       //初始化顺序表
void SeqListPrint(SeqList* seq, char* ch);      //打印顺序表

void SeqListPushEnd(SeqList* seq, SeqListType value);     //尾插一个元素
void SeqListPopEnd(SeqList* seq);           // 尾删一个元素

void SeqListPushStart(SeqList* seq, SeqListType value);     //头插一个元素
void SeqListPopStart(SeqList* seq);        //头删一个元素

void SeqListPushPosition(SeqList* seq, size_t pos, SeqListType value);    //在下标为pos处插入元素
void SeqListPopPosition(SeqList* seq, size_t pos);               //删除下标为pos的元素

void SeqListSetList(SeqList* seq, size_t pos, SeqListType value);     //修改下标为pos的元素

SeqListType SeqListGetList(SeqList* seq, size_t pos);       //读下标为pos的元素
size_t SeqListGetpos(SeqList* seq, SeqListType value);      //查找value元素值的下标

SeqList.c

#include "SeqList.h"
#include <stdio.h>
#include <assert.h>

//初始化顺序表
void SeqListInit(SeqList* seq)
{
    assert(seq);
    seq->size = 0;
}

//打印顺序表
void SeqListPrint(SeqList* seq, char* ch)
{
    assert(seq);
    int i = 0;
    printf("%s\n", ch);
    for (i = 0; i < seq->size; i++)
    {
        printf("下标为%d的元素是：[%c]\n",i,seq->SeqListArr[i]);
    }
    printf("size = %ld\n\n", seq->size);
}

//尾插一个元素
void SeqListPushEnd(SeqList* seq, SeqListType value)
{
    assert(seq);
    if (seq->size >= SeqListMaxNum)
    {
        printf("顺序表已满，无法插入！\n\n");
        return;
    }
    else
    {
        seq->SeqListArr[seq->size] = value; 
        seq->size++;
    }
}

// 尾删一个元素
void SeqListPopEnd(SeqList* seq)
{
    assert(seq);
    if (seq->size == 0)
    {
        printf("顺序表为空表，无法删除！\n\n");
        return;
    }
    else
    {
        seq->size--;
    }
}

//头插一个元素
void SeqListPushStart(SeqList* seq, SeqListType value)
{
    assert(seq);
    if (seq->size >= SeqListMaxNum)
    {
        printf("顺序表已满，无法插入！\n\n");
        return;
    }
    else
    {
        int i = seq->size - 1;
        for (; i >= 0; i--)
        {
            seq->SeqListArr[i + 1] = seq->SeqListArr[i];    //将所有元素后移，为头插元素留出空间
        }
        seq->SeqListArr[0] = value;
        seq->size++;
    }
}

//头删一个元素
void SeqListPopStart(SeqList* seq)
{
    assert(seq);
    if (seq->size == 0)
    {
        printf("顺序表为空表，无法删除！\n\n");
        return;
    }
    else
    {
        int i = 0;
        for (; i < seq->size - 1;i++)
        {
            seq->SeqListArr[i] = seq->SeqListArr[i+1];     //删除一个元素只需将其覆盖掉即可
        }
        seq->size--;
    }
}

//在下标为pos处插入元素
void SeqListPushPosition(SeqList* seq, size_t pos, SeqListType value)
{
    assert(seq);
    if (seq->size >= SeqListMaxNum)
    {
        printf("顺序表已满，无法插入！\n\n");
        return;
    }
    else if (pos >= seq->size)
    {
        printf("非法坐标！\n\n");
        return;
    }
    else
    {
        int i = seq->size - 1;
        for (; i >= pos; i--)
        {
            seq->SeqListArr[i + 1] = seq->SeqListArr[i];      //将pos下标后所有元素后移，为插入元素留出空间
        }
        seq->SeqListArr[pos] = value;
        seq->size++;
    }
}

//删除下标为pos的元素
void SeqListPopPosition(SeqList* seq, size_t pos)
{
    assert(seq);
    if (seq->size == 0)
    {
        printf("顺序表为空表，无法删除！\n\n");
        return;
    }
    else if (pos >= seq->size)
    {
        printf("非法坐标！\n\n");
        return;
    }
    else
    {
        int i = pos;
        for (; i < seq->size - 1; i++)
        {
            seq->SeqListArr[i] = seq->SeqListArr[i + 1];
        }
        seq->size--;
    }
}

//修改下标为pos的元素
void SeqListSetList(SeqList* seq, size_t pos, SeqListType value)
{
    assert(seq);
    if (pos >= seq->size)
    {
        printf("非法坐标！\n\n");
        return;
    }
    else
    {
        seq->SeqListArr[pos] = value;
    }
}

//读下标为pos的元素
SeqListType SeqListGetList(SeqList* seq, size_t pos)
{
    assert(seq);
    if (pos >= seq->size)
    {
        printf("非法坐标！\n\n");
        return -1;
    }
    else
    {
        return seq->SeqListArr[pos];
    }
}

//查找value元素值的下标
size_t SeqListGetpos(SeqList* seq, SeqListType value)
{
    assert(seq);
    int i = 0;
    for (; i < seq->size; i++)
    {
        if (seq->SeqListArr[i] == value)
        {
            return i;
        }
    }
    return -1;
}

Test.c

//测试代码
#include "SeqList.h"
#include <stdio.h>
#include <windows.h>

//测试初始化顺序表
void TestSeqListInit()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPrint(&seq,"*****初始化顺序表*****");
}

//测试尾插一个元素
void TestSeqListPushEnd()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    SeqListPrint(&seq, "*****尾插四个元素至顺序表*****");
}

// 测试尾删一个元素
void TestSeqListPopEnd()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    SeqListPopEnd(&seq);
    SeqListPrint(&seq, "*****在顺序表中尾删一个元素*****");
    printf("空表情况：\n");
    SeqListInit(&seq);
    SeqListPopEnd(&seq);
}

//测试头插一个元素
void TestSeqListPushStart()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    SeqListPushStart(&seq, 'e');
    SeqListPrint(&seq, "*****头插一个元素至顺序表*****");
}

//测试头删一个元素
void TestSeqListPopStart()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    SeqListPopStart(&seq);
    SeqListPrint(&seq, "*****在顺序表中头删一个元素*****");
    printf("空表情况：\n");
    SeqListInit(&seq);
    SeqListPopStart(&seq);
}

//测试在下标为pos处插入元素
void TestSeqListPushPosition()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    SeqListPushPosition(&seq, 2, 's');
    SeqListPrint(&seq, "*****在顺序表中指定位置插入一个元素*****");
    printf("非法坐标情况(在下标为20的位置插入元素)：\n");
    SeqListPushPosition(&seq, 20, 'r');
}

//测试删除下标为pos的元素
void TestSeqListPopPosition()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    SeqListPopPosition(&seq, 2);
    SeqListPrint(&seq, "*****在顺序表中指定位置删除一个元素*****");
    printf("非法坐标情况(删除下标为8的元素)：\n");
    SeqListPopPosition(&seq, 8);
}

//测试修改下标为pos的元素
void TestSeqListSetList()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    SeqListSetList(&seq, 1, 'o');
    SeqListPrint(&seq, "*****在顺序表中修改指定位置的元素*****");
    printf("非法坐标情况(修改下标为10的元素)：\n");
    SeqListSetList(&seq, 10,'k');
}

//测试读取下标为pos的元素
void TestSeqListGetList()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'e');
    SeqListPushEnd(&seq, 'f');
    SeqListPushEnd(&seq, 'g');
    SeqListPushEnd(&seq, 'h');
    SeqListPrint(&seq, "*****在顺序表中读取指定位置元素*****");
    char ch = SeqListGetList(&seq, 1);
    printf("下标为1的元素为%c\n", ch);
    printf("非法坐标情况(读取下标为6的元素)：\n");
    SeqListGetList(&seq, 6);
}

//测试查找value元素值的下标
void TestSeqListGetpos()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'e');
    SeqListPushEnd(&seq, 'f');
    SeqListPushEnd(&seq, 'g');
    SeqListPushEnd(&seq, 'h');
    SeqListPrint(&seq, "*****在顺序表中读取指定位置元素下标*****");
    size_t pos = SeqListGetpos(&seq, 'h');
    printf("h元素的下标为%ld\n", pos);
    printf("非法情况(读取元素W的下标)：\n");
    size_t pos1 = SeqListGetpos(&seq, 'W');
    printf("W元素的下标为%ld，坐标非法！\n\n", pos1);
}

int main()
{
    TestSeqListInit();
    TestSeqListPushEnd();
    TestSeqListPopEnd();
    TestSeqListPushStart();
    TestSeqListPopStart();
    TestSeqListPushPosition();
    TestSeqListPopPosition();
    TestSeqListSetList();
    TestSeqListGetList();
    TestSeqListGetpos();
    system("pause");
    return 0;
}

结果如下：
默认数组中有4个元素（a，b，c，d）

1. 初始化
结果

2. 尾插
结果

3. 尾删
结果

4. 头插
结果

5. 头删
结果

6. 读任意位置元素
结果

7. 修改任意位置元素
结果

8. 查找指定元素值的下标
结果

9. 在任意位置插入元素
结果

动态数组与静态数组-内存管理与性能对比
一键难忘的博客
11-21 2745
在数据结构的选择上，动态数组和静态数组各有优缺点。静态数组适合用于内存需求固定且性能要求较高的场景，但在数据量大或不确定的情况下，可能会导致内存浪费或无法存储更多的数据。而动态数组则更为灵活，能够根据需要动态扩容，但其性能和内存管理较为复杂，扩容操作可能导致性能下降。了解两者的优劣势，以及在具体场景中的适用性，能帮助开发者做出最适合的选择。
顺序表（数组篇）
weixin_50749712的博客
02-08 1019
顺序表（数组篇）一、顺序表1.1 什么是顺序表二、所需要的结构体2.1 数据结构体2.2 比较准则结构体多一个键值2.3 顺序表的结构体三、创建链表四、插入数据4.1 插入4.2 更改申请的内存大小五、删除数据六、打印函数七、主函数八、调试结果 一、顺序表 1.1 什么是顺序表 /* 1.有序性 根据排序准则进行的排序存储 struct MM { char *name; int age; int num; } 为数组构建准则 struct data { int index
顺序表：数组
韶言大雅
08-07 508
数组 实际应用中以表的形式出现，数组中的元素是同一类型的。 一维数组又称向量，二维数组又称矩阵。 多维数组通过行优先或列优先描述，可以映射为一维数组。 在数组中第i个位置插入值为x的新元素 template <class T> boolean Array<T>::Insert(T&x,int i) { //在数组中第i个位置插入值为x的新元素 //若插入成功，则返回TRUE,否则返回FALSE if(ArrayLength==ArraySize) /
顺序表的静态建立
weixin_34072458的博客
12-24 155
1 #include<stdio.h> 2 #define MaxSize 100 3 typedef int Elemtype; 4 typedef struct{ 5 Elemtype data[MaxSize]; 6 int length; 7 }SqList; 8 9 /*插入元素操作*/ 10 bool ListIns...
C语言中的动态数组与静态数组的差异
最新发布
set_one的博客
02-10 722
静态数组是在编译时就确定了大小，并且在程序执行过程中该大小不能改变的数组。int arr[5];// 定义一个大小为5的整型静态数组动态数组是在程序运行时分配内存的数组，数组的大小可以在运行时根据需要进行调整。动态数组通常使用malloccallocrealloc等函数进行内存分配和管理。C语言中的静态数组和动态数组各有优缺点。静态数组简单高效，但缺乏灵活性；动态数组灵活强大，但需要程序员手动管理内存。在实际开发中，选择静态数组还是动态数组取决于具体的需求和程序设计的复杂度。
顺序表（数组型）
qq_65281024的博客
11-16 551
数据结构基础
数据结构——顺序表（静态数组）实现
qq_44887899的博客
07-24 267
参考王道考研的视频 #include<stdio.h> #include<iostream> using namespace std; #define Maxsize 50 //线性表的最大长度，一旦定下，使用中不能更改 typedef struct { int data[Maxsize]; //定义一个表，这个例子我用了int类型的 int length; //表中目前存在几个元素 }Sqlist; //初始化一个顺序表 void InitList(Sqlist &am
C++静态数组顺序表详解与操作实现
本文将深入探讨如何在C++中使用基于静态...通过这些核心操作，本文提供了一个实用的C++静态数组顺序表实现，适用于需要快速访问和插入/删除元素的场景。理解这些概念和代码有助于开发者在实际项目中高效地管理数据。
C++实现基于静态数组的顺序表
08-19
C++实现基于静态数组的顺序表 本文将详细介绍基于静态数组的顺序表的实现，包括基本操作的实现和示例代码。 一、顺序表的基本概念 顺序表是一种常见的数据结构，用于存储和管理数据。它由一个静态数组和一个size...
C++实现静态数组顺序表操作详解
"C++实现了一个基于静态数组的顺序表数据结构，提供了多种操作方法，如初始化、插入、删除、查找、修改等。顺序表的最大元素个数定义为maxsize，初始设定为1000。顺序表由一个结构体表示，包含一个seqType类型的数组...
顺序表——简单实现（静态数组）
Devil_Net的博客
03-14 531
实现基于静态数组的顺序表的以下基本操作: 1. 初始化 2. 尾插 3. 尾删 4. 头插 5. 头删 6. 读任意位置元素 7. 修改任意位置元素 8. 查找指定元素值的下标 9. 在任意位置插入元素实现环境：Centos6.5 vim编辑器       大体的思路，头插尾插主要是建立在数组的最后位，而数组的下标是以0开始的，即给其数组的静态空间加上尾插的个数，而将尾插的数依次赋给数组的后边，尾...
创建一个静态的顺序表存放整数
04-17
创建一个静态的顺序表存放整数。大小为10.完成以下的操作输入6个整数，1.打 印出顺序表中的内容，并显示表中剩余的空间个数。在顺序表中的第3个位置插入元素O.2.打印出顺序表中的内容，并显示表中剩余的空间个数。再试图向表中第11个位置插入整数0,3.程序提示超出范围。4.删除表中第6个元素，打印出顺序表中的内容，并显示表中剩余的空间个数。 二：编写一程序，动态地创建一个顺序表。要求顺序表初始长度为20,向顺序表中输 入15个整数，并打印出来: 再删除顺序表中的第5个元素。打印出删除后的结果。
数据结构---实现基于静态数组的顺序表的基本操作
啦~啦~啦~的博客
12-10 708
实现基于静态数组的顺序表的以下基本操作: 首先先定义一个结构体类型seqlist（ arr【】，size（有效的元素个数）），预定义一个数组的最大长度，将整型数据变量typedef为datatype，为了以后在插入删除别的类型时方便修改 初始化 void InitSeq(seqlist *s) 将数组的size置为0，不需要给每个元素进行赋值， 尾插 void SeqLis...
顺序表(数组)实现
hxy1625309592的博客
12-15 3455
1.1 基本介绍 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。 数组是最常见的顺序表，数组(Array)是有限个相同类型的变量所组成的有序集合，数组中的每一个变量被称为元素。数组是最为简单、最为常用的数据结构。 1.2 相关原理分析 1、基本概念 数组用一组连续的内存空间来存储一组具有相同类型的
顺序表与数组
热门推荐
Wayne_y的博客
04-28 1万+
顺序表是在计算机内存中以数组的形式保存的线性表。顺序表是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表，顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。线性表采用指针链接的方式存储就称之为链表。线性表是从逻辑结构的角度来说的，除了头和尾之外，它的每一个元素都只有一个前驱元素和一个后驱元素。各种队列（单向、双向、循环队列），栈等都...
顺序表 (数组) 详解
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
10-16 2581
1. 顺序表的`位序`和`元素下标`是两个不同概念，位序从1开始，元素下标从0开始。位置为i的元素，它的下标为i-1 2.当i的值在[1，L->length+1]区间内时，都是有效的插入位置。1表示待插入元素取代第1个元素，L->length+1表示插入到最后一个元素的后面。<font color=blue>记得，i是位序，不是下标，它的有效插入位置是(i < 1 || i > L->length + 1)，不要写成(i < 0 || i > L->length)，i为下标时才是这种写法。
静态数组的顺序表
雪碧柠七的博客
03-13 254
实现基于静态数组的顺序表的以下基本操作: 1. 初始化 2. 尾插 3. 尾删 4. 头插 5. 头删 6. 读任意位置元素 7. 修改任意位置元素 8. 查找指定元素值的下标 9. 在任意位置插入元素seqlist.h                                                     1 #pragma once 2 #include &lt;stdi...
顺序表
weixin_44546372的博客
03-13 1805
设计一个静态数组存储结构的顺序表类，要求编程实现如下任务：建立一个线性表，首先依次输人数据元素1，2，3，…，10，然后删除数据元素6，最后依次显示当前线性表中的数据元素。要求采用顺序表实现，假设该顺序表的数据元素个数在最坏情况下不会超过50个。 #include&lt;iostream&gt; using namespace std; const int MaxSize=100; templat...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值