数据结构和算法-线性表（顺序存储）

最新推荐文章于 2024-08-08 21:53:48 发布
最新推荐文章于 2024-08-08 21:53:48 发布
阅读量278 收藏 3
点赞数 2
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79562410/article/details/140380221
版权

数据结构中的线性表是一种非常基础和重要的概念，它按照线性的顺序存储数据元素。线性表可以采用不同的存储方式，其中顺序存储是一种常见的方式。下面是一些关于线性表和顺序存储的基本概念：

线性表的定义

线性表是具有相同数据类型的n个元素的有限序列，其中n称为表的长度。线性表的元素可以是任意的数据类型，如整数、字符、浮点数等。

顺序存储结构

顺序存储结构通常使用数组来实现线性表。在这种结构中，线性表的元素被存储在一个连续的内存块中。数组的每个元素对应线性表中的一个数据项。

特点

  1. 随机访问：由于是连续存储，可以通过索引快速访问任意位置的元素。
  2. 固定大小：数组的大小在创建时确定，通常不易改变，这可能导致空间浪费或需要重新分配更大的空间。
  3. 插入和删除操作：在顺序存储的线性表中，插入和删除元素可能需要移动大量元素以维持连续性，这可能导致较高的时间开销。

基本操作

线性表的基本操作通常包括：

  • 初始化：创建一个空的线性表。
  • 销毁：释放线性表占用的内存。
  • 查找：根据某种条件查找元素。
  • 插入：在指定位置插入一个元素。
  • 删除：删除指定位置的元素。
  • 长度获取：获取线性表中元素的数量。

定义一个结构体包含：数组data 、数组长度length：

typedef struct
{
    ElemType data[MAXSIZE];        /* 数组，存储数据元素 */
    int length;                    /* 线性表当前长度 */
}SqList;

初始化顺序线性表：

Status InitList(SqList* L)
{
    L->length = 0;
    return OK;
}

顺序表是否为空、清空、返回数组长度操作：

/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(SqList L)
{
    if (L.length == 0)
        return TRUE;
    else
        return FALSE;
}

