双向循环链表

最新推荐文章于 2024-09-15 16:31:43 发布
最新推荐文章于 2024-09-15 16:31:43 发布
阅读量269 收藏
点赞数
分类专栏： 数据结构 文章标签： C语言 双向循环链表 面向对象 内存管理 内核链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52547536/article/details/126075472
版权

双向循环链表

在这里插入图片描述

带头结点的双向循环链表

插入的操作：
在这里插入图片描述

基础代码：

  • llist.c文件代码：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "llist.h"



LLIST *llist_create(int initsize)
{

    LLIST *new;
    new=malloc(sizeof(*new));
    if(new==NULL)
    {
        return NULL;
    }

    new->size=initsize;
    new->head.data=NULL;
    new->head.prev=&new->head;
    new->head.next=&new->head;

    return new;

}

void llist_destroy(LLIST *ptr)
{
    
    struct llist_node_st *cur,*next;
    for(cur=ptr->head.next;cur!=&ptr->head;cur=cur->next)
    {
        next=cur->next;
        free(cur->data);
        free(cur);
    }
    free(ptr);

}

int llist_insert(LLIST *ptr,const void *data,int mode)
{

    struct llist_node_st *newnode;
    newnode=malloc(sizeof(*newnode));
    if(newnode==NULL)
        return -1;
    newnode->data=malloc(ptr->size);
    if(newnode->data==NULL)
        return -2;
    memcpy(newnode->data,data,ptr->size);

    if(mode==LLIST_FORWARD)
    {
        newnode->prev=&ptr->head;
        newnode->next=ptr->head.next;
        
        newnode->prev->next=newnode;
        newnode->next->prev=newnode;
        
    }
    else if(mode==LLIST_BACKWARD)
    {
        newnode->prev=ptr->head.prev;
        newnode->next=&ptr->head;

        newnode->prev->next=newnode;
        newnode->next->prev=newnode;


    }
    else
    {
        return -3;
    }
    return 0;

}

static struct llist_node_st *find_(LLIST *ptr,const void *key,llist_cmp *cmp)
{

        struct llist_node_st *cur;
        for(cur=ptr->head.next;cur != &ptr->head;cur=cur->next)
        {
                if(cmp(key,cur->data)==0)
                        break;
        }
        return cur;

}

/*
llist_delete();


llist_fetch();
*/

int llist_delete(LLIST *ptr,const void *key,llist_cmp *cmp)
{

    struct llist_node_st *node;
    
    node=find_(ptr,key,cmp);
    if(node==&ptr->head)
    {
        return -1;
    }
    
    node->prev->next=node->next;
    node->next->prev=node->prev;
    free(node->data);
    free(node);
    return 0;
    

}


int llist_fetch(LLIST *ptr,const void *key,llist_cmp*cmp,void *data)
{

    struct llist_node_st *node;

    node=find_(ptr,key,cmp);
    if(node==&ptr->head)
    {
        return -1;
    }
    
    node->prev->next=node->next;
    node->next->prev=node->prev;
    if(data != NULL)
    {
        memcpy(data,node->data,ptr->size);
    }
    
    free(node->data);
    free(node);

    return 0;
}



void *llist_find(LLIST *ptr,const void *key,llist_cmp *cmp)
{
    
    return find_(ptr,key,cmp)->data;


}



void llist_show(LLIST *ptr,llist_op *op)
{

    struct llist_node_st *cur;
    for(cur=ptr->head.next;cur != &ptr->head;cur=cur->next)
    {
        op(cur->data);
    }



}
  • llist.h文件代码：
#ifndef LLIST_H__
#define LLIST_H__

#define LLIST_FORWARD 1
#define LLIST_BACKWARD 2

struct llist_node_st
{

    void *data;
    struct llist_node_st *prev;
    struct llist_node_st *next;


};


typedef struct LLIST
{
    int size;
    
    struct llist_node_st head;
}LLIST;


typedef void llist_op(const void *);
typedef int llist_cmp(const void *,const void *);


LLIST *llist_create(int initsize);

