数据结构 链式存储 +

于 2024-07-24 15:35:36 发布
阅读量664 收藏 14
点赞数 22
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kxy102852/article/details/140620906
版权

int DeleteLinkList(LinkList *list, char *name);
int ReviseLinkList(LinkList *list, char *name, DATATYPE data);
int DestroyLinkList(LinkList *list);
int InsertTailLinkList(LinkList *list, DATATYPE data);

​​​​​​​删除

修改​​​​​​​

 

销毁

​​​​​​​

 插入

 完整代码展示

#include <stdio.h>
#include "doulink.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()
{
    DATATYPE data[5]={
        {"zhangsan",'m',20,70},
        {"lisi",'f',21,60},
        {"wangmazi",'m',25,80},
        {"liubei",'f',30,85},
        {"caocao",'f',40,90},
    };

    DouLinkList* dl = CreateDouLinkList();

    InsertHeadLinkList(dl,&data[0]);
    InsertHeadLinkList(dl,&data[1]);
    InsertHeadLinkList(dl,&data[2]);

    ShowDouLinkList(dl,DIR_FORWARD);
    printf("-------------back---------------\n");
    ShowDouLinkList(dl,DIR_BACKWARD);
    printf("-------------find---------------\n");
    //    char want_name[]="lisi";
    //    //DouLinkNode* tmp = FindLinkList(dl,findbyname,want_name);
    //    int want_age = 25;
    //    DouLinkNode* tmp = FindLinkList(dl,findbyage,&want_age);
    //    if(NULL == tmp)
    //    {
    //        printf("can't find person ,name:%s\n",want_name);
    //    }
    //    else
    //    {

    //        printf("%s:%d\n",tmp->data.name,tmp->data.score);
    //    }

    //    RevertDouLinkList(dl);
    //    printf("-------------rev---------------\n");
    //    ShowDouLinkList(dl,DIR_FORWARD);
    //    DeleteLinkList(dl,findbyname,"lisi");
    //    printf("-------------del forware---------------\n");
    //    ShowDouLinkList(dl,DIR_FORWARD);
    //    printf("-------------back---------------\n");
    //    ShowDouLinkList(dl,DIR_BACKWARD);

    //    ModifyDouLinkList(dl,findbyname,"zhangsan",&data[3]);
    //    printf("-------------modify---------------\n");
    //    ShowDouLinkList(dl,DIR_FORWARD);

    InserPosDouLinkList(dl,&data[3],3);
    printf("-------------pos---------------\n");
    ShowDouLinkList(dl,DIR_FORWARD);
    printf("-------------back---------------\n");
    ShowDouLinkList(dl,DIR_BACKWARD);


    DestroyDouLinkList(&dl);

    printf("Hello World!\n");
    return 0;
}
#include "doulink.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

DouLinkList *CreateDouLinkList()
{
    //DouLinkList dl ;
    DouLinkList* dl = (DouLinkList*)malloc(sizeof(DouLinkList));
    if(NULL == dl)
    {
        perror("CreateDouLinkList malloc");
        //exit(1);
        return NULL;
    }
    dl->head =NULL;
    dl->clen = 0 ;

    return dl;
}

int InsertHeadLinkList(DouLinkList *list, DATATYPE *data)
{
    DouLinkNode*newnode = malloc(sizeof(DouLinkNode));
    if(NULL == newnode)
    {
        perror("InsertHeadLinkList malloc");
        return 1;
    }
    memcpy(&newnode->data,data,sizeof(DATATYPE));
    newnode->next = NULL;
    newnode->prev= NULL;

    if(0==list->clen)//empty
    {
        list->head = newnode;
    }
    else
    {
        newnode->next = list->head;
        list->head->prev = newnode;
        list->head = newnode;
    }
    list->clen++;
    return 0;


}

