【数据结构】线性表 顺序存储结构

最新推荐文章于 2023-01-09 21:49:19 发布
最新推荐文章于 2023-01-09 21:49:19 发布
阅读量543 收藏
点赞数
分类专栏： # 【算法与数据结构】 文章标签： 线性表 数据结构 C语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43698328/article/details/103451243
版权

本文收录自【C语言数据结构】思想＋代码集】

文章目录

【数据结构】线性表

思想

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

代码

头文件及函数定义 SqList.h

/*=============================
 * 线性表的顺序存储结构（顺序表）
 *
 * 包含算法: 2.3、2.4、2.5、2.6
 =============================*/

#ifndef SQLIST_H
#define SQLIST_H

#include <stdio.h>
#include <stdlib.h>     // 提供malloc、realloc、free、exit原型
#include "Status.h"     //**▲01 绪论**//

/* 宏定义 */
#define LIST_INIT_SIZE 100  // 顺序表存储空间的初始分配量
#define LISTINCREMENT  10   // 顺序表存储空间的分配增量

/* 顺序表元素类型定义 */
typedef int ElemType;

/*
 * 顺序表结构
 *
 * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储
 */
typedef struct {
    ElemType* elem;     // 顺序表存储空间的基址（指向顺序表所占内存的起始位置）
    int length;   // 当前顺序表长度（包含多少元素）
    int listsize; // 当前分配的存储容量（可以存储多少元素）
} SqList;


/*
 * ████████ 算法2.3 ████████
 *
 * 初始化
 *
 * 初始化成功则返回OK，否则返回ERROR。q 
 */
Status InitList(SqList* L);

/*
 * 销毁(结构)
 *
 * 释放顺序表所占内存。
 */
Status DestroyList(SqList* L);

/*
 * 置空(内容)
 *
 * 只是清理顺序表中存储的数据，不释放顺序表所占内存。
 */
Status ClearList(SqList* L);

/*
 * 判空
 *
 * 判断顺序表中是否包含有效数据。
 *
 * 返回值：
 * TRUE : 顺序表为空
 * FALSE: 顺序表不为空
 */
Status ListEmpty(SqList L);

/*
 * 计数
 *
 * 返回顺序表包含的有效元素的数量。
 */
int ListLength(SqList L);

/*
 * 取值
 *
 * 获取顺序表中第i个元素，将其存储到e中。
 * 如果可以找到，返回OK，否则，返回ERROR。
 *
 *【备注】
 * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。
 * 通常，i的含义应该指索引，即从0开始计数。
 */
Status GetElem(SqList L, int i, ElemType* e);

/*
 * ████████ 算法2.6 ████████
 *
 * 查找
 *
 * 返回顺序表中首个与e满足Compare关系的元素位序。
 * 如果不存在这样的元素，则返回0。
 *
 *【备注】
 * 元素e是Compare函数第二个形参
 */
int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType));

/*
 * 前驱
 *
 * 获取元素cur_e的前驱，
 * 如果存在，将其存储到pre_e中，返回OK，
 * 如果不存在，则返回ERROR。
 */
Status PriorElem(SqList L, ElemType cur_e, ElemType* pre_e);

/*
 * 后继
 *
 * 获取元素cur_e的后继，
 * 如果存在，将其存储到next_e中，返回OK，
 * 如果不存在，则返回ERROR。
 */
Status NextElem(SqList L, ElemType cur_e, ElemType* next_e);

/*
 * ████████ 算法2.4 ████████
 *
 * 插入
 *
 * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。
 *
 *【备注】
 * 教材中i的含义是元素位置，从1开始计数
 */
Status ListInsert(SqList* L, int i, ElemType e);

/*
 * ████████ 算法2.5 ████████
 *
 * 删除
 *
 * 删除顺序表第i个位置上的元素，并将被删除元素存储到e中。
 * 删除成功则返回OK，否则返回ERROR。
 *
 *【备注】
 * 教材中i的含义是元素位置，从1开始计数
 */
Status ListDelete(SqList* L, int i, ElemType* e);

/*
 * 遍历
 *
 * 用visit函数访问顺序表L
 */
void ListTraverse(SqList L, void (Visit)(ElemType));

#endif

函数源码SqList.cpp


/*=============================
 * 线性表的顺序存储结构（顺序表）
 *
 * 包含算法: 2.3、2.4、2.5、2.6
 =============================*/

#include "SqList.h"

/*
 * ████████ 算法2.3 ████████
 *
 * 初始化
 *
 * 初始化成功则返回OK，否则返回ERROR。
 */