void llist_destroy(LLIST *);

int llist_insert(LLIST *,const void *data,int mode);

int llist_delete(LLIST *,const void *key,llist_cmp *);

void *llist_find(LLIST *,const void *key,llist_cmp *);

int llist_fetch(LLIST *,const void *key,llist_cmp*,void *data);


void llist_show(LLIST *,llist_op *);

#endif
  • main.c文件代码：
#include <stdio.h>
#include <stdlib.h>

#include "llist.h"
#define NAMESIZE 32
struct score_st
{

    int id;
    char name[NAMESIZE];
    int math;
    int chinese;

};


void print_s(const void  *record)
{
    const struct score_st *r=record;

    printf("%d %s %d %d \n",r->id,r->name,r->math,r->chinese);
}


static int id_cmp(const void *key,const void *record)
{
    const int *k=key;
    const struct score_st *r=record;

    return (*k-r->id);

}

int main()
{
    int i;
    LLIST *handler;
    struct score_st tmp;
    handler=llist_create(sizeof(struct score_st));
    /*if err*/
    for(i=0;i<7;i++)
    {
        tmp.id=i;
        snprintf(tmp.name,NAMESIZE,"std%d",i);
        tmp.math=rand()%100;
        tmp.chinese=rand()%100;
        
        llist_insert(handler,&tmp,LLIST_BACKWARD);
    }
    
    llist_show(handler,print_s);

    printf("\n \n");

    int id=3;
    struct score_st *data;
    llist_delete(handler,&id,id_cmp);

    llist_show(handler,print_s);

    
    data=llist_find(handler,&id,id_cmp);
    if(data==NULL)
    {
        printf("sorry ,can not find.\n");
    }
    else
    {
        print_s(data);
    }
    
    
    llist_destroy(handler);

    exit(0);

}
  • makefile文件内容：
all:llist

llist:llist.o main.o
    $(CC) $^ -o $@

clean:
    rm llist *.o -rf

利用变长结构体来实现双向循环链表的实现

在这里插入图片描述

  • llist.c文件代码：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "llist.h"

LLIST *llist_create(int initsize)
{

    LLIST *new;
    new=malloc(sizeof(*new));
    if(new==NULL)
    {
        return NULL;
    }

    new->size=initsize;
    new->head.prev=&new->head;
    new->head.next=&new->head;

    return new;

}

void llist_destroy(LLIST *ptr)
{
    
    struct llist_node_st *cur,*next;
    for(cur=ptr->head.next;cur!=&ptr->head;cur=cur->next)
    {
        next=cur->next;
        free(cur);
    }
    free(ptr);

}

int llist_insert(LLIST *ptr,const void *data,int mode)
{

    struct llist_node_st *newnode;
    newnode=malloc(sizeof(*newnode) + ptr->size);
    if(newnode==NULL)
        return -1;

    memcpy(newnode->data,data,ptr->size);

    if(mode==LLIST_FORWARD)
    {
        newnode->prev=&ptr->head;
        newnode->next=ptr->head.next;
        
        newnode->prev->next=newnode;
        newnode->next->prev=newnode;
        
    }
    else if(mode==LLIST_BACKWARD)
    {
        newnode->prev=ptr->head.prev;
        newnode->next=&ptr->head;

        newnode->prev->next=newnode;
        newnode->next->prev=newnode;


    }
    else
    {
        return -3;
    }
    return 0;

}

static struct llist_node_st *find_(LLIST *ptr,const void *key,llist_cmp *cmp)
{

        struct llist_node_st *cur;
        for(cur=ptr->head.next;cur != &ptr->head;cur=cur->next)
        {
                if(cmp(key,cur->data)==0)
                        break;
        }
        return cur;

}



int llist_delete(LLIST *ptr,const void *key,llist_cmp *cmp)
{

    struct llist_node_st *node;
    
    node=find_(ptr,key,cmp);
    if(node==&ptr->head)
    {
        return -1;
    }
    
    node->prev->next=node->next;
    node->next->prev=node->prev;
    free(node);
    return 0;
    

}