int ShowDouLinkList(DouLinkList *list, DIRECT direct)
{
    int i = 0 ;
    DouLinkNode* tmp = list->head;
    if(direct==DIR_FORWARD)
    {
        for(i=0;i<GetSizeDouLinkList(list);i++)
        {
            printf("%s %c %d %d\n",tmp->data.name,tmp->data.sex,tmp->data.age,tmp->data.score);
            tmp=tmp->next;
        }
    }
    else
    {
        while(tmp->next)
        {
            tmp=tmp->next;
        }
        for(i=0;i<GetSizeDouLinkList(list);i++)
        {
            printf("%s %c %d %d\n",tmp->data.name,tmp->data.sex,tmp->data.age,tmp->data.score);
            tmp=tmp->prev;
        }
    }
    return 0;
}

int GetSizeDouLinkList(DouLinkList *list)
{
    return list->clen;
}

DouLinkNode *FindLinkList(DouLinkList *list, PFUN fun, void *arg)
{
    DouLinkNode* tmp = list->head;
    int size = GetSizeDouLinkList(list);
    int i =  0;
    for(i = 0 ;i<size;i++)
    {
        //if(0==strcmp(tmp->data.name))
        if(fun(&tmp->data,arg))
        {
            return tmp;
        }
        tmp= tmp->next;
    }
    return NULL;
}

int RevertDouLinkList(DouLinkList *list)
{
    int size = GetSizeDouLinkList(list);
    if(size<2)
    {
        return 0;
    }

    DouLinkNode* prev= NULL;
    DouLinkNode* tmp = list->head;
    DouLinkNode*next= tmp->next;
    while(1)
    {
        tmp->next = prev;
        tmp->prev = next;
        prev= tmp;
        tmp = next;
        if(NULL == tmp)
        {
            break;
        }
        next =next->next;
    }
    list->head = prev;
    return 0;
}

int DeleteLinkList(DouLinkList *list, PFUN fun, void *arg)
{
    if(NULL == list)
    {
        fprintf(stderr,"DouLinkList is null");
        return 1;
    }
    if(IsEmptyDouLinkList(list))
    {
        fprintf(stderr,"DouLinkList is empty");
        return 1;
    }
    DouLinkNode* ret = FindLinkList(list,fun,arg);
    if(NULL==ret)
    {
        fprintf(stderr,"DeleteLinkList error,cant find\n");
        return 1;
    }
    if(ret == list->head)
    {
        list->head = ret->next;
        list->head->prev = NULL;
    }
    else
    {
        if(ret->next)
        ret->next->prev = ret->prev;
        ret->prev->next = ret->next;
    }

    free(ret);
    list->clen--;
    return 0;
}

int IsEmptyDouLinkList(DouLinkList *list)
{
    return 0 == list->clen;
}

int ModifyDouLinkList(DouLinkList *list, PFUN fun, void *arg, DATATYPE *data)
{
    DouLinkNode* ret = FindLinkList(list,fun,arg);
    if(NULL == ret)
    {
        fprintf(stderr,"ModifyDouLinkList error,cant find\n");
        return 1;
    }
    memcpy(&ret->data,data,sizeof(DATATYPE));
    return 0;
}

int DestroyDouLinkList(DouLinkList **list)
{
    DouLinkNode* tmp=(*list)->head;
    while(tmp)
    {
    (*list)->head=(*list)->head->next;
    free(tmp);
    tmp = (*list)->head;

    }
    free(*list);
    (*list)= NULL;
    return 0;
}

int InserPosDouLinkList(DouLinkList *list, DATATYPE *data,int pos)
{
    if(pos<0 ||pos>GetSizeDouLinkList(list))
    {
        fprintf(stderr,"InserPosDouLinkList error,index error\n");
        return 1;

    }
    if(IsEmptyDouLinkList(list) || 0 == pos)
    {
        return InsertHeadLinkList(list,data);
    }
    else
    {
        DouLinkNode* tmp = list->head;
        tmp= list->head;
        DouLinkNode* newnode = (DouLinkNode*)malloc(sizeof(DouLinkNode));
        if(NULL == newnode)
        {
            perror("InserPosDouLinkList malloc");
            return 1;
        }
        memcpy(&newnode->data,data,sizeof(DATATYPE));
        newnode->prev = NULL;
        newnode->next = NULL;
        int i = pos-1;
        while(i--)
        {
            tmp=tmp->next;
        }
        newnode ->prev = tmp;
        newnode->next = tmp->next;//这时候都是NULL，如果是尾插入不走if

        if(tmp->next)
        {
        tmp->next->prev = newnode;//中间插入
        }
        tmp->next = newnode;
    }
    list->clen++;
    return 0;
}
#ifndef DOULINK_H
#define DOULINK_H
typedef struct{
    char name[32];
    char sex;
    int age;
    int score;
}DATATYPE;
typedef int (*PFUN)(DATATYPE*data,void* arg);//表示fun（）中的参数书形式
typedef struct node {
    DATATYPE data;
    struct node *next,*prev;
}DouLinkNode;

