数据结构：线性表定义与特点、抽象数据类型

于 2024-07-29 22:47:41 发布
阅读量216 收藏 3
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79730293/article/details/140783067
版权

线性表定义与特点、抽象数据类型

线性表的定义

线性表是指具有相同数据类型的 n 个数据元素的有限序列。可以用如下方式表示：

[ L = (a_1, a_2, …, a_i, …, a_n) ]

其中：

  • ( a_1 ) 是第一个元素，称为表头。
  • ( a_n ) 是最后一个元素，称为表尾。
  • 对于任意元素 ( a_i )，它有且仅有一个前驱元素 ( a_{i-1} )（除第一个元素）和一个后继元素 ( a_{i+1} )（除最后一个元素）。

线性表的特点

  1. 有序性：线性表中的元素按逻辑顺序排列，即每个元素有且仅有一个前驱和一个后继。
  2. 唯一性：每个元素在表中的位置是唯一的。
  3. 有限性：线性表中元素的个数是有限的。
  4. 类型一致性：线性表中的所有元素具有相同的数据类型。

线性表的抽象数据类型（ADT）

抽象数据类型（ADT）是一个数学模型及定义在该模型上的一组操作。对于线性表，其抽象数据类型的描述包括数据对象、数据关系以及操作。

数据对象

线性表中的数据对象是具有相同类型的数据元素的有序序列。

数据关系

线性表中的数据元素之间存在前驱和后继关系，即对任意元素 ( a_i )，有一个前驱元素 ( a_{i-1} ) 和一个后继元素 ( a_{i+1} )（除第一个和最后一个元素）。

操作

线性表的基本操作包括：

  1. 初始化：创建一个空的线性表。
  2. 销毁：销毁线性表，释放其占用的内存空间。
  3. 插入：在指定位置插入一个元素。
  4. 删除：删除指定位置的元素。
  5. 查找：查找并返回指定元素的位置。
  6. 取值：获取指定位置的元素。
  7. 修改：修改指定位置的元素。
  8. 长度：返回线性表的长度（元素个数）。
  9. 判空：判断线性表是否为空。

顺序存储结构的实现

顺序存储结构是用一组地址连续的存储单元依次存储线性表中的各个元素，通常使用数组来实现。

以下是线性表的顺序存储结构及其操作的详细实现示例：

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

#define MAXSIZE 100  // 线性表的最大长度

typedef int ElemType;  // 定义线性表中的元素类型

typedef struct {
    ElemType data[MAXSIZE];  // 存储线性表的元素
    int length;              // 线性表的当前长度
} LinearList;

// 初始化线性表
void InitList(LinearList *L) {
    L->length = 0;  // 初始化长度为0
}

// 销毁线性表
void DestroyList(LinearList *L) {
    // 对于顺序存储结构，不需要额外释放内存
    L->length = 0;
}

// 插入元素
bool InsertElement(LinearList *L, int position, ElemType element) {
    if (position < 1 || position > L->length + 1) {
        return false;  // 插入位置不合法
    }
    if (L->length == MAXSIZE) {
        return false;  // 线性表已满
    }
    for (int i = L->length; i >= position; i--) {
        L->data[i] = L->data[i - 1];  // 元素后移
    }
    L->data[position - 1] = element;  // 插入元素
    L->length++;  // 长度加1
    return true;
}

// 删除元素
bool DeleteElement(LinearList *L, int position) {
    if (position < 1 || position > L->length) {
        return false;  // 删除位置不合法
    }
    for (int i = position; i < L->length; i++) {
        L->data[i - 1] = L->data[i];  // 元素前移
    }
    L->length--;  // 长度减1
    return true;
}

// 查找元素
int LocateElement(LinearList *L, ElemType element) {
    for (int i = 0; i < L->length; i++) {
        if (L->data[i] == element) {
            return i + 1;  // 返回位置，位置从1开始
        }
    }
    return 0;  // 元素不存在
}

// 获取元素
ElemType GetElement(LinearList *L, int position) {
    if (position < 1 || position > L->length) {
        exit(EXIT_FAILURE);  // 位置不合法，退出程序
    }
    return L->data[position - 1];
}

// 修改元素
bool SetElement(LinearList *L, int position, ElemType element) {
    if (position < 1 || position > L->length) {
        return false;  // 修改位置不合法
    }
    L->data[position - 1] = element;
    return true;
}

// 获取线性表长度
int ListLength(LinearList *L) {
    return L->length;
}

// 判断线性表是否为空
bool IsEmpty(LinearList *L) {
    return L->length == 0;
}

int main() {
    LinearList list;
    InitList(&list);

    // 插入元素
    InsertElement(&list, 1, 10);
    InsertElement(&list, 2, 20);
    InsertElement(&list, 3, 30);

    // 输出线性表长度
    printf("线性表长度: %d\n", ListLength(&list));

    // 获取并输出第2个位置的元素
    printf("第2个位置的元素: %d\n", GetElement(&list, 2));

    // 修改第2个位置的元素
    SetElement(&list, 2, 25);

    // 删除第1个位置的元素
    DeleteElement(&list, 1);

    // 查找元素
    int pos = LocateElement(&list, 30);
    if (pos) {
        printf("元素30的位置: %d\n", pos);
    } else {
        printf("元素30不存在\n");
    }

    // 判断线性表是否为空
    printf("线性表是否为空: %d\n", IsEmpty(&list));

    DestroyList(&list);
    return 0;
}

