顺序表的构造及功能

已于 2023-03-01 21:26:57 修改
阅读量786 收藏 2
点赞数
分类专栏： 顺序表 线性表 文章标签： c语言 c++ Powered by 金山文档
于 2023-02-27 22:26:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56627079/article/details/129249842
版权

定义

顺序表是一种随机存储都结构，其特点是表中的元素的逻辑顺序与物理顺序相同。

假设线性表L存储起始位置为L(A)，sizeof(ElemType)是每个数据元素所占的存储空间的大小，则线性表L所对应的顺序存储如下图。

顺序表的优缺点
优点：
随机存储表中的任意元素，其存储位置可以用一个简单、直观的公式来表示。
存储密度高，每个结点只存储数据元素。

缺点：
在做插入或删除元素时，需要移动大量元素。
操作相对复杂，必然导致空间的浪费。

静态顺序表的构建

在静态分配时，由于数组的大小和空间事先已经固定好，一旦空间占满，再加入新的数据就会产生溢出，进而导致进程崩溃。

#define MaxSize 100           //顺序表可能达到的最大长度
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];  //顺序表的元素
    int length;              //当前的长度
}List;                       //顺序表的类型定义

注意：线性表中元素的位置是从1开始的，而数组中的元素的下标是从0开始的。

动态顺表的构建

#define MaxSize 100  //顺序表可能达到的最大长度
typedef int ElemType;
typedef struct{
    ElemType* data;  //存储空间的基址
    int length;      //当前的长度
}List;               //顺序表的结构类型为List

C的初始动态分配语句

list.data = (ElemType*)malloc(sizeof(ElemType)*MaxSize);  //动态开辟空间 （c语言）

C++的初始动态分配语句

list.data = new ElemType[MaxSize];  //动态开辟空间 (c++)

注意：动态分配并不是链式存储，它同样属于顺序存储结构，，物理结构没有变化，依然是随机存储方式，只是分配的空间大小可以在运行时动态决定。

动态顺序表的常见操作

插入

插入新元素的图解

void Insert(List *list, int index, int value){  //插入(在第index位置插入value)
    if (index < 1 || index > list->length + 1){  //判断范围是否有效
        printf("插入失败（位置输入错误）！\n");
        return;
    }
    if (list->length >= MaxSize){   //空间已满，无法插入
        printf("插入失败（顺序表已满）！\n");
        return;
    }
    for (int i = list->length; i >= index; i--){  //将第index个元素及之后的元素后移
        list->data[i] = list->data[i - 1];
    }
    list->data[index - 1] = value;  //将位置index放入value
    list->length++;  //线性表长度加一
    printf("插入成功！\n");
    return;
}
线性表插入算法的平均时间复杂度为O(N)。

取值

根据下标来查找元素

void GetElem(List list, int index){  //取值(用下标找元素)
    if (index >= 0 && index < list.length){
        printf("要查找的第%d个元素是：%d\n", index, list.data[index - 1]);
    }
    else{
        printf("输入的值有误！！\n");
    }
}

查找

根据所给的元素来遍历顺序表来寻找

void LocateElem(List list, int value){ //查找(用值找下标)
    for (int i = 0; i < list.length; i++){
        if (value == list.data[i]){
            printf("%d是本表中的第%d元素\n", value, i + 1);
            return;
        }
    }
    printf("找不到该元素\n");
    return;
}
线性表按值查找算法的平均时间复杂度为O(N)。

删除

删除元素的图解

void Delete(List *list, int index){ //删除(删除指定的第几个元素)
    if (index < 1 || index > list->length) {  //判断index的范围是否有效
        printf("删除失败（输入的数值有误）！\n");
        return;
    }
    for (int i = index - 1; i < list->length - 1; i++){  //将第index个位置后的元素前移
        list->data[i] = list->data[i + 1];
    }
    list->length--;  //线性表长度减一
    printf("删除成功！\n");
    return;
}
线性表删除算法的平均时间复杂度为O(N)。

