数据结构 线性表

最新推荐文章于 2024-08-09 17:41:32 发布
最新推荐文章于 2024-08-09 17:41:32 发布
阅读量418 收藏 3
点赞数 10
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66605944/article/details/136934861
版权

  1. 顺序存储

零个或多个数据元素的有限序列

元素之间是有顺序了。如果存在多个元素，第一个元素无前驱，最有一个没有后继，其他的元素只有一个前驱和一个后继。

当线性表元素的个数n（n>=0）定义为线性表的长度，当n=0时，为空表。在非空的表中每个元素都有一个确定的位置，如果a1是第一个元素，那么an就是第n个元素。

线性表顺序存储的优点、缺点

优点

1、无需为表中的逻辑关系增加额外的存储空间

2、可以快速随机访问元素O(1)

缺点

1、插入，删除元素需要移动元素o(n)

2、无法动态存储。

内存泄露检测工具

sudo apt-get install valgrind

valgrind ./all

 seqlist.h                                       

#ifndef  _SEQLIST_H_
#define  _SEQLIST_H_  

typedef struct        person {
        char name[32];
        char sex;
        int age;
        int score;
        char word[100];
        char mean[100];
}DATATYPE;
typedef struct list {
        DATATYPE *head;
        int tlen;
        int clen;
}SeqList;

SeqList *CreateSeqList(int len);     //创建顺序表
int DestroySeqList(SeqList *list);   //销毁顺序表
int ShowSeqList(SeqList *list);      //遍历将内容输出到屏幕
int InsertTailSeqList(SeqList *list, DATATYPE *data);   //尾插
int IsFullSeqList(SeqList *list);     //判断顺序表是否满了
int IsEmptySeqList(SeqList *list);    //判断顺序表是否是空的
int InsertPosSeqList(SeqList *list, DATATYPE *data, int pos); //按位置插
int FindSeqList(SeqList *list, char *name);  //查找
int ModifySeqList(SeqList *list, char *old, DATATYPE *newdata);  //修改
int DeleteSeqList(SeqList *list, char *name);    //删除
int ClearSeqList(SeqList *list);       //清空
int GerSizeSeqList(SeqList*list);      //
DATATYPE*GetItemSeqList(SeqList *list,int pos);
#endif
 
seqlist.c
SeqList *CreateSeqList(int len)    //创建顺序表
{
        SeqList *s1 = (SeqList*)malloc(sizeof(SeqList));

        if(NULL== s1)
        {
                perror("CreateSeqList malloc");
                return NULL;
        }
        s1->head = (DATATYPE*)malloc(sizeof(DATATYPE)*len);
        if(NULL ==s1->head)
        {
                perror("CreateSeqList malloc 2");
                return NULL;
        }
        s1->tlen = len;
        s1->clen = 0;
        return s1;
}
int InsertTailSeqList(SeqList *list,DATATYPE *data)    //尾插
{
        if(IsFullSeqList(list))
        {
                return 1;
        }
        memcpy(&list->head[list->clen],data,sizeof(DATATYPE));
        list->clen++;
        return 0;
}
int IsFullSeqList(SeqList *list)  //判断顺序表是否满了
{
        return list->clen == list->tlen;
}
int GerSizeList(SeqList*list)     //得到clen的值
{
        return list->clen;
}
int ShowSeqList(SeqList *list)     //遍历将内容输出到屏幕
{
        int len = GerSizeList(list);
        int i = 0;
        for(i = 0;i < len;i++)
        {
                printf("%s %c %d %d\n",list->head[i].name,list->head[i].sex,list->head[i].age,list->head[i].score);

        }
        return 0;
}

int IsEmptySeqList(SeqList *list)    //判断顺序表是否为空
{
        return 0 == list->clen;
}
int InsertPosSeqList(SeqList *list,DATATYPE *data,int pos)   //按位置插
{
        if(IsFullSeqList(list))
        {
                return -1;
        }
        if(pos > list->clen)
        {
                return -1;
        }
        int i = 0;
        for(i = list->clen;pos < i;i--)
        {
                list->head[i] = list->head[i - 1];
        }
        memcpy(&list->head[pos],data,sizeof(DATATYPE));
        list->clen++;
        return 0;
}
int FindSeqList(SeqList *list,char *name)       //查找
{
        int len = GerSizeList(list);
        int i = 0;        
        for(i = 0;i < len;++i)
        {
                if(0 == strcmp(list->head[i].name,name))
                {
                        return i;
                }
        }
        return -1;
}