Status InitList(SqList* L) {
    // 分配指定容量的内存，如果分配失败，则返回NULL
    (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if((*L).elem == NULL) {
        // 存储内存失败
        exit(OVERFLOW);
    }

    (*L).length = 0;                    // 初始化顺序表长度为0
    (*L).listsize = LIST_INIT_SIZE;     // 顺序表初始内存分配量

    return OK;                          // 初始化成功
}

/*
 * 销毁(结构)
 *
 * 释放顺序表所占内存。
 */
Status DestroyList(SqList* L) {
    // 确保顺序表结构存在
    if(L == NULL || (*L).elem == NULL) {
        return ERROR;
    }

    // 释放顺序表内存
    free((*L).elem);

    // 释放内存后置空指针
    (*L).elem = NULL;

    // 顺序表长度跟容量都归零
    (*L).length = 0;
    (*L).listsize = 0;

    return OK;
}

/*
 * 置空(内容)
 *
 * 只是清理顺序表中存储的数据，不释放顺序表所占内存。
 */
Status ClearList(SqList* L) {
    // 确保顺序表结构存在
    if(L == NULL || (*L).elem == NULL) {
        return ERROR;
    }

    (*L).length = 0;

    return OK;
}

/*
 * 判空
 *
 * 判断顺序表中是否包含有效数据。
 *
 * 返回值：
 * TRUE : 顺序表为空
 * FALSE: 顺序表不为空
 */
Status ListEmpty(SqList L) {
    return L.length == 0 ? TRUE : FALSE;
}

/*
 * 计数
 *
 * 返回顺序表包含的有效元素的数量。
 */
int ListLength(SqList L) {
    return L.length;
}

/*
 * 取值
 *
 * 获取顺序表中第i个元素，将其存储到e中。
 * 如果可以找到，返回OK，否则，返回ERROR。
 *
 *【备注】
 * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。
 * 通常，i的含义应该指索引，即从0开始计数。
 */
Status GetElem(SqList L, int i, ElemType* e) {
    // 因为i的含义是位置，所以其合法范围是：[1, length]
    if(i < 1 || i > L.length) {
        return ERROR;                    //i值不合法
    }

    *e = L.elem[i - 1];

    return OK;
}

/*
 * ████████ 算法2.6 ████████
 *
 * 查找
 *
 * 返回顺序表中首个与e满足Compare关系的元素位序。
 * 如果不存在这样的元素，则返回0。
 *
 *【备注】
 * 元素e是Compare函数第二个形参
 */
int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)) {
    int i;
    ElemType* p;

    // 确保顺序表结构存在
    if(L.elem == NULL) {
        return ERROR;
    }

    /*
     * i的初值为第1个元素的位序
     *
     * 其实，更自然的写法是将i初始化为第1个元素的索引
     * 但由于教材中是按位序计数的，所以这里仍写作位序
     */
    i = 1;

    // p的初值为第1个元素的存储位置
    p = L.elem;

    // 遍历顺序表
    while(i <= L.length && !Compare(*p++, e)) {
        ++i;
    }

    if(i <= L.length) {
        return i;
    } else {
        return 0;
    }
}

/*
 * 前驱
 *
 * 获取元素cur_e的前驱，
 * 如果存在，将其存储到pre_e中，返回OK，
 * 如果不存在，则返回ERROR。
 */
Status PriorElem(SqList L, ElemType cur_e, ElemType* pre_e) {
    int i;

    // 确保顺序表结构存在，且最少包含两个元素
    if(L.elem == NULL || L.length < 2) {
        return ERROR;
    }

    // 这里的i初始化为第1个元素的【索引】
    i = 0;

    // 从第1个元素开始，查找cur_e的位置
    while(i < L.length && L.elem[i] != cur_e) {
        ++i;
    }

    // 如果cur_e是首个元素(没有前驱)，或者没找到元素cur_e，返回ERROR
    if(i==0 || i >= L.length) {
        return ERROR;
    }

    // 存储cur_e的前驱
    *pre_e = L.elem[i - 1];

    return OK;
}

/*
 * 后继
 *
 * 获取元素cur_e的后继，
 * 如果存在，将其存储到next_e中，返回OK，
 * 如果不存在，则返回ERROR。
 */