typedef struct{
    DouLinkNode *head;
    int clen;
}DouLinkList;
typedef enum{DIR_FORWARD,DIR_BACKWARD}DIRECT;
DouLinkList* CreateDouLinkList();
int InsertHeadLinkList(DouLinkList *list, DATATYPE *data);
int ShowDouLinkList(DouLinkList *list,DIRECT direct);
int GetSizeDouLinkList(DouLinkList *list);
DouLinkNode *FindLinkList(DouLinkList *list, PFUN fun,void* arg);
int RevertDouLinkList(DouLinkList *list);
int DeleteLinkList(DouLinkList *list, PFUN fun,void* arg);
int IsEmptyDouLinkList(DouLinkList *list);
int ModifyDouLinkList(DouLinkList *list,PFUN fun,void* arg,DATATYPE *data);
int DestroyDouLinkList(DouLinkList **list);
int InserPosDouLinkList(DouLinkList *list,DATATYPE *data,int pos);
#endif // DOULINK_H

序表和链表 优缺点


    存储方式：
        顺序表是一段连续的存储单元
        链表是逻辑结构连续物理结构（在内存中的表现形式）不连续
    时间性能，
        查找 顺序表O(1)
             链表  O(n)
        插入和删除
            顺序表 O(n)
            链表   O(1)
            
    空间性能
            顺序表 需要预先分配空间，大小固定
            链表， 不需要预先分配，大小可变，动态分配
            
            
    循环链表
        简单的来说，就是将原来单链表中最有一个元素的next指针指向第一个元素或头结点，链表就成了一个环，头尾相连，就成了循环链表。circultlar linker list.
        
        注意非空表，和空表。多数会加入头结点。
        原来结束的条件是
        p->next != NULL ------->>>>> p-next != Head 
        
    双向链表
    double link list。
    
    typedef struct DulNode
    {
    
        ElemType date;
        struct DulNode *pri;
        sturct DulNode *next；
    }DulNode,*DuLinkList;
    

 习题

1）双向链表逆序

2)实现mplay的播放列表

main.c

#include <stdio.h>
#include "doulink.h"
#include <string.h>
#include "func.h"
#include <stdlib.h>
void show_menu( DouLinkList* dl)
{
    printf("1.show_list\n");
    printf("2.prev\n");
    printf("3.next\n");
    printf("4.end\n");
    char buf[10]={0};
    fgets(buf,sizeof(buf),stdin);
    int num = atoi(buf);
    switch (num) {
    case 1:
        ShowDouLinkList(dl,DIR_FORWARD);
        break;
    case 2:
        GetPrev(dl);
        break;
    case 3:
        Getnext(dl);
        break;
    case 4:
        exit(1);
        break;
    default:
        break;
    }
}
int main()
{
    DouLinkList* dl = CreateDouLinkList();
    do_ls("/home/linux",dl);

    ShowDouLinkList(dl,DIR_FORWARD);
    char *pathname=NULL;
    while(1)
    {
         show_menu(dl);
         pathname = GetCurrent(dl);
         printf("currnt play file:%s\n",pathname);

    }


    //atexit();
    printf("Hello World!\n");
    return 0;
}

doulink.c

#include "doulink.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