int llist_fetch(LLIST *ptr,const void *key,llist_cmp*cmp,void *data)
{

    struct llist_node_st *node;

    node=find_(ptr,key,cmp);
    if(node==&ptr->head)
    {
        return -1;
    }
    
    node->prev->next=node->next;
    node->next->prev=node->prev;
    if(data != NULL)
    {
        memcpy(data,node->data,ptr->size);
    }
    free(node);

    return 0;
}



void *llist_find(LLIST *ptr,const void *key,llist_cmp *cmp)
{
    struct llist_node_st *node;
    node=find_(ptr,key,cmp);
    if(node==&ptr->head)
        return NULL;
    return node->data;

}



void llist_show(LLIST *ptr,llist_op *op)
{

    struct llist_node_st *cur;
    for(cur=ptr->head.next;cur != &ptr->head;cur=cur->next)
    {
        op(cur->data);
    }


}
  • llist.h文件代码实现：
#ifndef LLIST_H__
#define LLIST_H__

#define LLIST_FORWARD 1
#define LLIST_BACKWARD 2

struct llist_node_st
{

    struct llist_node_st *prev;
    struct llist_node_st *next;
    char data[1];

};


typedef struct LLIST
{
    int size;
    
    struct llist_node_st head;
}LLIST;


typedef void llist_op(const void *);
typedef int llist_cmp(const void *,const void *);


LLIST *llist_create(int initsize);

void llist_destroy(LLIST *);

int llist_insert(LLIST *,const void *data,int mode);

int llist_delete(LLIST *,const void *key,llist_cmp *);

void *llist_find(LLIST *,const void *key,llist_cmp *);

int llist_fetch(LLIST *,const void *key,llist_cmp*,void *data);


void llist_show(LLIST *,llist_op *);

#endif

其他文件不变。

用C语言实现面向对象的思想：

将函数的入口地址，包含在结构体当中。

  • llist.c文件内容：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "llist.h"

int llist_insert(LLIST *,const void *data,int mode);

int llist_delete(LLIST *,const void *key,llist_cmp *);

void *llist_find(LLIST *,const void *key,llist_cmp *);

int llist_fetch(LLIST *,const void *key,llist_cmp*,void *data);


void llist_show(LLIST *,llist_op *);

LLIST *llist_create(int initsize)
{

    LLIST *new;
    new=malloc(sizeof(*new));
    if(new==NULL)
    {
        return NULL;
    }

    new->size=initsize;
    new->head.prev=&new->head;
    new->head.next=&new->head;
    
    new->insert=llist_insert;
    new->delete=llist_delete;
    new->find=llist_find;
    new->fetch=llist_fetch;
    new->show=llist_show;

    return new;

}

void llist_destroy(LLIST *ptr)
{
    
    struct llist_node_st *cur,*next;
    for(cur=ptr->head.next;cur!=&ptr->head;cur=cur->next)
    {
        next=cur->next;
        free(cur);
    }
    free(ptr);

}

int llist_insert(LLIST *ptr,const void *data,int mode)
{

    struct llist_node_st *newnode;
    newnode=malloc(sizeof(*newnode) + ptr->size);
    if(newnode==NULL)
        return -1;

    memcpy(newnode->data,data,ptr->size);

    if(mode==LLIST_FORWARD)
    {
        newnode->prev=&ptr->head;
        newnode->next=ptr->head.next;
        
        newnode->prev->next=newnode;
        newnode->next->prev=newnode;
        
    }
    else if(mode==LLIST_BACKWARD)
    {
        newnode->prev=ptr->head.prev;
        newnode->next=&ptr->head;

        newnode->prev->next=newnode;
        newnode->next->prev=newnode;


    }
    else
    {
        return -3;
    }
    return 0;

}

static struct llist_node_st *find_(LLIST *ptr,const void *key,llist_cmp *cmp)
{

        struct llist_node_st *cur;
        for(cur=ptr->head.next;cur != &ptr->head;cur=cur->next)
        {
                if(cmp(key,cur->data)==0)
                        break;
        }
        return cur;

}