/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(SqList* L)
{
    L->length = 0;
    return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(SqList L)
{
    return L.length;
}

查找：

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始 */
Status GetElem(SqList L, int i, ElemType* e)
{
    if (L.length == 0 || i<1 || i>L.length)
    {
        return ERROR;
    }
    *e = L.data[i - 1];
    return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(SqList L, ElemType e)
{
    int i = 0;
    if (L.length == 0) {
        return ERROR;
    }
    for (i = 0; i < L.length; i++)
    {
        if (L.data[i] == e) {
            break;
        }
    }
    if (i >= L.length) {
        return 0;
    }
    return i + 1;
}

顺序表插入、删除元素：

/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(SqList* L, int i, ElemType e)
{
    int k;
    if (L->length == MAXSIZE)  /* 顺序线性表已经满 */
        return ERROR;
    if (i<1 || i>L->length + 1)/* 当i比第一位置小或者比最后一位置后一位置还要大时 */
        return ERROR;

    if (i <= L->length)        /* 若插入数据位置不在表尾 */
    {
        for (k = L->length - 1; k >= i - 1; k--)  /* 将要插入位置之后的数据元素向后移动一位 */
            L->data[k + 1] = L->data[k];
    }
    L->data[i - 1] = e;          /* 将新元素插入 */
    L->length++;

    return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList* L, int i, ElemType* e)
{   
    int k = 0;
    if (L->length == 0)
    {
        return ERROR;
    }

    if (i<1 || i>L->length) {
        return ERROR;
    }

    *e = L->data[i - 1];
    if (i < L->length) {    //删除位置不在表尾
        for (k = i; k < L->length; k++)
        {
            L->data[k - 1] = L->data[k];    //删除位置后面的数据前移
        }
    }
    L->length--;
    return OK;
}

总程序和测试案例：


#include "stdio.h"    

#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;          /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;        /* ElemType类型根据实际情况而定，这里假设为int */


Status visit(ElemType c)
{
    printf("%d ", c);
    return OK;
}

typedef struct
{
    ElemType data[MAXSIZE];        /* 数组，存储数据元素 */
    int length;                    /* 线性表当前长度 */
}SqList;

/* 初始化顺序线性表 */
Status InitList(SqList* L)
{
    L->length = 0;
    return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(SqList L)
{
    if (L.length == 0)
        return TRUE;
    else
        return FALSE;
}

/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(SqList* L)
{
    L->length = 0;
    return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(SqList L)
{
    return L.length;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始 */
Status GetElem(SqList L, int i, ElemType* e)
{
    if (L.length == 0 || i<1 || i>L.length)
    {
        return ERROR;
    }
    *e = L.data[i - 1];
    return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(SqList L, ElemType e)
{
    int i = 0;
    if (L.length == 0) {
        return ERROR;
    }
    for (i = 0; i < L.length; i++)
    {
        if (L.data[i] == e) {
            break;
        }
    }
    if (i >= L.length) {
        return 0;
    }
    return i + 1;
}


/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(SqList* L, int i, ElemType e)
{
    int k;
    if (L->length == MAXSIZE)  /* 顺序线性表已经满 */
        return ERROR;
    if (i<1 || i>L->length + 1)/* 当i比第一位置小或者比最后一位置后一位置还要大时 */
        return ERROR;

    if (i <= L->length)        /* 若插入数据位置不在表尾 */
    {
        for (k = L->length - 1; k >= i - 1; k--)  /* 将要插入位置之后的数据元素向后移动一位 */
            L->data[k + 1] = L->data[k];
    }
    L->data[i - 1] = e;          /* 将新元素插入 */
    L->length++;

    return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList* L, int i, ElemType* e)
{   
    int k = 0;
    if (L->length == 0)
    {
        return ERROR;
    }

    if (i<1 || i>L->length) {
        return ERROR;
    }

    *e = L->data[i - 1];
    if (i < L->length) {    //删除位置不在表尾
        for (k = i; k < L->length; k++)
        {
            L->data[k - 1] = L->data[k];    //删除位置后面的数据前移
        }
    }
    L->length--;
    return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(SqList L)
{
    int i;
    for (i = 0; i < L.length; i++)
        visit(L.data[i]);
    printf("\n");
    return OK;
}

/* 合并Lb的La的元素 */
void unionL(SqList* La, SqList Lb)
{
    int La_len, Lb_len, i;
    ElemType e;
    La_len = ListLength(*La);
    Lb_len = ListLength(Lb);
    for (i = 1; i <= Lb_len; i++)
    {
        GetElem(Lb, i, &e);
        if (!LocateElem(*La, e))
            ListInsert(La, ++La_len, e);
    }
}

int main()
{

    SqList L;
    SqList Lb;

    ElemType e;
    Status i;
    int j, k;
    i = InitList(&L);
    printf("初始化L后：L.length=%d\n", L.length);
    for (j = 1; j <= 5; j++)
        i = ListInsert(&L, 1, j);
    printf("在L的表头依次插入1～5后：L.data=");
    ListTraverse(L);

    printf("L.length=%d \n", L.length);
    i = ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n", i);

    i = ClearList(&L);
    printf("清空L后：L.length=%d\n", L.length);
    i = ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n", i);

    for (j = 1; j <= 10; j++)
        ListInsert(&L, j, j);
    printf("在L的表尾依次插入1～10后：L.data=");
    ListTraverse(L);

    printf("L.length=%d \n", L.length);

    ListInsert(&L, 1, 0);
    printf("在L的表头插入0后：L.data=");
    ListTraverse(L);
    printf("L.length=%d \n", L.length);

    GetElem(L, 5, &e);
    printf("第5个元素的值为：%d\n", e);
    for (j = 3; j <= 4; j++)
    {
        k = LocateElem(L, j);
        if (k)
            printf("第%d个元素的值为%d\n", k, j);
        else
            printf("没有值为%d的元素\n", j);
    }


    k = ListLength(L); /* k为表长 */
    for (j = k + 1; j >= k; j--)
    {
        i = ListDelete(&L, j, &e); /* 删除第j个数据 */
        if (i == ERROR)
            printf("删除第%d个数据失败\n", j);
        else
            printf("删除第%d个的元素值为：%d\n", j, e);
    }
    printf("依次输出L的元素：");
    ListTraverse(L);

    j = 5;
    ListDelete(&L, j, &e); /* 删除第5个数据 */
    printf("删除第%d个的元素值为：%d\n", j, e);

    printf("依次输出L的元素：");
    ListTraverse(L);

    //构造一个有10个数的Lb
    i = InitList(&Lb);
    for (j = 6; j <= 15; j++)
        i = ListInsert(&Lb, 1, j);

    unionL(&L, Lb);

    printf("依次输出合并了Lb的L的元素：");
    ListTraverse(L);

    return 0;
}

徐徐图之123
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法系列--线性表
2302_77343936的博客
10-01 487
针对顺序表的缺点，一种改进的思路是让相邻元素间留有足够的余地，即所有的元素都不考虑相邻的位置，哪里有空位就空到哪里，而只是让每个元素都知道它下一个元素在哪儿就可以了，这样，假设我们在表中的第一个元素，我们便知道了第二个元素的内存地址，在第二个元素，知道第三个元素的内存地址，依此类推，通过遍历的形式便可以找到所有元素的内存地址。这种思想便是线性表链式存储结构建立的前提。1.线性链表:采用链式存储结构的线性表。
算法与数据结构 --- 线性表 --- 顺序表示和实现
qq_51947882的博客
09-13 1051
list是线性表的英文名字，Elemset1. initialization 初始化2.销毁线性表的本质是将线性表从内存中删除3.置为空表的意思是将线性表中的元素全都删除1.数据元素判断函数的返回值类型是bool类型，当函数返回一个 true 时表示函数满足，返回一个false 时表示函数不满足2.这个函数会将我们传进来的 e 作为左参数，同时将 线性表中的每个元素依次作为右参数，左右参数进行比较，右参数依次变换，直到返回true为止，若比完了最后一个元素后仍无true则结束。
Java数据结构与算法-线性表
ly_better的博客
11-02 647
1.1线性表的基本概念 线性表是由n个数据元素所构成的有限序列. 对于同一个线性表，其每一个数据元素的值虽然不同，但必须具有相同的数据类型；同时，数据元素之间具有一种线性
数据结构与算法 －线性表顺序存储及其相关算法
越陌度阡
05-28 1556
线性表的基本运算操作主要有以下6种： 1.初始化 Initiate(L)，建立一个空表L=()，L不含数据元素。 2. 求表长度 Length(L)，返回线性表L的长度。 3.取表元 Get(L,i)，返回线性表第i个数据元素，当i不满足 1≤i≤Length(L)时，返回一特殊值。 4. 定位 Locate(L,x)，查找线性表中数据元素值等于x的结点序号，若有多个数据元素值与x相等，运算结果为这些结点中序号的最小值，若找不到该结点，则运算结果为0。 5.插入 Insert(L,x,i)，...
数据结构与算法--线性表的顺序存储
wumingzei的博客
07-31 651
线性表由n个相同属性的数据元素组成，可以为空表或表示为 ( A = (a_1, a_2, …, a_i, …, a_n) )。线性表的逻辑特征包括：有且仅有一个表头元素 ( a_1 )，无前驱。有且仅有一个表尾元素 ( a_n )，无后继。表头元素和表尾元素之外的其他元素都有一个前驱和一个后继。线性表的长度为n，当n=0时，称为空表。一般形式：线性表数据结构定义n0}其中，关系的定义< ai , ai+1 >：ai , ai+1 必定相邻；
头歌-数据结构与算法 - 线性表
mlws1900的博客
10-06 3742
【代码】头歌-数据结构与算法 - 线性表。
头歌（C语言）-数据结构与算法-线性表-第二关-实现一个链接存储的线性表
weixin_59436900的博客
05-03 903
后面将定义的若干操作与当前位置有关，例如：在当前位置结点之前插入结点，在当前位置结点之后插入结点，等等。删除线性表当前位置后面的那个数据元素结点： 若删除失败（为空表，或当前位置是表尾），则返回。获取线性表当前位置结点编号： 获取线性表的当前位置结点的编号。修改线性表当前位置数据元素的值： 将线性表的当前位置的数据元素的值修改为。在线性表当前位置之前插入数据元素： 在线性表的当前位置之前插入数据元素。在线性表当前位置之后插入数据元素： 在线性表的当前位置之后插入数据元素。（线性表为空，或当前位置为表尾）。
头歌（C语言）-数据结构与算法-线性表-第一关-实现一个顺序存储的线性表
weixin_59436900的博客
05-03 671
注意：本关必读中提及的其他操作已经由平台实现，你在实现本关任务的三个操作函数时，在函数体内可调用其他操作。本关的测试文件是 step1/Main.cpp ，负责对实现的代码进行测试。返回被删除的数据元素的值。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。所指向的用于存储线性表数据元素的存储空间。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。个数据元素的顺序存储的线性表，并将其初始状态设置为。的数据元素，返回该数据元素的编号。获取线性表当前长度：获取并返回线性表的当前长度。
数据结构与算法 －线性表顺序存储与链式存储的比较
越陌度阡
05-29 902
前端几篇分别介绍了线性表中顺序存储与链式存储，下面来总结一下他们的区别。 顺序表与链表的优缺点： 1. 单链表的每个结点包括数据域与指针域，指针域需要占用额外空间。 2. 从整体考虑，顺序表要预分配存储空间，如果预先分配得过大，将造成 浪费，若分配得过小，又将发生上溢；单链表不需要预先分配空间，只要内存空间没有耗尽，单链表中的结点个数就没有限制。 顺序表与链表的时间性能： ......
Java数据结构与算法-线性表（详细实现）
qq_41649001的博客
07-25 3289
线性表（Linear List） 2.1 什么是线性表 零个或多个数据元素的有限序列。 非空线性表的逻辑结构特征 有且仅有一个开始结点，无直接前趋，有且只有一个直接后继 有且仅有一个结束结点，有且只有一个直接前趋，无直接前驱。 内部结点都有且只有一个直接前趋和一个直接后继 对于同一线性表，数据类型一直，数据元素长度一致。 2.2 线性表基本运算 基本运算包括 initList 初始化操作，建立一个空的线性表 listEmpty 若线性表为空，返回true，否则返回false
高阶数据结构——B树
weixin_74310945的博客
08-08 681
B树：有序数组+平衡多叉树；B+树：有序数组链表+平衡多叉树；B*树：一棵更丰满的，空间利用率更高的B+树。单论树的高度，查找效率来看B树系列确实不错，但是也存在一些缺点。1.空间利用率低，占用的空间大。2.插入和删除数据时，需要进行分裂，涉及到数据的挪动，效率低。3.虽然比起红黑树等，高度更低，但是在内存中都是一个量级的，搜索效率并不比红黑树快多少（在内存中没什么优势）
树和二叉树
2401_83720143的博客
08-08 316
2、如果对一颗有n个结点的完全二叉树（深度为 | log以2为底n的对数 | +1 ）的结点。1、在二叉树的第i层上至多有2的 i-1次方个结点（i>=1），至少有i个结点。1、具有n个结点的完全二叉树的深度为 ： | log以2为底n的对数 | +1。2、深度为k的二叉树至多有2的k次方减1个结点（k>=1），至少有k个结点。2、如果2i>n,则结点i为叶子结点，无左孩子，否则其左孩子是结点 2i。3、如果2i+1>n，则结点 i无右孩子，否则其右孩子是结点 2i+1。根结点：非空树中无前驱结点的结点。
常见8种数据结构
qq_43575301的博客
08-08 134
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
C语言练习--数组作为函数参数
lovemelater618的博客
08-08 107
题目练习
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 347
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
数据结构：链表经典算法OJ题
2401_86551514的博客
08-04 1006
在了解了链表的相关知识后，我们还需要一些题目进行练习加深对链表这方面知识的理解，也可以用来检测链表这块学的的怎么样，废话不多说，开始上手。
【数据结构】数组复习-二分查找法
weixin_54096215的博客
08-08 320
[34] 在排序数组中查找元素的第一个和最后一个位置left = 0else:else:left = 0else:main()c++public:} else {left = 0;
数据结构——链式结构二叉树
2301_81888634的博客
08-02 689
我们已经学习了实现二叉树的两种方法：顺序结构（堆）和链式结构。敬请期待“二叉树OJ题”~
【Redis】数据结构篇
最新发布
小新的博客
08-08 524
Redis为什么那么快？除了它是内存数据库，使得所有的操作都在内存上进行之外，还有一个重要因素，它实现的数据结构，使得我们对数据进行增删查改操作时，Redis 能高效的处理。
数据结构与算法-线性表
09-13
数据结构与算法-线性表是一种用于存储数据的数据结构，它可以按照一定的逻辑顺序来存储和访问数据。线性表的定义是一个有限个相同类型的数据元素的集合，每个数据元素都有一个唯一的前驱和后继。线性表可以用顺序存储结构或链式存储结构来实现。 顺序表是线性表的一种实现方式，它使用连续的存储空间来存储数据元素。顺序表的特点是逻辑关系上相邻的两个元素在物理位置上也相邻，因此可以通过下标随机访问表中的任意元素。顺序表的存储位置可以使用简单直观的公式来表示。 链表是线性表的另一种实现方式，它使用一组通过指针连接起来的结点来存储数据元素。每个结点包含两部分：数据域和指针域。数据域用于存储数据元素，指针域用于指向下一个结点。链表的分类较为多样，包括单链表、双向链表和循环链表等。链表的操作相对复杂一些，但它具有灵活性和动态性的优势。 总结来说，数据结构与算法-线性表是一种用于存储数据的数据结构，它可以按照一定的逻辑顺序来存储和访问数据。线性表可以使用顺序表或链表来实现，顺序表适合于随机访问，而链表适合于插入和删除操作。对于链表来说，需要注意不同类型的链表有不同的操作和特点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值