DouLinkList *CreateDouLinkList()
{
    //DouLinkList dl ;
    DouLinkList* dl = (DouLinkList*)malloc(sizeof(DouLinkList));
    if(NULL == dl)
    {
        perror("CreateDouLinkList malloc");
        //exit(1);
        return NULL;
    }
    dl->head =NULL;
    dl->clen = 0 ;
    dl->currnet =NULL;

    return dl;
}

int InsertHeadLinkList(DouLinkList *list, DATATYPE *data)
{
    DouLinkNode*newnode = malloc(sizeof(DouLinkNode));
    if(NULL == newnode)
    {
        perror("InsertHeadLinkList malloc");
        return 1;
    }
    memcpy(&newnode->data,data,sizeof(DATATYPE));
    newnode->next = NULL;
    newnode->prev= NULL;

    if(0==list->clen)//empty
    {
        list->head = newnode;
    }
    else
    {
        newnode->next = list->head;
        list->head->prev = newnode;
        list->head = newnode;
    }
    list->clen++;
    return 0;


}

int ShowDouLinkList(DouLinkList *list, DIRECT direct)
{
    int i = 0 ;
    DouLinkNode* tmp = list->head;
    if(direct==DIR_FORWARD)
    {
        for(i=0;i<GetSizeDouLinkList(list);i++)
        {
            printf("%d %s\n",i,tmp->data.pathname);
            tmp=tmp->next;
        }
    }

    return 0;
}

int GetSizeDouLinkList(DouLinkList *list)
{
    return list->clen;
}

DouLinkNode *FindLinkList(DouLinkList *list, PFUN fun, void *arg)
{
    DouLinkNode* tmp = list->head;
    int size = GetSizeDouLinkList(list);
    int i =  0;
    for(i = 0 ;i<size;i++)
    {
        //if(0==strcmp(tmp->data.name))
        if(fun(&tmp->data,arg))
        {
            return tmp;
        }
        tmp= tmp->next;
    }
    return NULL;
}

int RevertDouLinkList(DouLinkList *list)
{
    int size = GetSizeDouLinkList(list);
    if(size<2)
    {
        return 0;
    }

    DouLinkNode* prev= NULL;
    DouLinkNode* tmp = list->head;
    DouLinkNode*next= tmp->next;
    while(1)
    {
        tmp->next = prev;
        tmp->prev = next;
        prev= tmp;
        tmp = next;
        if(NULL == tmp)
        {
            break;
        }
        next =next->next;
    }
    list->head = prev;
    return 0;
}



char *GetCurrent(DouLinkList *list)
{
    return list->currnet->data.pathname;
}

int GetPrev(DouLinkList *list)
{
    list->currnet = list->currnet->prev;
    if(NULL == list->currnet)
    {

        list->currnet = list->head;
        while(list->currnet->next)
        {
            list->currnet = list->currnet->next;
        }

    }
    return 0;

}

int Getnext(DouLinkList *list)
{
     list->currnet = list->currnet->next;
     if(NULL == list->currnet)
     {
           list->currnet = list->head;

     }
     return 0;
}

fun.c

#include "func.h"
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int do_ls(char *path,DouLinkList*dl)
{
    {

        DIR* dir = opendir(path);
           if(NULL == dir)
           {
               printf("opendir");
               return 1;
           }
            DATATYPE data;
           while(1)
           {
               struct dirent *info =  readdir(dir);
               //procintf("%s  %lu",info->d_name,info->d_ino);
               if(NULL == info)
               {
                   break;
               }
               if(strlen(info->d_name ) >3)// 1.flv  /home/linux/1.flv
               {
                   if(0==strcmp(&info->d_name[strlen(info->d_name)-3],"mp3")
                      ||0==strcmp(&info->d_name[strlen(info->d_name)-3],"flv")
                      ||0==strcmp(&info->d_name[strlen(info->d_name)-3],"mp4"))
                   {
                       bzero(&data,sizeof(data));

                       sprintf(data.pathname,"%s/%s",path,info->d_name);
                       //sprintf(song.songlist[song.total++],"%s/%s",path,info->d_name);
                       InsertHeadLinkList(dl,&data);


                   }
               }
               else
               {
                   continue;
               }
           }
           closedir(dir);
    }
     dl->currnet = dl->head;
    return 0;
}