DATATYPE* GetItemSeqList(SeqList* list,int pos)  //查找到tom以后，得到tom一行的信息
{
        if(pos < 0 || pos >= list->clen)
        {
                return NULL;
        }
        return &list->head[pos];
}
int ModifySeqList(SeqList *list, char *old, DATATYPE* newdata)  //修改
{
        int ret = FindSeqList(list,old);
        if(-1 == ret)
        {
                return -1;
        }
        memcpy(&list->head[ret],newdata,sizeof(DATATYPE));
        return 0;

}
int ClearSeqList(SeqList *list)    //清空
{
        list->clen = 0;
        return 0;
}
int DestorySeqList(SeqList * list)   销毁顺序表
{
        free(list->head);
        free(list);
        return 0;
}
int DeleteSeqList(SeqList* list,char *name)   //删除
{
        int i = 0;
        int ret = FindSeqList(list,name);
        if(-1 == ret)
        {
                return 1;
        }
        for(i = ret;i < list->clen;i++)
        {
                list->head[i] = list->head[i+1];
        }
        list->clen--;
        return 0;
}
main.c

#include<stdio.h>
#include"seqlist.h"
int main(int argc,const char *argv[])
{
        DATATYPE data[]={
        {"tom",'m',20,90},
        {"terry",'m',21,90},
        {"liming",'m',22,91},
        {"zhnagsan",'m',20,80},
        {"lisi",'m',23,88},
        {"tony",'m',19,90},
        
        };
        SeqList * s1 = CreateSeqList(10);
        InsertTailSeqList(s1,&data[0]);
        InsertTailSeqList(s1,&data[1]);
        InsertTailSeqList(s1,&data[2]);
        ShowSeqList(s1);
        printf("---------pos-------\n");
        InsertPosSeqList(s1,&data[3],100);
        ShowSeqList(s1);

        printf("----------find------\n");
        int ret = FindSeqList(s1,"tom");
        if(-1 == ret)
        {
                printf("can not find\n");
        }
        else 
        {
                DATATYPE *tmp = GetItemSeqList(s1,ret);
                printf("%s %d\n",tmp->name,tmp->age);
        }
        printf("--------modify-------\n");
        ModifySeqList(s1,"liming",&data[1]);
        ShowSeqList(s1);
        printf("----------delete-----\n");
        DeleteSeqList(s1,"tom");
        ShowSeqList(s1);

        DestroySeqList(s1);

        return 0;
}

  1. 链式存储

解决顺序存储的缺点，插入和删除，动态存储问题。

特点：

线性表链式存储结构的特点是一组任意的存储单位存储线性表的数据元素，存储单元可以是连续的，也可以不连续。可以被存储在任意内存未被占用的位置上。

所以前面的顺序表只需要存储数据元素信息就可以了。在链式结构中还需要一个元素存储下一个元素的地址。

为了表示每个数据元素，ai与其直接后继数据元素ai+1之间的逻辑关系，对ai来说，除了存储其本身的信息外，还需要存一个指示器直接后续的信息。把存储元素信息的域叫数据域，把存储直接后继位置的域叫指针域。这两部分信息组成数据元素ai的存储映像，叫结点(Node);

无头链表

有头链表：多一个空白表头

DouLinkList.h

#ifndef  _DOULINKLIST_H_
#define  _DOULINKLIST_H_

typedef struct person {
        char name[32];
        char sex;
        int age;
        int score;
}DATATYPE;
typedef enum {FORWARD,BACKWARD}DIRECT;
typedef struct dou_node {
        DATATYPE data;
        struct dou_node *next,*prev;
}DouLinkNode;

typedef struct list {
        DouLinkNode *head;
        int clen;
}DouLinkList;

typedef int (*pFun)(DATATYPE*data,void* arg);

