数据结构系列文章—线性结构

最新推荐文章于 2024-06-26 22:39:02 发布
最新推荐文章于 2024-06-26 22:39:02 发布
阅读量313 收藏 7
点赞数 5
文章标签： 数据结构 嵌入式硬件 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68495605/article/details/137993990
版权

线性结构

前言

//嵌入式入门必学，
//文章中用到的Linux版本——Ubuntu18.04
//本文章旨在通过项目程序，掌握线性结构-动态顺序表

什么是数据结构

//数据：现实生活中的一切事物 
​
//结构：逻辑结构和存储结构
​
//研究的是数据的逻辑结构、存储结构及其操作（创销增删改查）

为什么学习数据结构

//学习C语言目的是：写程序
//而学习数据结构的目的是：高效的写程序

结构

逻辑结构

存储结构

顺序存储：
    逻辑上连续的数据，在物理空间上也连续
——（计算机上）
    
链式存储：
    逻辑上连续的数据,在物理空间上不一定连续
——（计算机上）
    
索引存储：
    有索引表，索引表占有一定的空间
    根据索引表找数据，插入数据、删除数据要更新索引表
    索引表本身占空间
    插入数据和删除数据之后要更新索引表，时间开销大，查找方便，插入和删除不方便
——(数据结构上)
    
哈希存储：
    根据关键字就能定位到记录本身，查询方便，插入删除方便
    哈希函数设置的不合理，哈希存储会降维成索引存储
——(数据结构上)

项目

动态顺序表

1、创建目录

创建ListBak目录，包含子目录bin目录、include目录、obj目录、src目录、子文件Makefile文件

详细如下图

2、头文件

myhead.h
#ifndef _MYHEAD_H
#define _MYHEAD_H
//相关的头文件
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//文件相关
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
​
//相关的定义
//定义数据类型
/*
typedef struct student
{
    char name[20];
    char id[20];
    char add[20];
    int age;
}data_type;
 */
//简化操作，将int data_type
typedef int data_type;
//定义顺序表
typedef struct list
{
    data_type *Data;
    int size;
    int count;
}List;
​
//返回值
typedef enum ret{
    /* member*/
    LIST_NULL = -4,
    POS_ERR,
    LIST_FULL,
    LIST_EMPTY,
    OK,
​
} ret_e;
​
//相关函数声明
//打印菜单
//函数返回值：获取的选项
int Menu(void);
​
//函数定义：
//函数功能：创建顺序表
//函数参数：void
//函数返回值：成功返回表的地址，失败返回NULL
List *CreateList(void);
​
//函数功能：插入元素
//函数参数：给谁插入，插入的位置，插入的值
//函数返回值：成功返回OK，失败返回失败原因(错误信息)
int InsertItem(List *pList,int pos,data_type item);
​
​
//函数功能：显示所有的元素
//函数参数：被显示元素的表
//函数返回值：成功返回OK，失败返回失败原因
int ShowList(List *pList);
​
//函数功能：查询元素
//函数参数：查哪个表，表的元素
//函数返回值：成功返回查到的元素，失败返回失败原因
int Search(List *pList,data_type item);
​
//函数功能：删除元素
//函数参数：被删除元素的表，删除的位置，删除的值
//函数返回值：成功返回OK，失败返回失败原因
int DeleteItem(List *pList,int pos,data_type *item);
​
//函数功能：销毁空间
//函数参数：要销毁的表
//函数返回值：成功返回OK，失败返回失败原因
int DestoryList(List **pList);
​
//函数功能：保存
//函数参数：要保存的表
//函数返回值：成功返回OK，失败返回失败原因
int Save(List *pList);
​
//函数功能：导入
//函数参数：
//函数返回值：
List *LoadList(List *pList);
​
//函数功能：修改元素
//函数参数：被修改元素的表，旧元素，新元素
//函数返回值：成功返回OK，失败返回失败原因
int ModifyItem(List *pList,data_type old_item,data_type new_item);
#endif

3、源代码文件