销毁
void Clear(List *list){  //销毁
    list->length = 0;   //将顺序表的长度设为0
    free(list->data);   //释放malloc申请的空间
    printf("顺序表已销毁！\n");
}

划分

已第一个元素为界，比它小的元素放在它的前面，比它大的元素放在它的后面

void ListSort(List *list){  //划分(已第一个元素为界，前面比它小，后面比它大)
    int i = 0, j = 0;
    int temp, k;
    temp = list->data[0];
    for (i = 1; i < list->length; i++){
        if (temp > list->data[i]){
            k = list->data[i];
            for (j = i; j > 0; j--){
                list->data[j] = list->data[j - 1];
            }
            list->data[0] = k;
        }
    }
    printf("划分成功！\n");
    return;
}

单值化

单值化类似与去掉顺序表中重复的元素

void DeleteSame(List *list){  //单值化(去掉重复的元素)
    int i = 0;
    while (i < list->length){
        for (int j = i + 1; j <= list->length; j++)
        while (list->data[i] == list->data[j]){
            for (int k = j; k <= list->length; k++)
                list->data[k] = list->data[k + 1];
            list->length--;
        }
        i++;
    }
    printf("单值化完成！\n");
    return;
}

源码

SeqList.h 
#include <stdio.h>
#include <windows.h>
#include <malloc.h>

#define MaxSize 100
typedef int ElemType;
typedef struct{
    ElemType* data;  //动态顺序表
    int length;
}List;

void menu();
void PutList(List list);
void GetElem(List list, int index);
void LocateElem(List list, int value);
void Insert(List *list, int index, int value);
void Delete(List *list, int index);
void DeleteSame(List *list);
void ListSort(List *list);
void Clear(List *list);

SeqList.c 
#include "SeqList.h"

void PutList(List list){  //输出(遍历线性表)
    for (int i = 0; i < list.length; i++){
        printf("%d ", list.data[i]);
    }
    printf("\n");
}

void GetElem(List list, int index){  //取值(用下标找元素)
    if (index >= 0 && index < list.length){
        printf("要查找的第%d个元素是：%d\n", index, list.data[index - 1]);
    }
    else{
        printf("输入的值有误！！\n");
    }
}

void LocateElem(List list, int value){ //查找(用值找下标)
    for (int i = 0; i < list.length; i++){
        if (value == list.data[i]){
            printf("%d是本表中的第%d元素\n", value, i + 1);
            return;
        }
    }
    printf("找不到该元素\n");
    return;
}

void Insert(List *list, int index, int value){  //插入(在第index位置插入value)
    if (index < 1 || index > list->length + 1){
        printf("插入失败（位置输入错误）！\n");
        return;
    }
    if (list->length >= MaxSize){
        printf("插入失败（顺序表已满）！\n");
        return;
    }
    for (int i = list->length; i >= index; i--){
        list->data[i] = list->data[i - 1];
    }
    list->data[index - 1] = value;
    list->length++;
    printf("插入成功！\n");
    return;
}

void Delete(List *list, int index){ //删除(删除指定的第几个元素)
    if (index < 1 || index > list->length) {
        printf("删除失败（输入的数值有误）！\n");
        return;
    }
    for (int i = index - 1; i < list->length - 1; i++){
        list->data[i] = list->data[i + 1];
    }
    list->length--;
    printf("删除成功！\n");
    return;
}

void DeleteSame(List *list){  //单值化(去掉重复的元素)
    int i = 0;
    while (i < list->length){
        for (int j = i + 1; j <= list->length; j++)
        while (list->data[i] == list->data[j]){
            for (int k = j; k <= list->length; k++)
                list->data[k] = list->data[k + 1];
            list->length--;
        }
        i++;
    }
    printf("单值化完成！\n");
    return;
}