DouLinkList *CreateLinkList();    //创建链表
int InsertHeadLinkList(DouLinkList *list, DATATYPE *data);   //头插
int ShowLinkList(DouLinkList *list,DIRECT dire);   //遍历将内容显示在屏幕上
//DouLinkNode *FindLinkList(DouLinkList *list, char *name);
DouLinkNode *FindLinkList(DouLinkList *list, pFun fun,void *arg); //查找
int InsertTailLinkList(DouLinkList *list, DATATYPE*data);  //尾插
int InsertPosLinkList(DouLinkList *list, DATATYPE*data,int pos);   //按位置插
int DeleteLinkList(DouLinkList *list, pFun fun,void *arg);   //删除
int ModifyLinkList(DouLinkList *list,pFun fun,void * arg,DATATYPE *data); //修改
int DestroyLinkList(DouLinkList *list);   //销毁链表
int IsEmptyLinkList(DouLinkList*list);    //判断链表是否为空
int GetSizeDouLinkList(DouLinkList *list);   //得到clen的值
#endif
DouLinkList.c

#include"./seqlist.h"
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
SeqList *CreateSeqList(int len)
{
        SeqList *s1 = (SeqList*)malloc(sizeof(SeqList));

        if(NULL== s1)
        {
                perror("CreateSeqList malloc");
                return NULL;
        }
        s1->head = (DATATYPE*)malloc(sizeof(DATATYPE)*len);
        if(NULL ==s1->head)
        {
                perror("CreateSeqList malloc 2");
                return NULL;
        }
        s1->tlen = len;
        s1->clen = 0;
        return s1;
}
int InsertTailSeqList(SeqList *list,DATATYPE *data)
{
        if(IsFullSeqList(list))
        {
                return 1;
        }
        memcpy(&list->head[list->clen],data,sizeof(DATATYPE));
        list->clen++;
        return 0;
}
int IsFullSeqList(SeqList *list)
{
        return list->clen == list->tlen;
}
int GerSizeList(SeqList*list)
{
        return list->clen;
}
int ShowSeqList(SeqList *list)
{
        int len = GerSizeList(list);
        int i = 0;
        for(i = 0;i < len;i++)
        {
                printf("%s %c %d %d\n",list->head[i].name,list->head[i].sex,list->head[i].age,list->head[i].score);

        }
        return 0;
}

int IsEmptySeqList(SeqList *list)
{
        return 0 == list->clen;
}
int InsertPosSeqList(SeqList *list,DATATYPE *data,int pos)
{
        if(IsFullSeqList(list))
        {
                return -1;
        }
        if(pos > list->clen)
        {
                return -1;
        }
        int i = 0;
        for(i = list->clen;pos < i;i--)
        {
                list->head[i] = list->head[i - 1];
        }
        memcpy(&list->head[pos],data,sizeof(DATATYPE));
        list->clen++;
        return 0;
}
int FindSeqList(SeqList *list,char *name)
{
        int len = GerSizeList(list);
        int i = 0;        
        for(i = 0;i < len;++i)
        {
                if(0 == strcmp(list->head[i].name,name))
                {
                        return i;
                }
        }
        return -1;
}

DATATYPE* GetItemSeqList(SeqList* list,int pos)
{
        if(pos < 0 || pos >= list->clen)
        {
                return NULL;
        }
        return &list->head[pos];
}
int ModifySeqList(SeqList *list, char *old, DATATYPE* newdata)
{
        int ret = FindSeqList(list,old);
        if(-1 == ret)
        {
                return -1;
        }
        memcpy(&list->head[ret],newdata,sizeof(DATATYPE));
        return 0;

}
int ClearSeqList(SeqList *list)
{
        list->clen = 0;
        return 0;
}
int DestorySeqList(SeqList * list)
{
        free(list->head);
        free(list);
        return 0;
}
int DeleteSeqList(SeqList* list,char *name)
{
        int i = 0;
        int ret = FindSeqList(list,name);
        if(-1 == ret)
        {
                return 1;
        }
        for(i = ret;i < list->clen;i++)
        {
                list->head[i] = list->head[i+1];
        }
        list->clen--;
        return 0;
}

main.c

