数据结构-线性表

已于 2023-01-23 21:49:35 修改
阅读量313 收藏
点赞数
分类专栏： C语言-数据结构 文章标签： 数据结构 链表
于 2023-01-15 14:57:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51333166/article/details/128694346
版权

1. 定义

线性表是由同一类型的数据元素构成的有序序列的线性结构。

2.实现

2.1 顺序存储：在内存中用地址连续的一块存储空间顺序存放线性表中的各个元素，用一维数组表示顺序存储的数据区域。

MAXSIZE： 定义的数组的容量，线性表中数据从Data[0]开始存放。
Last ： 记录线性表中最后一个元素的位置（数组下标）。表空时Last = -1。
struct LNode： 为了体现数据组织的整体性，将数组Data和Last封装成结构作为顺序表的类型。
typedef PtrToLNode List：由此，可以利用List定义线性表 List L；通过L可以访问相应内容 L->Data[i] , L ->Last

#define MAXSIZE 10
#define ERROR -1
// 线性表的顺序存储

typedef int ElementType;// Data数组中存放数据的类型
typedef int Position;
typedef struct LNode *PtrToLNode;
typedef PtrToLNode List; // List 定义为结构体指针

struct LNode {
    ElementType Data[MAXSIZE];
    Position Last;
};

基本操作：

  1. List MakeEmpty() ： 初始化线性表
  2. void PrintData(List L) ： 打印线性表Data中存储的所有内容
  3. bool Insert(List L,ElementType X, int i)： 插入元素，i为制定位序
  4. bool Delete(List L,int i)： 删除元素，i为指定位序
  5. Position Find(List L, ElementType X)： 查找元素
  6. int Length：返回线性表长度

完整代码

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

#define MAXSIZE 10
#define ERROR -1
// 线性表的顺序存储

typedef int ElementType;// Data数组中存放数据的类型
typedef int Position;
typedef struct LNode *PtrToLNode;
typedef PtrToLNode List; // List 定义为结构体指针

// 将数组Data和变量Last分装成一个结构体
struct LNode {
    ElementType Data[MAXSIZE];
    Position Last;
};

// 初始化线性表
List MakeEmpty() {
    List L; // 利用List定义线性表L,构建一个空表
    L = (List) malloc(sizeof(struct LNode)); // 动态分配表结构所需要的存储空间
    L->Last = -1; // 将表中Last指针置-1
    return L;    // 返回结构体指针
}

// 打印线性表中的数据
void PrintData(List L) {
    int i = 0;
    if(L->Last==-1) printf("表为空");
    while (i < L->Last + 1) {
        printf("%d ", L->Data[i]);
        i++;
    }
    printf("\n");
}

// 插入元素: 在L的制定位序i前插入一个新元素X,成功返回true,失败返回false(位序i元素的数组下标为i-1)
bool Insert(List L, ElementType X, int i) {
    // 先判断插入是否合法 1) 表空间是否已满 2）插入位序的合法性
    if (L->Last == MAXSIZE - 1 || i < 1 || i > L->Last + 2) {
        printf("插入失败\n");
        return false;
    }
    // i-1后的数都往后挪一位
    else{
        for (int j = L->Last; j >= i - 1; j--)
            L->Data[j + 1] = L->Data[j];
        L->Data[i - 1] = X;
        L->Last++;
        return true;
    }
}


// 删除元素: 给定位序i 删除数组中的i-1
bool Delete(List L,int i){
    // 先判断删除合法性
    if(i<1||i>L->Last){
        printf("表中不存在位序为 %d 的元素，删除失败",i);
        return false;
    }
    // 删除元素
    else{
        for(int j = i-1;j<=L->Last;j++)
            L->Data[j-1] = L->Data[j];
        L->Last --;
        return true;
    }
}

// 查找元素: 查找和X相等的元素, 返回数组下标
Position Find(List L, ElementType X){
    Position i = 0;
    while(i<=L->Last){
        if(L->Data[i] == X) return i;
        i++;
    }
    return ERROR;
}

// 返回列表长度
int Length(List L){
    return L->Last+1;
}


int main() {
    int findResult;
    int len;
    List list;

    list = MakeEmpty();

    Insert(list, 10, 1);
    Insert(list, 20, 2);
    Insert(list, 30, 3);
    Insert(list, 40, 4);
    Insert(list, 50, 5);
    PrintData(list);

    findResult = Find(list,30);
    printf("%d\n",findResult);
    Delete(list,1);
    PrintData(list);

    len = Length(list);
    printf("%d\n",len);


}

2.2 链式存储：与顺序存储相比，它不需要用地址连续的存储单元来实现，通过一个指针来连接各个分散的结点形成链状结构。每个结点存放一个元素以及指向下一节点的指针。链表可分为带头结点的链表和不带头结点的链表。