/*
llist_delete();


llist_fetch();
*/

int llist_delete(LLIST *ptr,const void *key,llist_cmp *cmp)
{

    struct llist_node_st *node;
    
    node=find_(ptr,key,cmp);
    if(node==&ptr->head)
    {
        return -1;
    }
    
    node->prev->next=node->next;
    node->next->prev=node->prev;
    free(node);
    return 0;
    

}


int llist_fetch(LLIST *ptr,const void *key,llist_cmp*cmp,void *data)
{

    struct llist_node_st *node;

    node=find_(ptr,key,cmp);
    if(node==&ptr->head)
    {
        return -1;
    }
    
    node->prev->next=node->next;
    node->next->prev=node->prev;
    if(data != NULL)
    {
        memcpy(data,node->data,ptr->size);
    }
    free(node);

    return 0;
}



void *llist_find(LLIST *ptr,const void *key,llist_cmp *cmp)
{
    struct llist_node_st *node;
    node=find_(ptr,key,cmp);
    if(node==&ptr->head)
        return NULL;
    return node->data;

}



void llist_show(LLIST *ptr,llist_op *op)
{

    struct llist_node_st *cur;
    for(cur=ptr->head.next;cur != &ptr->head;cur=cur->next)
    {
        op(cur->data);
    }


}
  • llist.h文件内容
#ifndef LLIST_H__
#define LLIST_H__

#define LLIST_FORWARD 1
#define LLIST_BACKWARD 2


typedef void llist_op(const void *);
typedef int llist_cmp(const void *,const void *);


struct llist_node_st
{

    struct llist_node_st *prev;
    struct llist_node_st *next;
    char data[1];

};


typedef struct llist_head
{
    int size;    
    struct llist_node_st head;
    int (*insert)(struct llist_head *,const void *,int);
    void *(*find)(struct llist_head *,const void *,llist_cmp *);
    int (*delete)(struct llist_head *,const void *,llist_cmp *);
    int (*fetch)(struct llist_head *,const void *,llist_cmp *,void *);
    void (*show)(struct llist_head *,llist_op *);


}LLIST;


LLIST *llist_create(int initsize);

void llist_destroy(LLIST *);

#endif
  • main.c文件内容
#include <stdio.h>
#include <stdlib.h>

#include "llist.h"
#define NAMESIZE 32
struct score_st
{

    int id;
    char name[NAMESIZE];
    int math;
    int chinese;

};


void print_s(const void  *record)
{
    const struct score_st *r=record;

    printf("%d %s %d %d \n",r->id,r->name,r->math,r->chinese);
}


static int id_cmp(const void *key,const void *record)
{
    const int *k=key;
    const struct score_st *r=record;

    return (*k-r->id);

}

int main()
{
    int i;
    int ret;
    LLIST *handler;
    struct score_st tmp;
    handler=llist_create(sizeof(struct score_st));
    /*if err*/
    for(i=0;i<7;i++)
    {
        tmp.id=i;
        snprintf(tmp.name,NAMESIZE,"std%d",i);
        tmp.math=rand()%100;
        tmp.chinese=rand()%100;
        
        ret=handler->insert(handler,&tmp,LLIST_BACKWARD);
        if(ret)
        {
            exit(1);
        }
    }
    
    handler->show(handler,print_s);
#if 0
    printf("\n \n");

    int id=3;
    struct score_st *data;
    llist_delete(handler,&id,id_cmp);

    llist_show(handler,print_s);

    
    data=llist_find(handler,&id,id_cmp);
    if(data==NULL)
    {
        printf("sorry ,can not find.\n");
    }
    else
    {
        print_s(data);
    }
    
#endif     
    llist_destroy(handler);

    exit(0);

}

其他文件不变。

接下来将数据结构进行隐藏和封装，让用户看不到当前实现的数据结构，但是可以实现链表。

  • llist.c文件内容：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "llist.h"

struct llist_node_st
{