#include <stdio.h>
#include "DouLinkList.h"
#include <string.h>
int findbyname(DATATYPE* data,void* arg)
{
    return 0 == strcmp(data->name,(char*)arg);
}
int findbyage(DATATYPE* data,void* arg)
{
    return data->age == *(int*)arg;
}
int main(int argc, char *argv[])
{
    
    DouLinkList* ll =CreateLinkList();

    DATATYPE data[]={
        {"zhansan",'m',20,90},
        {"lisi",'f',22,87},
        {"wangmazi",'m',21,93},
        {"guanerge",'m',40,60},
        {"liuei",'m',42,83},
    };
    InsertHeadLinkList(ll,&data[0]);
    InsertHeadLinkList(ll,&data[1]);
    InsertHeadLinkList(ll,&data[2]);

    ShowLinkList(ll,FORWARD );
    printf("-------back-------------\n");
    ShowLinkList(ll,BACKWARD);


    //DouLinkNode* ret = FindLinkList(ll, "zhansan");
   // DouLinkNode* ret = FindLinkList(ll,findbyname,"zhansan");
    int age = 20;
    DouLinkNode* ret = FindLinkList(ll,findbyage,&age);
    if(NULL == ret)
    {
        printf("can't find\n");
    }
    else 
    {
        printf("find it,%s %d\n",ret->data.name,ret->data.score);
    }

    printf("-------------tail--------------\n");
    InsertPosLinkList(ll,&data[3],2);
    ShowLinkList(ll,FORWARD );
    printf("-------back-------------\n");
    ShowLinkList(ll,BACKWARD);

    printf("-------------del--------------\n");
    DeleteLinkList(ll,findbyname,"zhansan");
    ShowLinkList(ll,FORWARD );
    printf("-------back-------------\n");
    ShowLinkList(ll,BACKWARD); 

    printf("------modify------\n");
    ModifyLinkList(ll,findbyname,"zhansan",&data[4]);
    ShowLinkList(ll,FORWARD);
    printf("-------back------\n");
    ShowLinkList(ll,FORWARD);

    printf("--------destroy----\n");
    DestroyLinkList(ll);
   // ShowLinkList(ll,FORWARD);
    printf("-------back------\n");
  //  ShowLinkList(ll,FORWARD);

    return 0;
}

  1. 总结

顺序表和链表 优缺点

  1. 存储方式：

顺序表是一段连续的存储单元

链表是逻辑结构连续物理结构（在内存中的表现形式）不连续

  1. 时间性能

查找 顺序表O(1) 链表 O(n)

插入和删除 顺序表 O(n) 链表 O(1)

  1. 空间性能

顺序表： 需要预先分配空间，大小固定

链表 ：不需要预先分配，大小可变，动态分配

  1. 循环链表

简单的来说，就是将原来单链表中最有一个元素的next指针指向第一个元素或头结点，链表就成了一个环，头尾相连，就成了循环链表。circultlar linker list.

注意非空表，和空表。多数会加入头结点。

原来结束的条件是 : p->next != NULL ------->>>>> p-next != Head