链式存储结构的实现

链式存储结构是用一组任意的存储单元存放线性表中的元素，不要求地址连续，通过指针将这些存储单元链接起来。

以下是线性表的链式存储结构及其操作的详细实现示例：

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

typedef int ElemType;  // 定义线性表中的元素类型

typedef struct Node {
    ElemType data;       // 存储元素
    struct Node *next;   // 指向下一个节点的指针
} Node;

typedef struct {
    Node *head;  // 头指针，指向链表的第一个节点
    int length;  // 链表的长度
} LinkedList;

// 初始化链表
void InitList(LinkedList *L) {
    L->head = (Node *)malloc(sizeof(Node));  // 创建头节点
    L->head->next = NULL;  // 头节点指针域置空
    L->length = 0;  // 初始化长度为0
}

// 销毁链表
void DestroyList(LinkedList *L) {
    Node *p = L->head;
    while (p) {
        Node *temp = p;
        p = p->next;
        free(temp);
    }
    L->length = 0;
}

// 插入元素
bool InsertElement(LinkedList *L, int position, ElemType element) {
    if (position < 1 || position > L->length + 1) {
        return false;  // 插入位置不合法
    }
    Node *p = L->head;
    int i = 0;
    while (i < position - 1) {
        p = p->next;
        i++;
    }
    Node *newNode = (Node *)malloc(sizeof(Node));  // 创建新节点
    newNode->data = element;
    newNode->next = p->next;
    p->next = newNode;
    L->length++;
    return true;
}

// 删除元素
bool DeleteElement(LinkedList *L, int position) {
    if (position < 1 || position > L->length) {
        return false; 

 // 删除位置不合法
    }
    Node *p = L->head;
    int i = 0;
    while (i < position - 1) {
        p = p->next;
        i++;
    }
    Node *temp = p->next;
    p->next = temp->next;
    free(temp);
    L->length--;
    return true;
}

// 查找元素
int LocateElement(LinkedList *L, ElemType element) {
    Node *p = L->head->next;
    int position = 1;
    while (p) {
        if (p->data == element) {
            return position;
        }
        p = p->next;
        position++;
    }
    return 0;  // 元素不存在
}

// 获取元素
ElemType GetElement(LinkedList *L, int position) {
    if (position < 1 || position > L->length) {
        exit(EXIT_FAILURE);  // 位置不合法，退出程序
    }
    Node *p = L->head->next;
    int i = 1;
    while (i < position) {
        p = p->next;
        i++;
    }
    return p->data;
}

// 修改元素
bool SetElement(LinkedList *L, int position, ElemType element) {
    if (position < 1 || position > L->length) {
        return false;  // 修改位置不合法
    }
    Node *p = L->head->next;
    int i = 1;
    while (i < position) {
        p = p->next;
        i++;
    }
    p->data = element;
    return true;
}

// 获取链表长度
int ListLength(LinkedList *L) {
    return L->length;
}

// 判断链表是否为空
bool IsEmpty(LinkedList *L) {
    return L->length == 0;
}