main.c
#include"../include/myhead.h"
​
int main(int argc, const char *argv[])
{
    //表
    List *pList = NULL;
    //定义选项
    int opt = 0;
    //定义插入位置
    int pos = 0;
    //定义插入元素
    data_type item = 0;
    //接返回值
    int ret = 0;
    //定义修改函数旧元素，新元素变量
    data_type old_item = 0;
    data_type new_item = 0;
​
    //打印目录 Menu()
    while(1)
    {
        opt = Menu();
        if(-1 == opt) break;//退出
        switch(opt)
        {
            case 1:
                //insert
                printf("请输入要插入的位置和元素,尾插(pos=-1)：");
                scanf("%d%d",&pos,&item);
                ret = InsertItem(pList,pos,item);
                break;
            case 2:
                //delete
                printf("请输入要删除的位置(尾删 -1)：");
                scanf("%d",&pos);//小Bug:用户输入5的位置，实际删除6的位置
                ret = DeleteItem(pList,pos,&item);
                if(!ret)    printf("删除的：%d:\n",item);
                break;
            case 3:
                //search
                printf("请输入要查询的元素：");
                scanf("%d",&item);
                ret = Search(pList,item);
                break;
            case 4:
                //modify(修改元素)
                printf("请输入被修改的元素与修改后的元素：");
                scanf("%d %d",&old_item,&new_item);
                ret = ModifyItem(pList,old_item,new_item);
                break;
            case 5:
                //show
                ret = ShowList(pList);
                break;
            case 6:
                //save
                ret = Save(pList);
                break;
            case 7:
                //load
                pList = LoadList(pList);
                break;
            case 8:
                //destory
                printf("main : Before %p\n",pList);
                ret = DestoryList(&pList);
                printf("main : After %p\n",pList);
                break;
            case 9:
                //创建顺序表
                //创建空间
                pList = CreateList();
                if(!pList)  return -1;
                printf("pList = %p\n",pList);
                printf("pList->size = %d\n",pList->size);
                break;
            defaut:
                puts("请输入有效选项！");
        }
        switch(ret)
        {
            case POS_ERR:
                puts("POS_ERR");
                break;
            case LIST_FULL :
                puts("LIST_FULL");
                //调用扩容的函数
                break;
            case LIST_NULL:
                puts("LIST_NULL");
                //重新分配空间
                break;
            case LIST_EMPTY:
                puts("LIST_EMPTY");
                break;
        }
    }
    
    return 0;
}
menu.c
#include"../include/myhead.h"
//打印菜单
//函数返回值：获取的选项
int Menu(void)
{
    int opt = 0;
    puts("\t\t 1-----插入元素");
    puts("\t\t 2-----删除元素");
    puts("\t\t 3-----查询元素");
    puts("\t\t 4-----修改元素");
    puts("\t\t 5-----显示元素");
    puts("\t\t 6-----保存");
    puts("\t\t 7-----导入");
    puts("\t\t 8-----销毁");
    puts("\t\t 9-----创建顺序表");
    puts("\t\t-1-----退出");
    printf("请选择功能：");
    scanf("%d",&opt);
    return opt;
}
insert.c
#include"../include/myhead.h"
​
//函数功能：插入元素
//函数参数：给谁插入，插入的位置，插入的值
//函数返回值：成功返回OK，失败返回失败原因(错误信息)
int InsertItem(List *pList,int pos,data_type item)
{
    //入参判断
    if(!pList) return LIST_NULL;
    //判断是否为满
    if(pList->count == pList->size) return LIST_FULL;
    //判断位置是否合法
    if(pos < -1 || pos > pList->count) return POS_ERR;
    //插入
    //如果 pos = -1 尾插
    if(-1 == pos){
        pList->Data[pList->count] = item;
        //元素个数+1
        pList->count++;
        return OK;
    }
    //
    //1、移动元素
    for(int i = pList->count; i > pos; i--){
        pList->Data[i] = pList->Data[i - 1];
    }
    //2.插入
    pList->Data[pos] = item;
    //3.count
    pList->count ++;
    return OK;
}
delete.c
#include"../include/myhead.h"
//函数功能：删除元素
//函数参数：被删除元素的表，删除的位置，删除的值
//函数返回值：成功返回OK，失败返回失败原因
int DeleteItem(List *pList,int pos,data_type *item)
{
    //入参判断
    if(!pList)  return LIST_NULL;
    //表为空
    if(0 == pList->count) return LIST_EMPTY;
    //pos
    if(pos < -1 || pos > pList->count - 1) return POS_ERR;
    //删除元素
    //尾删
    if(-1 == pos){
        //删的同时把最后一个元素保存
        *item = pList->Data[pList->count-1];
        //元素的个数 -1
        pList->count --;
        puts("成功删除最后一个元素\n");
        return OK;
    }
    //正常的删除
    //1、保存元素
    *item = pList->Data[pos];
    //移动元素
    for(int i = pos; i < pList->count-1; i++){
        pList->Data[i] = pList->Data[i + 1];
    }
    //个数 -1
    pList->count--;
    printf("成功删除%d元素\n",*item);
    return OK;
}
search.c
#include"../include/myhead.h"
​
//函数功能：查询元素
//函数参数：查哪个表，表的元素
//函数返回值：成功返回查到的元素，失败返回失败原因
int Search(List *pList,data_type item)
{
    //入参判断表是否存在
    if(!pList)  return LIST_NULL;
    //判断表是否为空
    if(0 == pList->count) return LIST_EMPTY;
    //遍历元素
    for(int i = 0; i < pList->count; i++){
        if(pList->Data[i] == item){
            //找到了，返回元素的位置
            puts("表中存在此元素");
            return OK;
        }
    }
    //找到了
    puts("表中不存在此元素");
    return OK;
}
modify.c
#include"../include/myhead.h"
//函数功能：修改元素
//函数参数：被修改元素的表，旧元素，新元素
//函数返回值：成功返回OK，失败返回失败原因
int ModifyItem(List *pList,data_type old_item,data_type new_item)
{
    //入参判断
    if(!pList) return LIST_NULL;
    //如果为空
    if(0 == pList->count) return LIST_EMPTY;
    //从头到尾遍历元素
    for(int i = 0; i < pList->count; i++){
        if(pList->Data[i] == old_item){
            //找到了
            //替换
            pList->Data[i] = new_item;
            puts("修改成功");
            return OK;
        }
    }
    //没找到
    puts("查无旧元素");
    return OK;
}
show.c
#include"../include/myhead.h"
​
//函数功能：显示所有的元素
//函数参数：被显示元素的表
//函数返回值：成功返回OK，失败返回失败原因
int ShowList(List *pList)
{
    //入参判断
    //判断有没有这个表
    if(!pList)return LIST_NULL;
    //如果为空
    if(0 == pList->count) return LIST_EMPTY;
    //遍历打印元素
    for(int i = 0; i < pList->count; i++){
        printf("%d\t",pList->Data[i]);
    }
    putchar(10);
    return OK;
}
save.c
#include"../include/myhead.h"
//函数功能：保存
//函数参数：要保存的表
//函数返回值：成功返回OK，失败返回失败原因
int Save(List *pList)
{
    int fd = 0;
    //入入参判断
    if(!pList) return LIST_NULL;
    //打开文件
    fd = open("data.txt",O_WRONLY | O_CREAT | O_TRUNC,0664);
    //写
    write(fd,pList,sizeof(List));
    //写存储
    write(fd,pList->Data,sizeof(data_type) * pList->size);
    //关闭文件
    close(fd);
    puts("Write Success!");
    return OK;
}
load.c
#include"../include/myhead.h"
//函数功能：导入
//函数参数：
//函数返回值：成功返回表的地址，失败返回NULL
List *LoadList(List *pList)
{
    int mysize = 1;
    //创建空间
    //表:用来接收
    pList = (List *)malloc(sizeof(List));
    //判断空间是否开辟成功
    if(!pList){
        puts("MALLOC");
        return NULL;
    }
    memset(pList,0,sizeof(List));
    pList->Data = (data_type *)malloc(sizeof(data_type) * mysize);//大小，显示计算
    pList->size = mysize;
​
    int fd = 0;
    fd = open("data.txt",O_RDONLY);
    if(fd != -1)//成功打开文件，有原始数据
    {
        //读数据，获取size和count
        read(fd,pList,sizeof(List));
        //申请空间
        pList->Data = (data_type *)malloc(sizeof(data_type)* pList->size);
        if(!pList->Data) return NULL;
        //读数据给存储空间
        read(fd,pList->Data,sizeof(data_type)*pList->size);
        close(fd);
        puts("read success!");
        return pList;
    }
}
destory.c
#include"../include/myhead.h"
//函数功能：销毁空间
//函数参数：要销毁的表
//函数返回值：成功返回OK，失败返回失败原因
int DestoryList(List **pList)
{
    //入参判断
    printf("删除之前的地址:%p\n",*pList);
    if(!(*pList)) return LIST_NULL;
    //释放空间
    free(*pList);
    *pList = NULL;
    printf("删除之后的地址:%p\n",*pList);
    return OK;
}
creat.c
#include"../include/myhead.h"
​
//函数定义：
//函数功能：创建顺序表
//函数参数：void
//函数返回值：成功返回表的地址，失败返回NULL
List *CreateList(void)
{
    int mysize = 0;//后续的scanf接收表大小
    List *pList = NULL; //避免野指针的出现
    //创建空间
    //表
    pList = (List *)malloc(sizeof(List));
    //判断空间是否开辟成功，失败打印MALLOC
    if(!pList){
        puts("MALLOC");
        return NULL;//与CreateList函数返回值对应
    }
    //void *memset(void *s, int c, size_t n);
    //s：指向要设置的内存区域的指针。
    //c：要设置的值，会被转换为unsigned char类型。
    //n：要设置的字节数。
    memset(pList,0,sizeof(List));
    //开始创建存储空间的大小
    printf("请输入大小：");
    scanf("%d",&mysize);
    //给顺序表的存储空间
    pList->Data = (data_type *)malloc(sizeof(data_type) * mysize);//大小，显示计算
    //calloc    效率没有malloc高
    //初始化顺序表的大小
    pList->size = mysize;
    return pList;
}
​