青栀..
关注
  • 10
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构线性表
04-08
线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。
c语言数据结构线性表创建删除插入
06-30
本主题聚焦于C语言中的数据结构——线性表，这是数据结构的基础概念之一，适用于初学者学习。线性表是一种逻辑上一维、元素之间具有线性关系的数据结构。下面将详细阐述线性表的创建、删除和插入操作。 1. **线性表...
数据结构线性表基本操作
热门推荐
lizhi20210729的博客
11-20 1万+
数据结构线性表基本操作基本内容线性表的顺序表示和实现线性表的顺序存储表示顺序表中基本操作的实现 基本内容 因为第一次数据结构阶段考写代码又想规范写又写不出规范的可读性强的代码，让我第一次意识到自己应该在这方面下一些功夫。这篇文章是记录自己把书上写的算法打到电脑上遇到的问题。 线性表的顺序表示和实现 线性表的顺序存储表示 将书中代码复刻如下： #define MAXSIZE 100//顺序表可能达到的最大长度 typedef struct { ElemType *elem;//储存空间的基地址
C语言数据结构线性表
qq_55391702的博客
01-17 798
线性表线性表的类型定义 线性表的类型定义 线性表是常用且最简单的一种数据结构。简言之一个线性表是n个数据元素的有限序列。至于每个数据元素的具体含义，在不同的情况下各不相同，它可以是一个数一个符号也可以是一页书，甚至是其他更复杂的信息。 ...
数据结构 线性表 插入 删除
mmmm0303的博客
04-22 1万+
数据结构线性表的插入，删除 任务描述 本关任务：实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数，以实现线性表中数据的插入、删除与查找等功能。 相关知识) 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存...
数据结构——线性表
qq_52434831的博客
04-24 2891
数据结构线性表的基础知识及常用算法的总结
数据结构：线性表
y_h_k_666的博客
03-28 2765
线性表是基本的数据结构之一，是一组元素的抽象。 线性表包含顺序表和链接表（简称链表），顺序表在C语言中一般使用数组去实现，链表使用结构体去实现。在Python中，list对象是采用顺序表实现的。 1. 顺序表 顺序表是将表中的元素顺序的存储在连续的内存里。 优点： 查询速度快，时间复杂度为O(1) 缺点： 插入元素速度慢，时间复杂度为O(n) 表中元素个数需要提前定义 2. 链表 链表：通过链接各个结点实现的技术就叫做链表。链表中的结点分为指针域和数据域，具体见下图。结点中的data用来存放数据
数据结构线性表元素的删除
qq_46153158的博客
09-24 2740
线性表的创建，元素的删除 #include<stdio.h> #define MAXSIZE 100 typedef int ElemType; /*定义线性表*/ typedef struct { ElemType list[MAXSIZE];//顺序表元素 int last; //顺序表当前长度 }SeqList; /*创建空表*/ void InitList(SeqList *L) { L->last=-1; } /*输入递增有序顺序表*/ void Pu
【数据结构线性表练习题】
爱喝阔落的猫的博客
07-18 951
代码】【数据结构线性表练习题】
数据结构线性表的定义、初始化和创建
qq_48471248的博客
07-29 1941
SqList//该语句表示这是一个顺序表。intlength;//顺序表的当前长度。intdata[MaxSize];//设置为用数组存放元素。//初始化一个顺序表。
数据结构线性表的C语言代码
06-27
适合学习数据结构的同学
【归并排序/快排/堆排序】912. 排序数组
m0_63530048的博客
08-07 333
维护大顶堆：从下往上，第一个有孩子节点的节点开始，取根节点、左孩子、右孩子之间的最大值 换到根节点处
排序算法3：归并排序与计数排序
2302_79964175的博客
08-08 531
Hello，小伙伴们，今天我们继续排序算法的学习，大家三连上车不迷路，我们现在开始今天的学习！！！
数据结构--第六天
xujiashuo1的博客
08-08 1244
树是由。
【深度学习】P1 深度学习数据结构
weixin_43098506的博客
08-07 757
深度学习的数据结构——张量的概念与其基本操作
数据结构 JAVADS ——部分栈题目分享 (持续更新版)
cjejwe的博客
08-09 764
让我们看看这个代码(C++ 版本)
内存池数据结构
最新发布
qq_61531048的博客
08-09 390
这样一来，每次获取空闲块直接从表头拿就行了，时间复杂的是明确的 O(1)。被分离出的空闲块指针位指向 pool 对象本体，便于后续“物归”时找到“原主”“空闲中”**的内存块并不刚好是物理有序的前后状态。比如内存块1使用中，内存块2空闲，内存块3使用中……上述情况下，当用户需要获取一个空闲的内存块时，若是按物理连续的逻辑来找**“空闲中”内存池是由一个个固定大小的内存块组成，所以应用每次获取的内存块长度是固定的。一个池子内的所有内存块都是物理上连续的，但常常会出现**“使用中”此内存池方案参考来源为。
数据结构线性表解析：公式化、链接、间接寻址与模拟指针
"C++数据结构线性表003" 在C++中，数据结构是编程中的一个重要概念，它涉及到如何有效地组织和管理数据。线性表是数据结构中最基础且常用的一种，本章主要探讨了四种描述线性表的方法，以及它们在实现常见操作（如...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值