详解顺序表

最新推荐文章于 2023-10-30 11:15:12 发布
最新推荐文章于 2023-10-30 11:15:12 发布
阅读量230 收藏 1
点赞数 1
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53454890/article/details/133619753
版权

定义：

顺序表是一种线性表（Linear List）数据结构，其中的元素按照线性的顺序排列，每个元素都有一个唯一的前驱元素和一个唯一的后继元素，除了第一个元素没有前驱，最后一个元素没有后继。
顺序表通常使用数组来实现，数组中的元素按照逻辑顺序排列，可以通过数组下标访问和操作元素。

特点：

连续存储：顺序表的元素在内存中是连续存储的，这意味着元素在物理上是相邻的，这有助于快速访问元素。但也因此，顺序表的大小通常是固定的，需要预先分配足够的内存空间。

随机访问：由于元素的连续存储特性，顺序表支持常数时间复杂度（O(1)）的随机访问，即通过元素的下标可以立即访问元素。

固定大小：顺序表的大小通常是固定的，一旦分配了一定大小的内存空间，就不能动态改变大小。如果需要更大的容量，通常需要重新分配内存并复制数据。

插入和删除效率较低：在顺序表中插入或删除元素通常需要移动其他元素，因此其时间复杂度为O(n)，其中n是元素的总数。这与链表不同，链表在插入和删除元素时可以在O(1)时间内完成。

空间利用率：顺序表在存储元素时，除了存储元素本身外，通常需要额外的空间来存储数组的大小信息，因此在存储上可能会浪费一些空间。

顺序表的基本运算：

  1. 初始化（Init）：创建一个空的顺序表，即一个具有零个元素的表。

  2. 插入（Insert）：在指定位置插入一个元素。通常需要提供插入位置的索引和要插入的元素。

  3. 删除（Delete）：删除指定位置的元素。通常需要提供要删除的元素的索引。

  4. 查找（Search）：查找指定值的元素，并返回其位置（索引）。如果要查找多个相同值的元素，可能会返回第一个匹配项的位置。

  5. 获取（Get）：获取指定位置的元素，通常通过索引来实现。返回指定位置的元素值。

  6. 更新（Update）：更新指定位置的元素的值，通常需要提供索引和新的元素值。

  7. 获取长度（Length）：返回顺序表中元素的个数（长度）。

  8. 判断空（IsEmpty）：检查顺序表是否为空，即是否没有元素。

  9. 判断满（IsFull）：检查顺序表是否已满，即是否达到了最大容量。

  10. 清空（Clear）：清空顺序表，即删除所有元素，将其重置为空表。

  11. 遍历（Traverse）：按照顺序遍历顺序表中的所有元素，通常用于打印或处理每个元素。

顺序表的实现：

1.导入必要的函数库，同时定义表的大小以及表中元素的数据类型。

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

2.定义顺序表的结构体

// 定义顺序表的结构体
typedef struct {
    int data[MAX_SIZE]; // 用于存储元素的数组
    int length;         // 当前顺序表的长度
} ArrayList;

3.初始化顺序表

// 初始化顺序表
void initArrayList(ArrayList *list) {
    list->length = 0; // 初始长度为0
}

4.判断顺序表是否为空，是否已满

// 判断顺序表是否为空
int isEmpty(ArrayList *list) {
    return list->length == 0;
}

// 判断顺序表是否已满
int isFull(ArrayList *list) {
    return list->length == MAX_SIZE;
}

5.向顺序表末尾添加元素

// 向顺序表末尾添加元素
void append(ArrayList *list, int element) {
    if (!isFull(list)) {
        list->data[list->length++] = element;
    } else {
        printf("顺序表已满，无法添加元素。\n");
    }
}

6.在指定位置插入元素

// 在指定位置插入元素
void insert(ArrayList *list, int index, int element) {
    if (index < 0 || index > list->length) {
        printf("插入位置无效。\n");
        return;
    }

    if (!isFull(list)) {
        // 从后往前移动元素以腾出插入位置
        for (int i = list->length; i > index; i--) {
            list->data[i] = list->data[i - 1];
        }
        list->data[index] = element;
        list->length++;
    } else {
        printf("顺序表已满，无法插入元素。\n");
    }
}

7.删除指定位置的元素

// 删除指定位置的元素
void remove(ArrayList *list, int index) {
    if (index < 0 || index >= list->length) {
        printf("删除位置无效。\n");
        return;
    }

    // 从指定位置开始，后面的元素向前移动
    for (int i = index; i < list->length - 1; i++) {
        list->data[i] = list->data[i + 1];
    }
    list->length--;
}

8.获取指定位置的元素