        struct llist_node_st *prev;
        struct llist_node_st *next;
        char data[1];

};


struct llist_head_st
{
        int size;
        struct llist_node_st head;
};



LLIST *llist_create(int initsize)
{

    struct llist_head_st *new;
    new=malloc(sizeof(*new));
    if(new==NULL)
    {
        return NULL;
    }

    new->size=initsize;
    new->head.prev=&new->head;
    new->head.next=&new->head;
    

    return new;

}

void llist_destroy(LLIST *p)
{
    struct llist_head_st *ptr=p;
    struct llist_node_st *cur,*next;
    for(cur=ptr->head.next;cur!=&ptr->head;cur=cur->next)
    {
        next=cur->next;
        free(cur);
    }
    free(ptr);

}

int llist_insert(LLIST *p,const void *data,int mode)
{

    struct llist_node_st *newnode;
    struct llist_head_st *ptr=p;

    newnode=malloc(sizeof(*newnode) + ptr->size);
    if(newnode==NULL)
        return -1;

    memcpy(newnode->data,data,ptr->size);

    if(mode==LLIST_FORWARD)
    {
        newnode->prev=&ptr->head;
        newnode->next=ptr->head.next;
        
        newnode->prev->next=newnode;
        newnode->next->prev=newnode;
        
    }
    else if(mode==LLIST_BACKWARD)
    {
        newnode->prev=ptr->head.prev;
        newnode->next=&ptr->head;

        newnode->prev->next=newnode;
        newnode->next->prev=newnode;


    }
    else
    {
        return -3;
    }
    return 0;

}

static struct llist_node_st *find_(struct llist_head_st *ptr,const void *key,llist_cmp *cmp)
{

        struct llist_node_st *cur;
        for(cur=ptr->head.next;cur != &ptr->head;cur=cur->next)
        {
                if(cmp(key,cur->data)==0)
                        break;
        }
        return cur;

}



int llist_delete(LLIST *p,const void *key,llist_cmp *cmp)
{
    
    struct llist_head_st *ptr=p;
    struct llist_node_st *node;
    
    node=find_(ptr,key,cmp);
    if(node==&ptr->head)
    {
        return -1;
    }
    
    node->prev->next=node->next;
    node->next->prev=node->prev;
    free(node);
    return 0;
    

}


int llist_fetch(LLIST *p,const void *key,llist_cmp*cmp,void *data)
{
    struct llist_head_st *ptr=p;
    struct llist_node_st *node;

    node=find_(ptr,key,cmp);
    if(node==&ptr->head)
    {
        return -1;
    }
    
    node->prev->next=node->next;
    node->next->prev=node->prev;
    if(data != NULL)
    {
        memcpy(data,node->data,ptr->size);
    }
    free(node);

    return 0;
}



void *llist_find(LLIST *p,const void *key,llist_cmp *cmp)
{
    struct llist_head_st *ptr=p;
    struct llist_node_st *node;
    node=find_(ptr,key,cmp);
    if(node==&ptr->head)
        return NULL;
    return node->data;

}



void llist_show(LLIST *p,llist_op *op)
{
    struct llist_head_st *ptr=p;
    struct llist_node_st *cur;
    for(cur=ptr->head.next;cur != &ptr->head;cur=cur->next)
    {
        op(cur->data);
    }


}
  • llist.h文件内容
#ifndef LLIST_H__
#define LLIST_H__

#define LLIST_FORWARD 1
#define LLIST_BACKWARD 2

typedef void LLIST;

typedef void llist_op(const void *);
typedef int llist_cmp(const void *,const void *);


LLIST *llist_create(int initsize);

void llist_destroy(LLIST *);

int llist_insert(LLIST *,const void *data,int mode);

int llist_delete(LLIST *,const void *key,llist_cmp *);

void *llist_find(LLIST *,const void *key,llist_cmp *);

int llist_fetch(LLIST *,const void *key,llist_cmp*,void *data);

void llist_show(LLIST *,llist_op *);

#endif
  • main.c文件内容：
#include <stdio.h>
#include <stdlib.h>