Status NextElem(SqList L, ElemType cur_e, ElemType* next_e) {
    int i;

    // 确保顺序表结构存在，且最少包含两个元素
    if(L.elem == NULL || L.length < 2) {
        return ERROR;
    }

    // 这里的i初始化为第1个元素的【索引】
    i = 0;

    // 从第1个元素开始，查找cur_e的位置
    while(i < L.length-1 && L.elem[i] != cur_e) {
        ++i;
    }

    // 如果cur_e是最后1个元素(没有前驱)，或者没找到元素cur_e，返回ERROR
    if(i >= L.length-1) {
        return ERROR;
    }

    // 存储cur_e的前驱
    *next_e = L.elem[i + 1];

    return OK;
}

/*
 * ████████ 算法2.4 ████████
 *
 * 插入
 *
 * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。
 *
 *【备注】
 * 教材中i的含义是元素位置，从1开始计数
 */
Status ListInsert(SqList* L, int i, ElemType e) {
    ElemType* newbase;
    ElemType* p, * q;

    // 确保顺序表结构存在
    if(L == NULL || (*L).elem == NULL) {
        return ERROR;
    }

    // i值越界
    if(i < 1 || i > (*L).length + 1) {
        return ERROR;
    }

    // 若存储空间已满，则增加新空间
    if((*L).length >= (*L).listsize) {
        // 基于现有空间扩容
        newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType));
        if(newbase == NULL) {
            // 存储内存失败
            exit(OVERFLOW);
        }

        // 新基址
        (*L).elem = newbase;
        // 存的存储空间
        (*L).listsize += LISTINCREMENT;
    }

    // q为插入位置
    q = &(*L).elem[i - 1];

    // 1.右移元素，腾出位置
    for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) {
        *(p + 1) = *p;
    }

    // 2.插入e
    *q = e;

    // 3.表长增1
    (*L).length++;

    return OK;
}

/*
 * ████████ 算法2.5 ████████
 *
 * 删除
 *
 * 删除顺序表第i个位置上的元素，并将被删除元素存储到e中。
 * 删除成功则返回OK，否则返回ERROR。
 *
 *【备注】
 * 教材中i的含义是元素位置，从1开始计数
 */
Status ListDelete(SqList* L, int i, ElemType* e) {
    ElemType* p, * q;

    // 确保顺序表结构存在
    if(L == NULL || (*L).elem == NULL) {
        return ERROR;
    }

    // i值越界
    if(i < 1 || i > (*L).length) {
        return ERROR;
    }

    // p为被删除元素的位置
    p = &(*L).elem[i - 1];

    // 1.获取被删除元素
    *e = *p;

    // 表尾元素位置
    q = (*L).elem + (*L).length - 1;

    // 2.左移元素，被删除元素的位置上会有新元素进来
    for(++p; p <= q; ++p) {
        *(p - 1) = *p;
    }

    // 3.表长减1
    (*L).length--;

    return OK;
}

/*
 * 遍历
 *
 * 用visit函数访问顺序表L
 */
void ListTraverse(SqList L, void(Visit)(ElemType)) {
    int i;

    for(i = 0; i < L.length; i++) {
        Visit(L.elem[i]);
    }

    printf("\n");
}

main函数

#include <stdio.h>
#include "SqList.h"                                //**02 线性表**//

// 判断data>e是否成立
Status CmpGreater(ElemType data, ElemType e) {
    return data > e ? TRUE : FALSE;
}

// 测试函数，打印元素
void PrintElem(ElemType e) {
    printf("%d ", e);
}