// 获取指定位置的元素
int get(ArrayList *list, int index) {
    if (index < 0 || index >= list->length) {
        printf("索引越界。\n");
        return -1;
    }
    return list->data[index];
}

9.打印顺序表的所有元素

// 打印顺序表的所有元素
void display(ArrayList *list) {
    printf("顺序表的元素：");
    for (int i = 0; i < list->length; i++) {
        printf("%d ", list->data[i]);
    }
    printf("\n");
}

10.主函数

int main() {
    ArrayList myList;
    initArrayList(&myList);
    int choice;

    while (1) {
        printf("\n顺序表操作选项：\n");
        printf("1. 添加元素\n");
        printf("2. 插入元素\n");
        printf("3. 删除元素\n");
        printf("4. 获取元素\n");
        printf("5. 打印顺序表\n");
        printf("6. 退出\n");
        printf("请选择操作：");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                if (!isFull(&myList)) {
                    int element;
                    printf("请输入要添加的元素：");
                    scanf("%d", &element);
                    append(&myList, element);
                    printf("元素 %d 已添加。\n", element);
                } else {
                    printf("顺序表已满，无法添加元素。\n");
                }
                break;

            case 2:
                if (!isFull(&myList)) {
                    int index, element;
                    printf("请输入要插入的位置和元素（例如，位置 元素）：");
                    scanf("%d %d", &index, &element);
                    insert(&myList, index, element);
                    printf("元素 %d 已插入到位置 %d。\n", element, index);
                } else {
                    printf("顺序表已满，无法插入元素。\n");
                }
                break;

            case 3:
                if (!isEmpty(&myList)) {
                    int index;
                    printf("请输入要删除的位置：");
                    scanf("%d", &index);
                    remove(&myList, index);
                    printf("元素已删除。\n");
                } else {
                    printf("顺序表为空，无法删除元素。\n");
                }
                break;

            case 4:
                if (!isEmpty(&myList)) {
                    int index;
                    printf("请输入要获取的位置：");
                    scanf("%d", &index);
                    int element = get(&myList, index);
                    if (element != -1) {
                        printf("获取的元素：%d\n", element);
                    }
                } else {
                    printf("顺序表为空，无法获取元素。\n");
                }
                break;

            case 5:
                if (!isEmpty(&myList)) {
                    display(&myList);
                } else {
                    printf("顺序表为空，无法打印元素。\n");
                }
                break;

            case 6:
                printf("退出程序。\n");
                exit(0);

            default:
                printf("无效的选项，请重新选择。\n");
                break;
        }
    }

    return 0;
}

执行结果

完整demo

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

// 定义顺序表的结构体
typedef struct {
    int data[MAX_SIZE]; // 用于存储元素的数组
    int length;         // 当前顺序表的长度
} ArrayList;

// 初始化顺序表
void initArrayList(ArrayList *list) {
    list->length = 0; // 初始长度为0
}

// 判断顺序表是否为空
int isEmpty(ArrayList *list) {
    return list->length == 0;
}

// 判断顺序表是否已满
int isFull(ArrayList *list) {
    return list->length == MAX_SIZE;
}

// 向顺序表末尾添加元素
void append(ArrayList *list, int element) {
    if (!isFull(list)) {
        list->data[list->length++] = element;
    } else {
        printf("顺序表已满，无法添加元素。\n");
    }
}

// 在指定位置插入元素
void insert(ArrayList *list, int index, int element) {
    if (index < 0 || index > list->length) {
        printf("插入位置无效。\n");
        return;
    }

    if (!isFull(list)) {
        // 从后往前移动元素以腾出插入位置
        for (int i = list->length; i > index; i--) {
            list->data[i] = list->data[i - 1];
        }
        list->data[index] = element;
        list->length++;
    } else {
        printf("顺序表已满，无法插入元素。\n");
    }
}

// 删除指定位置的元素
void remove(ArrayList *list, int index) {
    if (index < 0 || index >= list->length) {
        printf("删除位置无效。\n");
        return;
    }

    // 从指定位置开始，后面的元素向前移动
    for (int i = index; i < list->length - 1; i++) {
        list->data[i] = list->data[i + 1];
    }
    list->length--;
}

// 获取指定位置的元素
int get(ArrayList *list, int index) {
    if (index < 0 || index >= list->length) {
        printf("索引越界。\n");
        return -1;
    }
    return list->data[index];
}

// 打印顺序表的所有元素
void display(ArrayList *list) {
    printf("顺序表的元素：");
    for (int i = 0; i < list->length; i++) {
        printf("%d ", list->data[i]);
    }
    printf("\n");
}