void ListSort(List *list){  //划分(已第一个元素为界，前面比它小，后面比它大)
    int i = 0, j = 0;
    int temp, k;
    temp = list->data[0];
    for (i = 1; i < list->length; i++){
        if (temp > list->data[i]){
            k = list->data[i];
            for (j = i; j > 0; j--){
                list->data[j] = list->data[j - 1];
            }
            list->data[0] = k;
        }
    }
    printf("划分成功！\n");
    return;

}

void Clear(List *list){  //销毁
    list->length = 0;
    free(list->data);
    printf("顺序表已销毁！\n");
}

void menu(){  //菜单
    printf("顺序表操作：< P-输出  G-取值  L-查找  I-插入  D-删除  S-单值化  F-划分  X-销毁  Q-退出 >\n");
}

Test.c 
#include "SeqList.h"

int main(){
    List list;
    list.data = (ElemType*)malloc(sizeof(ElemType)*MaxSize);  //动态开辟空间 （c语言）
    //list.data = new ElemType[MaxSize];  //动态开辟空间 (c++)

    printf("线性表中元素的个数：");
    int n = 0;
    scanf("%d", &n);
    list.length = n;
    printf("请输入元素：");
    for (int i = 0; i < n; i++){
        int t = 0;

        //cin >> list.data[i]; //c++输入
        scanf("%d", &t);
        list.data[i] = t;
    } 

    while (1){
        menu();
        char key;
        //cin >> key; //c++输入
        int t = 0;
        getchar();  //释放scanf读取的\n
        scanf("%c", &key);

        switch (key){
        case 'P':
            PutList(list); //输出
            break;

        case 'G':
            printf("要查找第几个元素：");
            scanf("%d", &t);
            GetElem(list,t);  //取值
            break;

        case 'L':
            printf("要查找元素的值为：");
            scanf("%d", &t);
            LocateElem(list,t); //查找
            break;

        case 'I':
            printf("输入要插入的位置和数值：");
            int index, value;
            scanf("%d %d", &index,&value);
            Insert(&list, index, value);  //插入
            break;

        case 'D':
            printf("输入要删除第几个元素：");
            scanf("%d", &t);
            Delete(&list, t);  //删除
            break;

        case 'S':
            DeleteSame(&list); //单值化
            break;

        case 'F':
            ListSort(&list);  //划分
            break;

        case 'X':
            Clear(&list);  //销毁
            break;

        case 'Q':
            exit(0);  //退出
            break;
        }
    }
    system("pause");
}