int main() {
    LinkedList list;
    InitList(&list);

    // 插入元素
    InsertElement(&list, 1, 10);
    InsertElement(&list, 2, 20);
    InsertElement(&list, 3, 30);

    // 输出链表长度
    printf("链表长度: %d\n", ListLength(&list));

    // 获取并输出第2个位置的元素
    printf("第2个位置的元素: %d\n", GetElement(&list, 2));

    // 修改第2个位置的元素
    SetElement(&list, 2, 25);

    // 删除第1个位置的元素
    DeleteElement(&list, 1);

    // 查找元素
    int pos = LocateElement(&list, 30);
    if (pos) {
        printf("元素30的位置: %d\n", pos);
    } else {
        printf("元素30不存在\n");
    }

    // 判断链表是否为空
    printf("链表是否为空: %d\n", IsEmpty(&list));

    DestroyList(&list);
    return 0;
}
凭君语未可
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构学习笔记二 ：线性表定义及基本操作
qq_37412281的博客
11-24 418
数据结构学习笔记二 ：线性表定义及基本操作一、线性表的定义和基本操作（1）线性表的定义1.1 生活中的线性表1.2 线性表的定义（逻辑结构）1.3 线性表的特点1.4 线性表的基本操作 一、线性表的定义和基本操作 （1）线性表的定义 1.1 生活中的线性表 之前学习数据结构基本概念是说过，数据结构就是把我们日常生活中发生的琐碎事情信息化。将数据通过计算机反映出来，帮助我们更便捷的解决问题。 小时候， 我特别喜欢吃西四的冷面，每次去吃都需要排很长很长的队伍，从点餐需要排队，取餐也需要排队，基本上就是排队一小时
数据结构与算法笔记-线性表定义和特点
01-07
线性表的定义和特点 # 定义： 由n (n>0)个数据特性相同的元素构成的有限序列称为线性表。 # 对于非空线性表或者线性...一、下列给出线性表的抽象数据类型定义： ADT 线性表 （list） Data 线性表的数据对象集合为{a1,a
数据结构：线性表(List)【详解】
热门推荐
UniqueUnit的博客
02-18 11万+
线性表 一、线性表的定义 线性表（List）：零个或多个数据元素的有限序列。 线性表的数据集合为{a1,a2,…,an}，假设每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。 在较复杂的线性表中，一个数据元素可以由若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称为文件 二、线性表的顺序标识和实现 概念：用一组地址连续的存储单元依次存储
数据结构：线性表
梁辰兴的博客
03-21 1941
线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点）。
数据结构笔记（二）：线性表的抽象和代码实现
晓风残月淡的博客
08-04 463
ADT List {数据对象：{ai|ai∈ElemSet,i=1,2,...,n,n≥0}数据关系：{|ai-1,ai∈D,i=2,...,n}基本操作：操作结果：构造一个空的线性表L初始条件：线性表已存在操作结果：销毁线性表L初始条件：线性表L操作结果：将L重置为空表初始条件：线性表L已存在操作结果：若L为空表，则返回true，否则返回false初始条件：线性表L已存在操作结果：返回L中数据元素个数初始条件：线性表L已存在。..............................
数据结构——线性表的类型定义
壮壮Loschicos
08-07 1297
数据结构—线性表笔记—线性表的类型定义
【实验一】数据结构：线性表
weixin_49003900的博客
11-06 2718
数据结构，实验一，线性表，内容：递增有序顺序表的插入、两个有序链表序列的交集、简单计算器、银行业务队列简单模拟
数据结构：线性表的顺序存储与链式存储
Rain的博客
02-23 1万+
文章目录一、线性表的基本概念二、动态数组(顺序表)的实现与测试 一、线性表的基本概念 线性表：线性表是零个或者多个数据元素的有限序列，是最常用且最简单的一种数据结构。 特点： (1)存在惟一的一个被称做“第一个”的数据元素。 (2)存在惟一的一个被称做“最后一个”的数据元素。 (3)除第一之外，集合中每个元素均只有一个前驱。 (4)除最后一个之外，集合中每个数据元素均只有一个后继。 数学语言来定义...
线性表的定义和抽象数据类型
一个搬运知识的笨小孩
07-20 1316
1.线性表的定义 线性表（List）：0个或多个数据元素的有限序列 2.线性表的抽象数据类型定义 ADT List{ 数据对象a_i 数据关系a_{i-1}和a_i 基本操作： InitList(&L) //构造一个空的线性表L DestroyList(&L) //销毁线性表L ClearList(&L) //将线性表L置为空表 ListEmpty(L) //判断线性表是否为空，若L为空，返回true ListLength(L) //返回L中数据元素个数 G
线性表的定义与特点及抽象数据类型定义
gets_s的博客
02-26 3026
一、线性表的定义 由n(n>=0)个数据特性相同的元素构成的有限序列称为线性表。 线性表中元素的个数n(n>=0)定义为线性表的长度，n=0时线性表称为空表。 二、非空线性表及线性结构的特点 1、存在唯一的一个被称为“第一个”的数据元素； 2、存在唯一的一个被称为“最后一个”的数据元素； 3、除第一个结点外，剩余的每个数据元素都只有一个前驱； 4、除最后一个结点外，剩余的每个数据元素都...
数据结构之线性表的定义 定义线性表节点的结构.pdf
04-18
数据结构之线性表的定义和结构 数据结构是计算机科学中的一门重要学科...线性表是数据结构中最基本和最重要的一种数据结构形式，它的定义、逻辑结构和物理结构、抽象数据类型等知识点都是计算机科学中重要的基础知识。
数据结构：第2章线性表.pdf
06-12
数据结构：第2章线性表 本章主要讲解了线性表的概念、逻辑结构、顺序存储和链式存储、应用等...本章对线性表的概念、逻辑结构、顺序存储和链式存储进行了详细的讲解，并提供了线性表的抽象数据类型描述和基本运算。
数据结构：第2章 线性表.ppt
06-12
线性表的抽象数据类型ADT定义了它的数据对象、数据关系和基本运算。数据对象D由一系列的数据元素构成，如D={a1, a2, a3, ..., an}。数据关系R表示元素之间的顺序关系，例如R={, a2>, , a3>, ..., , an>}。基本运算...
数据结构：第2章线性表B.ppt
06-12
线性表的抽象数据类型（ADT）定义了数据对象D和数据关系R，以及一系列基本操作，包括初始化、撤销、清空、判空、求表长、表头、表尾、前趋、后继、读元素、查找、遍历、插入和删除等。这些操作提供了对线性表的通用...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 267
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 405
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
java算法原理
jylee的博客
07-25 834
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
数据结构的概念和术语
2303_78660417的博客
07-24 524
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科。数据结构的基本数据结构包括两部分，线性结构跟非线性结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值