#include "llist.h"
#define NAMESIZE 32
struct score_st
{

    int id;
    char name[NAMESIZE];
    int math;
    int chinese;

};


void print_s(const void  *record)
{
    const struct score_st *r=record;

    printf("%d %s %d %d \n",r->id,r->name,r->math,r->chinese);
}


static int id_cmp(const void *key,const void *record)
{
    const int *k=key;
    const struct score_st *r=record;

    return (*k-r->id);

}

int main()
{
    int i;
    int ret;
    LLIST *handler;
    struct score_st tmp;
    handler=llist_create(sizeof(struct score_st));
    /*if err*/
    for(i=0;i<7;i++)
    {
        tmp.id=i;
        snprintf(tmp.name,NAMESIZE,"std%d",i);
        tmp.math=rand()%100;
        tmp.chinese=rand()%100;
        
        ret=llist_insert(handler,&tmp,LLIST_BACKWARD);
        if(ret)
        {
            exit(1);
        }
    }
    
    llist_show(handler,print_s);

    printf("\n \n");

    int id=3;
    struct score_st *data;
    llist_delete(handler,&id,id_cmp);

    llist_show(handler,print_s);

    
    data=llist_find(handler,&id,id_cmp);
    if(data==NULL)
    {
        printf("sorry ,can not find.\n");
    }
    else
    {
        print_s(data);
    }
        
    llist_destroy(handler);

    exit(0);

}

其他文件内容不变。

内核双向链表的赏析：
在这里插入图片描述

根据内核的代码写双向循环链表

  • list.h文件内容：
#ifndef LINUX_LIST_H__
#define LINUX_LIST_H__

struct list_head
{

    struct list_head *prev;
    struct list_head *next;

};

#define LIST_HEAD_INIT(name) {&(name),&(name)}

#define LIST_HEAD(name) struct list_head name=LIST_HEAD_INIT(name)

static inline void __list_add(struct list_head *new, struct list_head *prev, struct list_head *next)
{
        next->prev = new;
        new->next = next;
        new->prev = prev;
        prev->next = new;
}


static inline void list_add(struct list_head *new, struct list_head *head)
{
        __list_add(new, head, head->next);
}

#define list_for_each(pos, head) \
        for (pos = (head)->next; pos != (head); pos = pos->next)


/*
ptr->cur;
type->struct score_st
member->node

*/


#define offsetof(TYPE, MEMBER)  ((size_t)&((TYPE *)0)->MEMBER)


#define container_of(ptr, type, member) ({                      \
        const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
        (type *)( (char *)__mptr - offsetof(type,member) );})


#define list_entry(ptr, type, member) \
        container_of(ptr, type, member)


#endif
  • main.c文件内容：
#include <stdio.h>
#include <stdlib.h>
#define NAMESIZE 32
#include "list.h"

struct score_st
{
    int id;
    char name[NAMESIZE];
    struct list_head node;
    int math;
    int chinese;    
    
};


static void print_s(struct score_st *d)
{

    printf("%d %s %d %d \n",d->id,d->name,d->math,d->chinese);
}

int main()
{
    struct score_st *datap;
    struct list_head *cur;
    LIST_HEAD(head);
    int i;
    for(i=0;i<7;i++)
    {
        datap=malloc(sizeof(*datap));
        if(datap == NULL)
            exit(1);

        datap->id=i;
        snprintf(datap->name,NAMESIZE,"stu%d",i);
        datap->math=rand()%100;
        datap->chinese=rand()%100;

        list_add(&datap->node,&head);
        
    }
    
    list_for_each(cur,&head)
    {
        datap=list_entry(cur,struct score_st,node);
        print_s(datap);
    }    

    //find
        list_for_each(cur,&head)
        {
                datap=list_entry(cur,struct score_st,node);
                if(datap->id == 5)
            break;
        }
    
    if(cur==&head)
        printf("Can not find the id\n");
    else
        print_s(datap);
    
    
    exit(0);
}

运行结果：

在这里插入图片描述