我会一直在的
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
《数据结构》之静态顺序表
weixin_55687667的博客
08-25 360
这篇博客参考严蔚敏老师《数据结构》第二版 介绍顺序表 我们把按顺序存储结构的线性表叫顺序表，它的特点是：逻辑相邻的数据元素，其物理次序也是相邻的。 这就可以得到顺序表的一个最大的特点：它支持随机访问，让我们想到了数组也是支持随机访问的，下面我们来采用静态存储的数组来表示线性表。 用静态数组表示顺序表 来看定义： typedef struct{ ElemType *elem; int length; }SqList;//用它定义的变量就是一个顺序表 元素类型定义中的Ele.
数据结构 —— 顺序表的结构、功能（增删查改）。
wihkum
07-08 529
数据结构 —— 顺序表
数据结构-静态顺序表
m0_61433144的博客
07-04 1199
顺序表又分为静态顺序表和动态顺序表。对于静态顺序表，在静态分配时，由于数组的大小和空间事先已经固定好了，一旦空间占满，再加入新的数据就会产生溢出，进而导致程序崩溃。
数据结构---顺序表全功能实现
Thinker_serious的博客
12-05 469
顺序表的基本功能：增删查改 我将对每一个接口的功能及实现方法进行介绍 顺序表的结构与数组相似，都可以通过对下标的访问，访问到数据 结构体的创建： 首先定义一个结构体类型，对属性进行添加，我的结构体中定义了一个地址（用来存放动态开辟空间的地址），如果需要的是简单的静态顺序表，可以将指针换做数组使用。接着定义一个capacity，表示容量（用于动态开辟内存的大小），一个size用于记录内存中有效数据的...
C语言---顺序表（详解）---数据结构
weixin_57535054的博客
02-03 3860
我们直接切入主题 1.首先这次写的顺序表的动态的，因为静态的弊端较多。 2.顺序表的功能函数有：初始化 丶申请动态内存 顺序表的头部，尾部的插入和删除 丶在特定位置的插入和删除 丶打印顺序表 丶释放动态内存 需要用到的头文件 我们先给 类型 重命名 原因是：以后还需要用到顺序表时，插入的不一定是你当前使用的类型，如果要改还需要一个个改，非常麻烦，为了以后方便，我们需要改类型时，直接给 类型重命名 这里改，就可以了，更加节省时间。 创建一个结构体里面包含 1指向动态开辟数组的指针。*a.
shunxubiao.rar_顺序表
09-21
本压缩包"shunxubiao.rar_顺序表"包含了实现顺序表功能的C++源代码文件"seqlist1.cpp"，这将帮助我们深入理解顺序表的原理和应用。 顺序表的实现通常涉及以下几个核心概念： 1. **数组**：顺序表的基础是数组，...
C++实现顺序表的方法
09-01
总结起来，本篇C++实现的顺序表`SeqList`类展示了如何利用动态数组实现顺序存储的数据结构，并通过合理的内存管理和操作符重载，提供了一套完整且功能丰富的接口。这样的实现有助于理解数据结构的基本原理，同时也...
数据结构C++顺序表
03-04
- `SeqList(int capacity)`：构造函数，用于初始化顺序表，指定初始容量。 - `~SeqList()`：析构函数，用于释放动态分配的内存。 - `void insert(int index, int value)`：在指定位置插入元素。 - `void remove...
shunxubiao.rar_shunxubiao_顺序表
09-19
8. 赋值/拷贝构造函数：复制另一个顺序表的所有元素到当前表。 在实际应用中，顺序表有其优缺点。优点包括： - 访问速度快：由于元素在内存中连续存储，可以通过索引快速访问任意元素。 - 简单易懂：实现逻辑相对...
用C++实现简单的顺序表
12-27
本文将深入探讨如何用C++语言实现一个简单的顺序表，并介绍其相关功能。C++是一种强大的编程语言，它提供了丰富的特性来支持面向对象编程，使得实现数据结构变得高效且易于理解。 顺序表在内存中以数组的形式存储...
顺序表（数据结构）
outdated_socks的博客
04-07 5374
顺序表详解
顺序表的功能实现
wnx_hh的博客
11-11 151
顺序表 2.1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储。 typedef int SLDataType; typedef struct SeqList { SLDataType* array; // 指向动态开辟的数...
数据结构—顺序表的基本功能实现
qq_42932834的博客
06-05 1464
顺序表的基本功能实现 线性表是数据结构的基础结构。数据结构+算法=程序，今天结束了C++的书本自学，扎进数据结构和算法的世界里。 线性表分为顺序存储，链式存储，索引存储，散列存储等。 顺序存储即顺序表，链式存储即链表。 关于数据结构，最重要的是会画图，明白逻辑结构和物理结构。不急不燥，代码不是一气呵成的，需要长久的练习和耐心。 下面是顺序表的实现代码： #include <iostrea...
顺序表的基本操作(详细、全面)
gaorutao0923的博客
07-30 3059
顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 接下来看一下顺序表的基本操作： ...
顺序表功能的实现与总结
lzy15192536135的博客
03-26 2853
顺序表所需要功能 1.创建一个空的顺序表 2.指定位置插入数据 3.判断顺序表满 4.遍历顺序表 5.判断顺序表是否为空 6.删除指定位置的数据 7.修改指定位置的数据 8.修改指定的数据(将一个数据修改为新值) 9.查找指定数据的位置 10.查找指定位置的数据 11.清空表 首先创建一个结构体 typedef int datatype;//定义一个数据类型为datatype，方便之后使用 //定义一个顺序表的结构体 typedef struct list_t { datatype data[N]
顺序表的基本功能实现
dianquanhe2322的博客
04-11 152
#include<stdio.h>#include<malloc.h>#include<assert.h>#define SEQLIST_INIT_SIZE 8#define INC_SIZE 3typedef int ElemType; typedef struct SeqList{ ElemType *base; int capacit...
顺序表的基本功能（C语言实现）
m0_50490844的博客
01-31 212
顺序表的基本功能（C语言实现） ** #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 #define TRUE 1 #define OK 1 #define FALSE 0 #define ERROR 0 #define OVERFLOW -1 typedef int Elemtype; typedef int Status; typedef struct{ Elemtype *elem; int leng
线性表（顺序表功能实现）
boy_of_god的博客
08-29 277
文章目录线性表1、顺序表（动态数组）1.1、定义：1.2、算法1.3实现1.3.0定义数据类型1.3.1初始化1.3.1.0思想1.3.1.1 功能代码：1.3.2判断是否满1.3.2.0思想1.3.2.1 功能代码：1.3.3追加1.3.3.0思想1.3.3.1 功能代码：1.3.4判断是否为空1.3.4.0思想1.3.2.1功能代码：1.3.5输出数组1.3.5.0思想1.3.5.1功...
C语言之 数据结构入门——顺序表的构造
tq02的博客
12-27 3233
顺序表的删、插、增、查、扩等详解，且结尾附带完整代码
编写顺序表
最新发布
05-24
以下是一个简单的顺序表的定义和实现： ```C++ #include <iostream> using namespace std; const int MAX_SIZE = 100; // 顺序表的最大长度 class SeqList { private: int data[MAX_SIZE]; // 存储数据的数组 int length; // 当前顺序表的长度 public: SeqList() { // 构造函数，初始化长度为0 length = 0; } // 插入元素函数 bool insert(int index, int value) { if (length == MAX_SIZE) { // 判断顺序表是否已满 return false; } if (index < 0 || index > length) { // 判断插入位置是否合法 return false; } for (int i = length; i > index; i--) { // 将插入位置之后的元素依次向后移动 data[i] = data[i - 1]; } data[index] = value; // 在插入位置处插入新元素 length++; // 长度加1 return true; } // 删除元素函数 bool remove(int index) { if (index < 0 || index >= length) { // 判断删除位置是否合法 return false; } for (int i = index; i < length - 1; i++) { // 将删除位置之后的元素依次向前移动 data[i] = data[i + 1]; } length--; // 长度减1 return true; } // 获取元素函数 bool get(int index, int& value) { if (index < 0 || index >= length) { // 判断获取位置是否合法 return false; } value = data[index]; // 将获取位置处的元素值赋给value return true; } // 修改元素函数 bool set(int index, int value) { if (index < 0 || index >= length) { // 判断修改位置是否合法 return false; } data[index] = value; // 将修改位置处的元素值修改为value return true; } // 获取顺序表长度函数 int getLength() { return length; } }; int main() { SeqList list; list.insert(0, 1); list.insert(1, 2); list.insert(2, 3); cout << "Length: " << list.getLength() << endl; int value; list.get(1, value); cout << "Value at index 1: " << value << endl; list.set(1, 4); list.get(1, value); cout << "Value at index 1 after set: " << value << endl; list.remove(2); cout << "Length after remove: " << list.getLength() << endl; return 0; } ``` 这个顺序表实现了插入、删除、获取、修改元素以及获取顺序表长度的功能。你可以根据自己的需求进行修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我会一直在的

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

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

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

打赏作者

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

抵扣说明：

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

余额充值