fun.h

#ifndef FUNC_H
#define FUNC_H
#include "doulink.h"
int do_ls(char *path,DouLinkList*dl);

#endif // FUNC_H

doulink.h

#ifndef DOULINK_H
#define DOULINK_H
typedef struct{
    char pathname[512];
}DATATYPE;
typedef int (*PFUN)(DATATYPE*data,void* arg);
typedef struct node {
    DATATYPE data;
    struct node *next,*prev;

}DouLinkNode;

typedef struct{
    DouLinkNode *head;
    struct node *currnet;
    int clen;
}DouLinkList;
typedef enum{DIR_FORWARD,DIR_BACKWARD}DIRECT;
DouLinkList* CreateDouLinkList();
int InsertHeadLinkList(DouLinkList *list, DATATYPE *data);
int ShowDouLinkList(DouLinkList *list,DIRECT direct);
int GetSizeDouLinkList(DouLinkList *list);
DouLinkNode *FindLinkList(DouLinkList *list, PFUN fun,void* arg);
int RevertDouLinkList(DouLinkList *list);
char* GetCurrent(DouLinkList *list);
 int GetPrev(DouLinkList *list);
 int Getnext(DouLinkList *list);
#endif // DOULINK_H

y.ki
关注
  • 22
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构-线性表的链式存储
09-17
线性表的链式存储是数据结构课程中的核心概念之一，它的主要特点是通过链接而非内存位置连续来组织数据。 链式存储与顺序存储是线性表的两种基本实现方式。顺序存储（如数组）要求所有元素在内存中是连续存放的，而...
数据结构链式表，c语言简单实现
01-12
链式表是一种重要的数据结构，它在计算机科学中扮演着至关重要的角色，特别是在处理动态数据集合时。与数组不同，链式表不依赖于物理存储位置的连续性，而是通过节点间的指针链接来组织数据。本文将深入探讨链式表的...
数据结构——链式存储结构
qq_51594995的博客
10-10 9506
文章目录前言一、链式存储结构二、相关术语1.结点2.链表3.单链表4.双链表5.循环链表6.头指针7.首元结点三、单链表1.单链表的实现2.单链表的初始化3.单链表的销毁4.单链表的清空5.单链表的长度6.单链表的取值7.单链表的查找8.单链表的插入9.单链表的删除10.单链表的尾插法 前言 数据结构笔记第三章 一、链式存储结构 结点在存储器中的位置是任意的，及逻辑上相邻的数据元素在物理上不一定相邻。线性表的链式表示又称为非顺序映像或链式映像，用一组物理位置任意的存储单元来存放线性表的数据元素，这..
数据结构之顺序存储结构和链式存储结构分析 , 图文并茂 , 又涨姿势了
热门推荐
刘跃辉的博客
09-05 11万+
在计算机中，数据元素并不是孤立、杂乱无序的，而是具有内在联系的数据集合。数据元素之间存在一种或多种特定关系，也就是数据的组织形式。为编写出一个 好"的程序，必须分析待处理对象的特性及各处理对象之间存在的关系。这也就是研究数据结构的意义所在。
数据结构——链式存储
x18037177724的博客
11-16 848
链式存储，即链表，是一种常用、方便的存储方式。链表这种方法可以在多个语言中使用，具有一定抽象性。一般对链表进行的操作有：求表长，查找特定元素，插入结点，删除结点。
数据结构：二叉树的链式结构
Yikefore的博客
06-03 5592
链式二叉树创建非常详细的过程：包含如何前序遍历创建二叉树、对二叉树的前、中、后序遍历、二叉树节点个数、二叉树叶子节点个数、二叉树的高度、第k层节点个数、查找节点、层序遍历、判断二叉树是否为完全二叉树、二叉树的销毁.....附带完整代码以及图解
数据结构之队列的链式存储
AHuRui的博客
05-16 4968
文章目录一、队列的链式存储结构结构体的定义：二、相关操作实现1.初始化2.依次对栈中的每个数据元素输出3.进队列4.出队列5.链队列中元素个数6.测试函数7.具体代码实现三、样例输出四、问题回答五、写在最后 队列的链式存储 这里是数据结构个人学习的笔记记录，如有问题欢迎指正说明 一、队列的链式存储结构 队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出，我们把它简单称为链队列。为了操作上的方便，我们将队头指针指向链队列的头结点，而队尾指针指向终端结点。空队列时，我们将队头指针和队尾指针都
数据结构-链式结构
wooovi的博客
02-05 2700
数据结构-链式结构线性表的链式表示及实现链式存储结构与链式存储有关的术语链表（链式存储结构）的特点单链表的定义与表示单链表基本操作的实现单链表的初始化（带头结点的单链表），即构造一个空的单链表（补充）判断链表是否为空(补充)单链表的销毁：销毁链表后不存在（补充）清空链表（补充）求单链表长单链表取值-取第i个元素单链表查值单链表插入单链表中删除元素--删除第i个结点单链表的建立-头插法单链表的建立-尾插法 线性表的链式表示及实现 链式存储结构 节点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定
数据结构之顺序存储与链式存储
wahkim的博客
11-25 1万+
http://www.itongji.cn/detail?type=1121 https://blog.csdn.net/qq_38378384/article/details/80430396 定义 线性表，全名为线性存储结构。 线性表是n个数据特性相同的元素的组成有限序列，是最基本且常用的一种线性结构(线性表，栈，队列，串和数组都是线性结构），同时也是其他数据结构的基础。具有“一对一”逻辑关系的数据，最佳的存储方式是使用线性表。 特点 是一个有限的序列 可以是有序的也可以是无序的。 线性表的开始元素没
6.0、C语言数据结构——链式存储结构 (1)
m0_52433668的博客
09-17 778
1. 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元恶意存在内存中未被占用的任意位置；2. 比起顺序存储结构每个数据元素只需要存储一个位置就可以了；现在链式存储结构中，除了要存储数据元素信息外，还要存储他的后继元素的存储地址（指针）；3. 也就是说除了存储其本身的信息外，还需要存储一个指示其直接后继的存储位置的信息；1. 我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域；指针域中存储的信息称为指针或链；
数据结构——线性表的链式存储
weixin_46272350的博客
08-11 4973
通常采用链式存储结构的线性表称为线性链表。从链式方式的角度看，链表可以分为单链表，循环链表和双链表。 1.单链表 链表是用一组任意存储单元来存放线性表的结点，这组存储单元可以是连续的，也可以是非连续的，甚至是零散分布在内存的任何位置上。因此，链表中结点的逻辑顺序和物理顺序不一定相同。 结点包括两个域：数据域用来存储结点的值，指针域用来存储数据元素的直接后继的地址。线性链表正是通过每个结点的指针域将线性表的n个结点按其逻辑顺序连接在一起。又因为线性链表的每个结点只有一个next指针域，所以这...
数据结构--串的链式存储
m0_65472749的博客
10-16 926
串的链式存的储基本操作
数据结构链式存储
12-01
数据结构链式存储 链式存储是一种常见的数据结构存储方式，特别是在C++编程中。链式存储的基本思想是将数据元素存储在链表中，每个元素都是一个节点，节点中包含数据元素和指向下一个节点的指针。这种存储方式可以...
数据结构笔记 绪论+算法.docx
12-31
数据结构是计算机科学中至关重要的一个分支，它主要研究如何高效地存储和处理数据。《数据结构笔记 绪论+算法》是对B站王卓教授数据结构课程的整理，结合了PPT和教材内容，适合考研复习使用。笔记中包含了数据结构的...
数据结构：二叉树（链式存储）
12-07
以上就是关于“数据结构：二叉树（链式存储）”的主要内容，包括了二叉树的链式存储结构，递归创建二叉树的方法，以及三种遍历策略的实现。这些知识对于理解和操作二叉树至关重要，也是数据结构和算法学习中的基础...
c语言（7.23）
最新发布
fhgfyrsg的博客
07-23 359
【代码】c语言（7.23）
数据结构---二叉树
weixin_47808575的博客
07-22 315
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 754
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 487
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值