完整代码(带头节点的链表)

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

#define ERROR -1


typedef int ElementType;// Data数组中存放数据的类型
typedef struct LNode *PtrToLNode;
typedef PtrToLNode Position; // 这里的位置是结点的地址
typedef PtrToLNode List; // List 定义为结构体指针


// 将数组Data和变量Last分装成一个结构体
struct LNode {
    ElementType Data; // 保存当前元素
    PtrToLNode Next; // 指向下一个结点的指针
};


List MakeEmpty() {
    List L; // 利用List定义线性表L,构建一个空表
    L = (List) malloc(sizeof(struct LNode)); // 动态分配表结构所需要的存储空间
    L->Next = NULL; // 将表中Last指针置-1
    return L;    // 返回结构体指针
}

// 插入数据
bool Insert(List L, ElementType X, int index) {
    Position tmp, pre;
    int cnt = 0;

    pre = L; // pre指向表头
    while (pre && cnt < index - 1) {
        pre = pre->Next;
        cnt++;
    }
    if (pre == NULL || cnt != index - 1) {
        printf("插入位置错误\n");
        return ERROR;
    } else {
        tmp = (Position) malloc(sizeof(struct LNode));
        tmp->Data = X;
        tmp->Next = pre->Next;
        pre->Next = tmp;
        return true;
    }
}

// 删除数据
bool Delete(List L, int index) {
    Position tmp, pre;
    int cnt = 0;

    pre = L; // pre指向表头

    // 查找位序为index-1的结点
    while (pre && cnt < index - 1) {
        pre = pre->Next;
        cnt++;
    }
    if (pre == NULL || cnt != index - 1) {
        printf("删除位置错误\n");
        return ERROR;
    } else {
        tmp = pre->Next;
        pre->Next = tmp->Next;
        free(tmp);
        return true;
    }
}

// 返回线性表的长度
int Length(List L) {
    int cnt = 0;
    while (L) {
        L = L->Next;
        cnt++;
    }
    return cnt;
}

// 打印线性表中的数据
void PrintData(List L) {
    // 表头不放数据, 跳过表头读取
    while (L->Next) {
        L = L->Next;
        printf("%d", L->Data);
    }
    printf("\n");
}



int main() {
    List list;
    list = MakeEmpty();
    printf("线性表长度为 %d \n", Length(list));

    Insert(list, 1, 1);
    PrintData(list);
    Insert(list, 2, 2);
    PrintData(list);
    Insert(list, 4, 3);
    PrintData(list);
    printf("线性表长度为 %d \n", Length(list));

    Delete(list, 1);
    PrintData(list);
    printf("线性表长度为 %d \n", Length(list));
}

3 顺序表 vs 链表

  1. 链表在随机访问元素时需要通过遍历来完成，而顺序表利用数组特性直接访问得到
  2. 顺序表在插入元素时需要移动后续所有元素，而链表只需要修改结点指向即可完成插入

总结： 当读取数据多于插入删除数据时，用顺序表；当插入删除数据多于读取时，用链表。