4、Makefile文件

ListBak目录下Makefile文件
All:
    make -C ./src/
    make -C ./obj/
​
.PHONY:CLEAN
CLEAN:
    rm obj/*.o
    rm bin/*
obj目录下Makefile文件
ALL:
    gcc *.o -o ../bin/APP
src目录下Makefile文件
ALL:../obj/main.o ../obj/menu.o ../obj/creat.o ../obj/insert.o ../obj/show.o ../obj/search.o ../obj/delete.o ../obj/destory.o ../obj/save.o ../obj/load.o ../obj/modify.o
../obj/main.o:main.c
    gcc -c $< -o $@
../obj/menu.o:menu.c
    gcc -c $< -o $@
../obj/creat.o:creat.c
    gcc -c $< -o $@
../obj/insert.o:insert.c
    gcc -c $< -o $@
../obj/show.o:show.c
    gcc -c $< -o $@
../obj/search.o:search.c
    gcc -c $< -o $@
../obj/delete.o:delete.c
    gcc -c $< -o $@
../obj/destory.o:destory.c
    gcc -c $< -o $@
../obj/save.o:save.c
    gcc -c $< -o $@
../obj/load.o:load.c
    gcc -c $< -o $@
../obj/modify.o:modify.c
    gcc -c $< -o $@

后续为大家带来全注释版本，持续更新……

清澈的爱52
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python数据结构—2.线性数据结构(栈)
12-21
在这个系列的第一篇博客中，我主要强调了编程思维的重要性以及如何高效准确的编写出能解决问题的代码，这一篇博客开始就正式开始python数据结构相关的知识。 有一种数据结构，它的元素顺序取决于添加的顺序或者删除...
Java数据结构和算法系列文章，源码.zip
01-14
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
数据结构：八种数据结构大全
緑水長流*z
07-29 20万+
数据结构 1.1 数据结构概述 数据结构是计算机存储、组织数据的方式；通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能；常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等； 1.2 数据结构的分类 1.2.1 排列方式 1）集合 集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系； 2）线性结构 线性
数据结构——非线性结构（图）
巧克力布丁的博客
08-26 5489
如果本身就是连通图，则本身就是其连通分量，而非连通图的各个连通图作为其组成部分均为其连通分量强连通图：任意顶点出发可以到达其余任意节点假设一个图有n个节点，如果边数小于n-1，那么此图必是非连通图一个图有n个顶点，并且有大于n-1条边，则此图一定有环顶点不分大小、主次，所以用一个一维数组存储图中顶点的信息边或弧由于是顶点之间的关系，用一个二维数组存储图中边的信息（这个二维数组称为邻接矩阵）性质1：是有向图的一种链式存储结构：将邻接表和逆邻接表整合在一起邻接多重表是无向图的另一种链式存储结构。........
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 40万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构——非线性结构（树与二叉树）
巧克力布丁的博客
08-20 3054
1）有且只有一个称为根的节点2）有若干个互不相交的子树，这些子树本身也是一棵树（递归定义）1）树是由节点和边组成2）每个节点只有一个父节点但可以有多个子节点3）但有一个节点除外，该节点没有父节点，此节点称为根节点（n个节点的树中有n-1条边）后序遍历左子树后序遍历右子树再访问根节点递归遍历左右子树顺序是固定的，只是访问根的顺序不同。时间复杂度O(n)：因为不管采用哪种遍历算法，每个节点都访问一次。
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
chongyang_的博客
11-07 25万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
数据结构——栈的详解
晴空๓
04-20 7万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
如何区分数据结构中的线性结构与非线性结构？
joshua317的博客
09-17 2601
本文为joshua317原创文章,转载请注明：转载自joshua317博客如何区分数据结构中的线性结构与非线性结构？ - joshua317的博客 数据结构可以分成两大类： 线性结构 非线性结构 下面就来简单聊聊这两种结构，至于具体的数据结构，后续咱们慢慢聊。 线性结构 先来说线性结构，怎么理解呢？线性结构的元素之间是一个接着一个连接，构成线性的形式。比如数组、链表、栈、队列等。 对于数组，元素依次顺序存放，紧挨着，是一种顺序存储方式。 对于链表，元素之间离散存储，通过指针彼此相连，是一种链.
数据结构：树(Tree)【详解】
UniqueUnit的博客
02-26 15万+
树 一、知识框架 二、考纲内容 树的基本概念 二叉树 二叉树的定义及其主要特征；二叉树的顺序存储结构和链式存储结构；二叉树的遍历；线索二叉树的基本概念和构造 树、森林 树的存储结构；森林与二叉树的转换；树和森林的遍历 树与二叉树的应用 二叉排序树；平衡二叉树；哈夫曼树和哈弗编码 三、树的基本概念 1、树的定义 树是n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当n>1时，其余节点可分为m（m>
线性结构和非线性结构
weixin_53567905的博客
10-03 1444
该文章是根据尚硅谷Java数据结构与java算法（Java数据结构与算法）学习时，所做的笔记。 目录 一、线性结构 和非线性结构 1.线性结构 2.非线性结构 一、线性结构 和非线性结构 数据结构包括：线性结构和非线性结构。 1.线性结构 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的 链式存储的线性表称为链表，链表中的存储元素不
数据结构—笔记整理—初识数据结构
好好读书
10-22 4万+
数据结构笔记及相关知识整理，冲冲冲！！！
数据结构脑图1
08-03
本篇文章将深入探讨数据结构的一些基本类型及其特点。 首先，我们关注的是线性表，这是一种基本的数据结构，包括顺序结构和链式结构。在顺序结构中，数据元素按顺序存储在数组中。数组具有O(1)的随机访问优势，但...
数据结构之线性结构.doc
07-11
数据结构之线性结构（一，表结构） 作者：冲出宇宙 时间：2006-10-24 修改：2006-11-3 转载请注明作者。 作者主要参考了www.answers.com 上面的资料（因为wikipedia上不去）和部分较新学术论文（一般来自于acm, IEEE...
数据结构与算法内容梳理1
08-03
首先，链表是一种常见的线性数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。链表分为多种类型，包括单链表、双链表、循环链表等。链表的操作主要有增、删、查、改和销毁。题目中提到了链表...
数据结构-顺序表的交换排序
WinterXJujube的博客
06-25 557
快速排序是对冒泡排序的一种改进，它的基本思想是铜鼓哦一趟排序将待排序的数据分割成独立的两个部分，其中一部分比另一部分要小。然后分别对这两部分继续分割，直至整个序列有序。顺序表的冒泡排序和数组的冒泡排序的原理相同。通过不停比较相邻两个数据，如果不满足排序要求就交换两个值，直到所有的记录都排好序。快速排序有递归操作，每层递归都要使用到栈来存放指针和参数。通过冒泡排序的算法可知每次交换，循环都需要比较。（2）将剩余的部分分割成两个子序列。使用的方法是双指针法，快速排序并。，最坏情况下空间复杂度为。
数据结构需要每个都具体实现吗？
T1246632660的博客
06-25 270
大多数现代编程语言都有成熟的库或框架，提供了标准的数据结构实现，如Python的内置数据类型列表、字典等，Java中的ArrayList、LinkedList、HashMap等，以及C++ STL中的vector、list、map等。在某些特定场景下，标准库可能不完全满足需求，这时可能需要基于现有数据结构进行定制化改造，或者实现特定功能的数据结构。在学习数据结构的理论知识时，亲手实现各种数据结构（如链表、树、图、堆、队列等）是非常有益的，可以帮助深入理解它们的工作原理和时间空间复杂度。
数据结构——并查集
最新发布
qq_73201597的博客
06-26 476
在计算机科学中，并查集（英文：Disjoint-set data structure，直译为不数据结构交集）是一种数据结构，用于处理一些​​​​​​​不交集（Disjoint sets，一系列没有重复元素的集合）的合并及查询问题。
数据结构详解
AOMGyz的博客
06-24 503
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。它研究的是数据的逻辑结构和物理结构以及它们之间的相互关系，并对这种结构定义相适应的运算，设计出相应的算法，以确保经过这些运算以后所得到的新结构仍保持原来的结构类型。总结来说，数据结构是计算机科学中的基础概念，它描述了数据之间的关系以及数据的组织和存储方式。不同的数据结构适用于不同的场景和需求，通过合理选择和运用数据结构，可以提高程序的运行效率和性能。数据结构是计算机科学中一个非常重要的概念，它描述了数据之间的关系以及数据的组织和存储方式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值