int main() {
    ArrayList myList;
    initArrayList(&myList);
    int choice;

    while (1) {
        printf("\n顺序表操作选项：\n");
        printf("1. 添加元素\n");
        printf("2. 插入元素\n");
        printf("3. 删除元素\n");
        printf("4. 获取元素\n");
        printf("5. 打印顺序表\n");
        printf("6. 退出\n");
        printf("请选择操作：");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                if (!isFull(&myList)) {
                    int element;
                    printf("请输入要添加的元素：");
                    scanf("%d", &element);
                    append(&myList, element);
                    printf("元素 %d 已添加。\n", element);
                } else {
                    printf("顺序表已满，无法添加元素。\n");
                }
                break;

            case 2:
                if (!isFull(&myList)) {
                    int index, element;
                    printf("请输入要插入的位置和元素（例如，位置 元素）：");
                    scanf("%d %d", &index, &element);
                    insert(&myList, index, element);
                    printf("元素 %d 已插入到位置 %d。\n", element, index);
                } else {
                    printf("顺序表已满，无法插入元素。\n");
                }
                break;

            case 3:
                if (!isEmpty(&myList)) {
                    int index;
                    printf("请输入要删除的位置：");
                    scanf("%d", &index);
                    remove(&myList, index);
                    printf("元素已删除。\n");
                } else {
                    printf("顺序表为空，无法删除元素。\n");
                }
                break;

            case 4:
                if (!isEmpty(&myList)) {
                    int index;
                    printf("请输入要获取的位置：");
                    scanf("%d", &index);
                    int element = get(&myList, index);
                    if (element != -1) {
                        printf("获取的元素：%d\n", element);
                    }
                } else {
                    printf("顺序表为空，无法获取元素。\n");
                }
                break;

            case 5:
                if (!isEmpty(&myList)) {
                    display(&myList);
                } else {
                    printf("顺序表为空，无法打印元素。\n");
                }
                break;

            case 6:
                printf("退出程序。\n");
                exit(0);

            default:
                printf("无效的选项，请重新选择。\n");
                break;
        }
    }

    return 0;
}

小结

  • 顺序表中的元素在内存中是连续存储的，支持随机访问。
  • 需要预先分配一定大小的内存空间，因此具有固定的容量。
  • 插入和删除元素的效率较低，通常需要移动其他元素。
  • 顺序表通常包括数组和长度信息，可能会浪费一些空间。
  • 适用于需要快速随机访问元素的情况。
  • 不适用于频繁插入和删除元素的情况，因为这些操作可能涉及大量数据的移动。
  • 针对特定应用场景，可以考虑使用动态数组来克服固定容量的限制。
  • 对于大型数据集，可以使用二分查找等算法来提高查找效率。