IU555
关注
专栏目录
C语言双向循环链表
qq_45911878的博客
08-07 4429
C语言单向链表正向、反向、排序插入和链表逆转。
双向循环链表操作的实现
m0_53676388的博客
01-24 2128
对双向循环列表进行如下操作： 1.建立一个空表。 2.在第i个位置插入新的元素x。 3.删除第i个位置上的元素。 4.取第i个位置上的元素。 5.返回元素x第一次出现在双向循环链表中的位置号。 6.求双向循环链表的长度，即元素个数。 7.输出双向循环链表中所有的元素值。 8.实现双向循环链表的就地逆置。
Linux操作系统中通用双向循环链表的实现分析.pdf
09-06
Linux操作系统中通用双向循环链表的实现分析 Linux操作系统是一个支持多用户、多任务、多线程和多CPU的开源操作系统，其内核功能强大、性能稳定并具有丰富的应用软件支持。Linux内核源代码主要由C语言和少量的汇编...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
21_动态规划与数据结构结合
刘炫320的博客
09-11 531
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 949
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
【华为OD】2024D卷——生成哈夫曼树
weixin_45653183的博客
09-12 1287
这是通过构建一种特殊的二叉树来实现的，其中每个字符都位于树的一个叶节点上，且该叶节点到根节点的路径上的边所代表的字符（在哈夫曼编码中通常使用0和1表示）共同构成了该字符的编码。·新节点作为这两个子节点的父节点，而原来的两个节点则成为新节点的左右子节点（通常约定左子节点频率小于等于右子节点）。2、不断从堆中取出两个最小的节点作为左右子树，构造一个新的父节点，其权值为两个节点权值之和，并将新节点插入堆中。·然后，算法反复地选择两个频率最小的节点，将它们合并为一个新的节点，新节点的频率是两个子节点频率之和。
[数据结构]二叉搜索树
2302_80220453的博客
09-15 552
今天我们来学习一下新的数据结构，二叉搜索树，这个结构比较简单，是一个铺垫式的结构，为之后的平衡二叉树，AVL树以及红黑树做一个知识基础，我们将从概念到实现具体的介绍二叉搜索树。
【数据结构】线性表的定义和基本操作
m0_74209563的博客
09-12 415
线性表是具有相同数据类型的 n（n≥0）个数据元素的有限序列，其中 n 为表长，当 n=0 时线性表是一个空表注意：① 元素的数据类型相同意味着每个元素所占空间一样大；② 线性表是有限序列意味着各元素之间有先后次序且数量是有限的】若用 L 命名线性表，则其一般表示为La1a2aiai1anLa1​a2​ai​ai1​an​aia_iai​是线性表中的 “第 i 个” 元素线性表中的位序【注意位序是从1开始的，数组下标是从0开始的】a。
数据结构之哈希表
最新发布
weixin_44021343的博客
09-15 334
在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，就有了散列表查找。散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。
数据结构 | 栈和队列
TTKunn的博客
09-15 1017
本文详细介绍了栈和队列的数据结构及其实现
从0开始的算法（数据结构和算法）基础（十）
Solidao的博客
09-12 863
分治的字面意思是分而治之，将问题进行分化，从而进行处理，最后将结果进行合并。尽量的将问题分的不可以再分，分到和操作系统里面的原语是一样的，用较为多空间进行多线程的并行，节省时间运行。递归调用可能会导致较大的递归开销，特别是在递归深度较大的情况下，可能会导致栈溢出。在某些情况下，分治方法可能会导致对同一子问题的重复计算，从而降低效率。例如，在动态规划问题中，使用简单的分治方法可能会导致大量重复计算。
数据结构：堆排序
2303_78940834的博客
09-15 978
更完堆，再更一期堆排序。
Java实现双向循环链表详解
"这是一个关于Java实现双向循环链表的详细设计文档，其中包含了主要类的代码实现和迭代器的构造方法。" 在Java编程中，双向循环链表是一种数据结构，它允许在链表的两个方向上进行遍历。与单向链表不同，双向循环...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值