我渊啊我渊啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-线性表-PPT
02-04
"数据结构-线性表-PPT" 数据结构是一门研究非数值计算的程序设计问题的学科，它研究的是计算机存储、表示、操作和保护非数值信息的方法和技术。线性表是数据结构的一种基本结构，它是一种线性结构，只有一个首结点...
数据结构（一）
qq_41320429的博客
01-16 630
文章目录单链表链表定义查询删除 单链表 链表定义 链表定义 * Definition for singly-linked list struct Node; typedef struct Node * PtrToNode; //简化数组指针定义方式 typedef PtrToNode List; //定义指向结构体Node的指针List 和Position typedef P...
单链表的建立
kuoyu12138的博客
11-17 1253
#include<stdio.h> #include<stdlib.h> typedef struct Node *ptrtonode; //为struct Node取别名为ptrtonode，可以直接用类型ptrtonode来定义指针变量 typedef ptrtonode List; //为ptrtonode取别名为List，可以直接用类型List类型来定义指针变量 typedef ptrtonode position; struct Node //定义单播
链表逆置(三种方法详解)
热门推荐
Achievek的博客
03-23 2万+
@Achievk 6-1 单链表逆转 （20 point(s)) 本题要求实现一个函数，将给定的单链表逆转。 ##函数接口定义： List Reverse( List L ); 其中List结构定义如下： typedef struct Node PtrToNode; struct Node { ElementType Data; / 存储结点数据 / PtrToNode Next; / 指向下...
【03】递增的整数序列链表的插入
WR的博客
10-02 1996
本题要求实现一个函数，在递增的整数序列链表（带头结点）中插入一个新整数，并保持该序列的有序性。 函数接口定义： List Insert( List L, ElementType X ); 其中List结构定义如下： typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Next; /* 指向下一个结点的指针 */ }; typedef PtrToNode List;
两个有序链表序列的合并
xiaoxiang22的专栏
09-30 589
本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。 函数接口定义： List Merge( List L1, List L2 ); 其中List结构定义如下： typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Ne...
数据结构-线性表的链式存储
最新发布
09-17
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型元素组成，按照线性顺序排列。在实际应用中，线性表的数据元素可以是数字、字符串、对象等各种类型。线性表的链式存储是数据结构课程中的核心概念...
数据结构-线性表的基本使用
10-26
线性表是数据结构中的基础概念，它是一种最简单但非常重要的数据组织形式。线性表是由n（n>=0）个相同类型元素构成的有限序列，这些元素在逻辑上是顺序排列的，可以通过索引访问。在计算机科学中，理解和掌握线性表...
数据结构-线性表-xmind思维导图
05-13
串、栈、队列的区分度在于数据的运算和逻辑结构，而他们的存储结构常用的都是顺序表和链表。 广义表和数组都是更抽象的线性表，数组对数据元素要求更严苛，广义表则是放开了数据元素的限定。他们都可以是递归定义，...
数据结构-线性表09
01-20
线性表是数据结构中的基础概念，它是一个包含零个或多个数据元素的有限序列，这些元素遵循特定的顺序规则。在线性表中，每个元素要么是序列的开头（无直接前驱），要么位于中间（有一个直接前驱和一个直接后继），...
单链表的基本操作（全）
weixin_55859275的博客
09-27 1640
#include<stdio.h> #include<stdlib.h> #define ERROR NULL typedef int ElemType; typedef struct LNode *PtrToLNode; typedef struct LNode { //对节点的定义 int Date; struct LNode *next; }LNode; typedef PtrToLNode List; typedef PtrToLNode Post.
typedef用法
qq_42835526的博客
07-22 2084
用于取别名 typedef 原名 新名 1⃣️给基本类型取别名 typedef int ElemType 以后可定义整型变量：ElemType a=0; 在c语言中： 2⃣️给结构体取别名 typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Next; /* 指向下一个结点的指针 */ }; typedef PtrToNode List; /* 定义单链表类型 *
【C】 typedef struct LNode * list
开发随笔-猫咪酱
12-28 5738
 typedef struct LNode * list表示定义了一个别名list，list代表struct LNode *类型的别名，它是一个指针类型。list a，就是定义了一个struct LNode *类型的变量a。   而struct LNode代表一个结构体类型。struct LNode a代表定义了struct LNode类型的变量a。   其详细理解如下所示： C语言   在C语言中： struct StructName 1   表示一个完整的类型名。就像int一样。区别是.
习题2.4 递增的整数序列链表的插入
royzdr的博客
01-03 3347
被一个小问题气死我了！！！！ while( (L->Next->Data Next)和 while(L->Next && (L->Next->Data 有什么不同？？？？！！！前一句在遇到L->Next为空时，直接就段错误。。。。。。 本题要求实现一个函数，在递增的整数序列链表（带头结点）中插入一个新整数，并保持该序列的有序性。 函数接口定义： Lis
6-1 单链表逆转 (20分)
weixin_43725617的博客
01-06 2935
文章目录问题解决方法将链翻转 问题 本题要求实现一个函数，将给定的单链表逆转。 函数接口定义： List Reverse( List L ); 其中List结构定义如下： typedef struct Node PtrToNode; struct Node { ElementType Data; / 存储结点数据 / PtrToNode Next; / 指向下一个结点的指针 / }; type...
两个有序链表序列的合并（c语言实现）
Sicilly的博客
07-30 2万+
题目 本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。 函数接口定义： List Merge( List L1, List L2 ); 其中List结构定义如下： typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Next;...
单链表基础知识详解
Jasmine的博客
07-06 660
//通常使用结构的嵌套来定义单向链表结点的数据类型 typedef struct Node *PtrToNode;//将Node命名为PtrToNode struct Node { ElementType Data;//存储结点数据 PtrToNode Next；//指向下一个结点的指针 }; //结构类型Node中的Next分量又是该结构类型的指针，称之为结构的递归定义 //为了阅读方便，我们将指针重命名为PtrToNode，即“指向Node的指针”的含义 //通常我们说给定一个单链表，
数据结构 - 线性表
09-13
线性表是一种常见的数据结构，它表示具有相同数据类型的一组元素的有序序列。线性表中的元素之间存在一种顺序关系，每个元素都有一个前驱和一个后继（除了第一个元素没有前驱，最后一个元素没有后继）。线性表可以用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值