weixin_53454890
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
详解顺序表-顺序表演示源文件
10-02
顺序表演示源文件
线性表list
Fanxing1391的博客
11-24 293
实现线性表的各个功能： InitList（*L）：初始化操作，建立一个空的线性表L。 ListEmpty(L)：若线性表为空，则返回TRUE，否则返回FALSE。 ClearList(*L):将线性表清空。 GetElem(L,i,*e):将线性表L中第i个位置元素值返回给e。 LocateElem(L,e):在线性表中查找与给定值e相等的元素，如果查找成功，返回该元素在表中的序号表示成
数据结构———线性表之顺序表
weixin_72184257的博客
10-30 277
顺序表
数据结构之顺序表
m0_62878102的博客
08-04 2912
顺序表在内存中以一段连续的地址存储，具有随机性，顺序性，动态性随机性，即首地址随机生成；顺序性，即各元素地址满足等距相邻；动态性，即存储空间可在程序运行时动态生成。
顺序表中有效元素的长度_一、顺序表
weixin_39760068的博客
12-16 1310
今天我们正式开始数据结构与算法的学习，参考书籍是《大话数据结构》、《算法导论》，使用IDE为VS2019，编程语言为C语言。我计划学习10种数据结构：顺序表、链表、栈、队列、散列表、二叉树、堆、跳表、图、Trie 树；10种算法：递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法。先掌握这些基础的数据结构和算法，以后再精进更加复杂的内容。1. 顺序表概述我...
【数据结构学习】线性表
SWEET0SWAT的博客
07-20 444
基本概念 逻辑上来看，线性表由n(n>=0)个数据元素a1、a2、a3…an组成。 n为表的长度，也就是数据元素的个数。 表空时n=0 对于一个非空的线性表所具有的逻辑结构特征： 1、有且仅有一个开始节点a1，没有直接前驱节点，有且仅有一个直接后继节点。 2、有切仅有一个终结节点an，没有直接后继节点，有且仅有一个直接前驱节点。 3、其余的内部节点ai(2<= i <= n-1)，有且仅有一个直接前驱节点和一个直接后继节点。 对于同意线性表，各个数据元素的数据类型都必须相同。 线性表的
C语言实现静态顺序表的实例详解
01-01
C语言实现静态顺序表的实例详解 线性表 定义一张顺序表也就是在内存中开辟一段连续的存储空间，并给它一个名字进行标识。只有定义了一个顺序表，才能利用该顺序表存放数据元素，也才能对该顺序表进行各种操作。 接...
顺序表的基本操作详解.zip
最新发布
03-20
顺序表的基本操作详解
Python中顺序表原理与实现方法详解
09-18
主要介绍了Python中顺序表原理与实现方法,结合实例形式分析了Python顺序表的概念、原理及增删查等相关实现技巧,需要的朋友可以参考下
408考研-数据结构算法-顺序表
JAVA技术博客
08-30 309
关于算法的内容就是这些。很多时候，计算一样东西并不只有一种方法，换种算法可能会极大地影响程序的性能。同时你还应意识到，世界上并没有哪种适用于所有场景的数据结构或者算法。你不能因为有序数组能使用二分查找就永远只用有序数组。在经常插入而很少查找的情况下，显然插入迅速的常规数组会是更好的选择。如之前所述，比较算法的方式就是比较各自的步数。
【数据结构-C】顺序表知识点梳理
weixin_44768184的博客
05-13 1780
1.线性表 2.顺序表 概念 结构 问题: 1.中间/头部的插入删除，时间复杂度为O（N） 2.增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。 3.增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。 思考： 如何解决以上的问题？下面我们给出了链表...
数据结构 （一）顺序表
qq_42585108的博客
09-12 3937
顺序表一、顺序存储结构二、顺序表的初始化 一、顺序存储结构 顺序表，全名顺序存储结构，是线性表的一种。 线性表用于存储逻辑关系为“一对一”的数据，顺序表自然也不例外。 顺序表存储数据时，会提前申请一整块足够大小的物理空间，然后将数据依次存储起来，存储时做到数据元素之间不留一丝缝隙。 例如，使用顺序表存储集合 {1,2,3,4,5}，数据最终的存储状态如图 1 所示： 由此我们可以得出，将“具有 ‘一对一’ 逻辑关系的数据按照次序连续存储到一整块物理空间上”的存储结构就是顺序存储结构。 通过观察图 1 中数
数据结构与算法学习笔记(一)-----顺序表
qq_55078048的博客
09-10 468
简单易懂的顺序表知识！
温故知新——数据结构之顺序表
laosuannai233的博客
12-15 1222
顺序表是数据结构中的基础知识之一，本文带你回顾顺序表的定义和实现，重温计算机学科基础知识。
数据结构：顺序表的基本操作
热门推荐
Keep Fighting All The Time
05-03 10万+
线性表的顺序存储 顺序表的线性存储示意图 C语言定义线性表的顺序存储结构 线性表的顺序存储        线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。        顺序存
listlength函数头文件_顺序表的头文件和头文件的实现
weixin_39570777的博客
12-19 459
注意：1模板类中的函数有const，那么定义此函数时const必须要有2定义模板类的函数时，template一定要有class#ifndef _SQLIST_H_#define _SQLIST_H_#include using namespace std;const DEFAULT_SIZE=10;enum StatusCode{RANGE_ERROR,SUCCESS,NOT_PRESENT,EN...
Linux的软链接和硬链接概念
qq_45652092的博客
10-05 242
一，软链接 1，概念： - 软链接文件有类似于Windows的快捷方式。 -在符号连接中，文件实际上是一个文本文件，其中包含的有另一文件的位置信息。 -你选定的位置上生成一个文件的镜像，不会占用磁盘空间 2，如何创建软链接 ln -s xxx.so.2.50 xxxx.so 指令 参数 要被链接的文件 软链接文件名字 注：ln -s 是linux中一个非常重要命令，它的功能是为某一个文件在另外一个位置建立一个同不的链接，这个命令最常用的参数是-s。 3，注意： 第一，ln命令会保持每一处链接文
顺序表的设计与实现List（Arraylist）
小熊来了
01-31 6198
package com.tmx.sequence; //采用线性表实现一个list集合 public class SeqList extends Object { private Object[] elements; // 数组 private int n; // 长度 /** * 构造方法，根据传参创建空表 * @par
顺序表和链表的区别，请详解
06-10
顺序表和链表是两种常见的数据结构，它们的主要区别在于存储方式和操作效率。 1. 存储方式 顺序表是一种连续的存储结构，它将数据元素存储在一段连续的物理存储空间中，元素的存储位置是连续的，每个元素都占据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值