int main(int argc, char** argv) {
    SqList L;   // 待操作的顺序表

    int i;
    ElemType e;

    printf("████████ InitList \n");
    {
        printf("█ 初始化顺序表 L ...\n");
        InitList(&L);
    }
    PressEnterToContinue();


    printf("████████ ListEmpty \n");
    {
        if(ListEmpty(L) == TRUE) {
            printf("█ L 为空！！\n");
        } else {
            printf("█ L 不为空！\n");
        }
    }
    PressEnterToContinue();


    printf("████████ ListInsert \n");
    {
        for(i = 1; i <= 8; i++) {
            printf("█ 作为示范，在 L 第 %d 个位置插入 \"%d\"...\n", i, 2 * i);
            ListInsert(&L, i, 2 * i);
        }
    }
    PressEnterToContinue();


    printf("████████ ListTraverse \n");
    {
        printf("█ L 中的元素为：L = ");
        ListTraverse(L, PrintElem);
    }
    PressEnterToContinue();


    printf("████████ ListLength \n");
    {
        i = ListLength(L);
        printf("█ L 的长度为 %d \n", i);
    }
    PressEnterToContinue();


    printf("████████ ListDelete \n");
    {
        printf("█ 删除前的元素：L = ");
        ListTraverse(L, PrintElem);

        printf("█ 尝试删除 L 中第 6 个元素...\n");

        if(ListDelete(&L, 6, &e) == OK) {
            printf("█ 删除成功，被删除元素是：\"%d\"\n", e);
        } else {
            printf("█ 删除失败，第 6 个元素不存在！\n");
        }

        printf("█ 删除后的元素：L = ");
        ListTraverse(L, PrintElem);
    }
    PressEnterToContinue();


    printf("████████ GetElem \n");
    {
        GetElem(L, 4, &e);
        printf("█ L 中第 4 个位置的元素为 \"%d\" \n", e);
    }
    PressEnterToContinue();


    printf("████████ LocateElem \n");
    {
        i = LocateElem(L, 7, CmpGreater);
        printf("█ L 中第一个元素值大于 \"7\" 的元素是 \"%d\" \n", L.elem[i - 1]);
    }
    PressEnterToContinue();


    printf("████████ PriorElem \n");
    {
        ElemType cur_e = 6;

        if(PriorElem(L, cur_e, &e) == OK) {
            printf("█ 元素 \"%d\" 的前驱为 \"%d\" \n", cur_e, e);
        } else {
            printf("█ 元素 \"%d\" 的前驱不存在！\n", cur_e);
        }
    }
    PressEnterToContinue();


    printf("████████ NextElem \n");
    {
        ElemType cur_e = 6;

        if(NextElem(L, cur_e, &e) == OK) {
            printf("█ 元素 \"%d\" 的后继为 \"%d\" \n", cur_e, e);
        } else {
            printf("█ 元素 \"%d\" 的后继不存在！\n", cur_e);
        }
    }
    PressEnterToContinue();


    printf("████████ ClearList \n");
    {
        printf("█ 清空 L 前：");
        if(ListEmpty(L) == TRUE) {
            printf(" L 为空！！\n");
        } else {
            printf(" L 不为空！\n");
        }

        ClearList(&L);

        printf("█ 清空 L 后：");
        if(ListEmpty(L) == TRUE) {
            printf(" L 为空！！\n");
        } else {
            printf(" L 不为空！\n");
        }
    }
    PressEnterToContinue();


    printf("████████ DestroyList \n");
    {
        printf("█ 销毁 L 前：");
        if(L.elem != NULL) {
            printf(" L 存在！\n");
        } else {
            printf(" L 不存在！！\n");
        }

        DestroyList(&L);

        printf("█ 销毁 L 后：");
        if(L.elem != NULL) {
            printf(" L 存在！\n");
        } else {
            printf(" L 不存在！！\n");
        }
    }
    PressEnterToContinue();


    return 0;
}
数据结构线性表顺序存储结构和主要算法实现
weixin_45743004的博客
11-29 1344
(1) 线性表的定义。 零个或多个数据元素的有限序列 序列线性表中有直接后继元素，有且仅有一个直接后继，有且仅有一个直接前驱，数据元素之间的关系是一对一的关系 常用的List操作： Operation InitList（*L）：//初始化操作，简历一个空的线性表L ListEmpty（L）：//若线性表为空，返回true，否则返回Falser GetElme（L，i，e）：//将线性表L中的第...
线性表的实现_代码(初始化、判断是否为空表、求表长、输出表、插入、删除、查找、修改、清空表、释放表空间、退出
10-16
线性表的实现_代码(初始化、判断是否为空表、求表长、输出表、插入、删除、查找、修改、清空表、释放表空间、退出。
线性表的实现全部代码
07-14
线性表的实现：建表、插入、删除、排序、查找等 可运行的代码
线性表c代码实现
10-22
该代码实现了线性表的顺序存储，包括创建线性表、删除线性表、清空线性表、插入元素、删除元素等API函数
线性表的经典实现代码
‎‎‎‎‎不想吃泡面
04-20 698
1.线性表的顺序存储结构   顺序存储结构即用一段连续的存储单元依次存储线性表示的数据元素。优缺点大家应该都知道，下面是实现主要功能的数据结构经典代码。 /** * 顺序存储结构的线性表 * anuthor:star sea * */ #include <cstdio> #define MAX_SIZE 20 #define OK 1 #define ERRO...
线性表的实现（C语言完整代码+详细注释版）【数据结构】
热门推荐
小賀のBlog
08-01 2万+
完整且健壮的两种线性表的表示代码 线性表的顺序表示： // // main.c // SQList // // Created by Eason on 2020/7/28. // Copyright © 2020 Eason. All rights reserved. // #include<stdio.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define maxsize 100 typedef i
数据结构-线性表代码实现
03-20
线性表顺序存储代码实现
dm02_线性表顺序存储设计与实现.zip_数据结构 线性表
09-21
总的来说，这个压缩包中的代码提供了线性表顺序存储的一个基础实现，是学习和理解数据结构及算法的好例子。通过阅读和分析这段代码，你可以深入理解线性表的概念，以及如何用C语言高效地实现其基本操作。
数据结构线性表的顺序存储结构
05-03
实验 二 基于链式存储结构 实现线性表的基本的 常见的运算 提示： ⑴ 提供一个实现功能的演示系统 ⑵ 具体物理结构和数据元素类型自行选定 ⑶ 线性表数据可以使用磁盘文件永久保存
C语言线性表顺序存储结构实例详解
08-30
在计算机科学中，线性表是一种常见的数据结构，它的每个元素都有一个前驱和一个后继（除了...总之，线性表顺序存储结构是学习数据结构与算法不可或缺的一环，深入理解并灵活运用这一结构，将对编程能力的提升大有裨益。
《数据结构C++版》实验一：线性表的顺序存储结构实验报告
04-25
《数据结构C++版》实验一的目的是让学生深入理解线性表的顺序存储结构，并熟练掌握C++程序设计的基本技巧。在这个实验中，学生需要通过类的定义来实现线性表，数据对象的类型可以自定义。以下是实验涉及的主要知识点...
线性表的实现
振宇的博客
05-07 718
线性表
线性表代码的实现（最详细）
qq_53965368的博客
10-30 341
顺序表的存储结构 typedef struct List { int *date; int size; int length; }L; 构造线性表 void ListInit(L* ps) { ps->date = (int*)malloc(sizeof(L) * 4); if (ps == NULL) { cout << "创建失败" << endl; } else { cout << "创建成功"
数据结构之线性表的应用——完整代码实现
weixin_64618739的博客
11-15 1751
数据结构之线性表的应用——完整代码实现
数据结构—线性表实现代码
进阶中的程序员吃吃的博客
05-18 808
顺序表：typedef int Position; typedef struct LNode *List; struct LNode {     ElementType Data[MAXSIZE];     Position Last; };   /* 初始化 */ List MakeEmpty() {     List L;     L = (List)malloc(sizeof(struct ...
数据结构探险——线性表篇（代码实现）
xuyin1204的博客
05-25 701
imooc相关学习视频 1、什么是线性表？ 线性表是n个数据元素的有限序列。 2、应用场景 通讯录
线性表C语言实现代码
taotaobaobei的博客
01-26 9540
线性表特点 1)存在惟一的被称作“第一个”的数据元素 2)存在惟一的被称作最后一个”的数据元素 3)除第一个外,集合中每个数据元素均只有驱 4)除最后一个外,集合中每个数据元素只有个后继 根据存储方式不同,分为顺序存储结构与链式存储结构。 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素 #ifndef _LIST_H #define _LIST_H #define ...
线性表详解（代码演示）
Guqing_f的博客
04-26 500
1.顺序表 顺序表是指用一段连续的地址，依次存放数据元素的线性数据结构，这种存储方式使得顺序表的物理结构与逻辑结构都是连续的。 q1：这和平时再函数中定义的数组有什么区别？ ans1：函数中的数组被存放在栈段中，而栈段有系统限制的大小【ulimit -s】。因此顺序表往往使用再堆段中操作管理动态数组的方式实现。 （1）管理结点 如果把数据结构比作仓库，数据元素比作货物，除了货物之外，还应该有货物的数量，货架的数量等信息。要体现这些信息，就需要“管理结点”。 eg： ​ 顺序表中，管理结点内部一般存放：数据域
线性表的实现（C语言版）——详细代码
m0_63285686的博客
01-09 1万+
基于C语言实现的线性表（顺序表），在Devc++上进行了顺序表的增删改查基本操作的实现（附详细代码），本文介绍一下自己动手过程中的一些心得和这些代码的内容。提示：以下是本篇文章正文内容，下面案例可供参考#include //malloc()、free()和exit()函数在这个头文件之中int *data;//存放存储空间首地址的指针变量int length;//线性表当前的元素个数//线性表最大能存储的元素个数}Sqlist;
考研数据结构：C语言实现的线性表顺序存储
对于计算机科学与技术专业考研的学生来说，理解并掌握线性表顺序存储结构的实现，是数据结构课程的基础要求。通过该知识点的掌握，考生可以加强对数据存储方式的理解，为进一步学习链表、栈、队列等其它数据结构打下...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值