day 22 双向链表

最新推荐文章于 2025-12-28 21:52:08 发布
原创 最新推荐文章于 2025-12-28 21:52:08 发布 · 443 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构

由于单向链表只能从某个节点开始单向访问其后继节点,并没有存储其前驱节点信息，访问前面的节点是不容易办到的。

为了能从某个节点开始，既可以访问前驱节点也可以访问后继节点，我们可以改造一下单向链表的节点结构，在结构中多参加一个指向前驱节点的指针。

节点结构体类型

1.相比于单向链表的节点类型，多了一个指向前驱节点的指针

2.通过任意一个节点，既可以访问前驱节点也可以访问后继节点

typedef char datatype;  //数据元素类型

//定义双向链表结点类型
typedef struct Node
{
    union
    {
     datatype   data;     //普通结点数据域
     int len;           //头结点数据域
    };

     struct Node *prio;   //指向前驱节点的指针
     struct Node *next;   //指向后继节点的指针

}Node, *Node_ptr;

创建双向链表

1.只需要创建一个头节点即可

2.初始化时，需要两个指针域都置空

3.返回值为头节点的指针

//创建双向链表
Node_ptr list_create()
{
    //堆区申请一个头结点的大小
    Node_ptr L = (Node_ptr)malloc(sizeof(Node));
    if(NULL==L)
    {
        printf("链表创建失败\n");
        return NULL;
    }

    //初始化头结点
    L->len = 0;          //链表长度
    L->prio = NULL;        //前驱指针为空
    L->next = NULL;        //后继指针为空

    printf("链表创建成功\n");
    return L;
}

双向链表判空

//判空:1表示空，0表示非空
int list_empty(Node_ptr L)
{
    //判断逻辑
    if(NULL==L)
    {
        printf("链表不合法\n");
        return -1; 
    }
    return L->next==NULL;
}

申请节点封装数据

static Node_ptr list_node_apply(datatype e)
{
    //堆区申请一个结点
    Node_ptr p = (Node_ptr)malloc(sizeof(Node));
    if(NULL==p)
    {
        printf("结点申请失败\n");
        return NULL;
    }
    //将数据封装进数据域
    p->data = e;
    p->next = NULL;
    p->prio = NULL;

    return p;
}

双向链表头插

//头插
int list_insert_head(Node_ptr L, datatype e)
{
    //判断逻辑
    if(NULL == L)
    {
        printf("所给链表不合法\n");
        return -1;
    }

    //申请结点封装数据
    Node_ptr p = list_node_apply(e);
    if(NULL==p)
    {
        return -1;
    }

    //头插逻辑
    if(list_empty(L))
    {
        //链表为空
        p->prio = L;
        L->next = p;
    }else
    {
        //链表不为空
        p->next = L->next;
        p->prio = L;
        L->next->prio = p;   //p->next->prio = p;
        L->next = p;
    }
    //表长变化
    L->len++;
    printf("插入成功\n");
    return 0;
}

双向链表的遍历

//遍历
void list_show(Node_ptr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("遍历失败\n");
        return ;
    }
    //遍历逻辑
    printf("当前链表中的元素分别是：");
    Node_ptr q = L->next;    //定义遍历指针从第一个结点出发
    while(q!=NULL)
    {
        printf("%c\t", q->data);
        q = q->next;
    }
    printf("\n");
}

按位置查找返回节点

//按位置查找返回结点
Node_ptr list_search_pos(Node_ptr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) ||pos<0 || pos>L->len)
    {
        printf("查找失败\n");
        return NULL;
    }

    //定义遍历指针从头结点出发
    Node_ptr q = L;
    for(int i=0; i<pos; i++)
    {
        q = q->next;
    }

    //将找到的结点返回
    return q;
}

双向链表任意位置插入

1.插入时。可以找到要插入的位置进行插入，也可以找到其前驱节点进行插入

2.使用双向链表完成尾插时要额外注意

//任意位置插入
int list_insert_pos(Node_ptr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || pos<1 || pos>L->len+1)
    {
        printf("插入失败\n");
        return -1;
    }

    //找到其前驱结点
    Node_ptr q = list_search_pos(L, pos-1);

    //申请结点封装数据
    Node_ptr p = list_node_apply(e);
    if(NULL==p)
    {
        return -1;
    }

    //插入逻辑
    if(q->next ==NULL)
    {
        //说明要进行尾插
        p->prio = q;
        q->next = p;
    }else
    {
        //中间任意位置
        p->next = q->next;
        p->prio = q;
        q->next->prio = p;
        q->next = p;
    }

    //表长变化
    L->len++;
    printf("插入成功\n");
    return 0;
}

双向链表的头删

//头删
int list_delete_head(Node_ptr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("删除失败\n");
        return -1;
    }
    //删除逻辑
    Node_ptr p = L->next;    //标记

    //判断要删除的结点后面是否还有结点
    if(NULL == p->next)
    {
        //说明p是链表中最后一个结点
        L->next = NULL;
    }else
    {
        //说明p不是最后一个结点
        L->next = p->next;
        p->next->prio = L;
    }

    free(p);          //释放结点
    p = NULL;

    //表长变化
    L->len--;
    printf("删除成功\n");
    return 0;
}

双向链表任意位置删除

//任意位置删除
int list_delete_pos(Node_ptr L, int pos)
{
    //判断逻辑
    if(NULL==L ||list_empty(L) ||pos<1 || pos>L->len)
    {
        printf("删除失败\n");
        return -1;
    }
    //找到要删除的结点
    Node_ptr q = list_search_pos(L, pos);

    //删除逻辑
    if(q->next == NULL)
    {
        //说明要删除的是最后一个结点
        q->prio->next = NULL;   //将前面的结点后继指针置空
    }else
    {
        //交接工作
        q->prio->next = q->next;
        q->next->prio = q->prio;
    }

    free(q);       //释放结点
    q = NULL;

    //表长变化
    L->len--;
    printf("删除成功\n");
    return 0;
}

双向链表按位置修改

//按位置进行修改
int list_update_pos(Node_ptr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || list_empty(L) ||pos<1 || pos>L->len)
    {
        printf("修改失败\n");
        return -1;
    }

    //找到要修改的结点
    Node_ptr p = list_search_pos(L, pos);
    
    p->data = e;          //将当前数据域进行修改

    printf("修改成功\n");
    return 0;

}

双向链表的释放

//销毁双向链表
void list_destroy(Node_ptr L)
{
    //判断链表是否合法
    if(NULL == L)
    {
        return ;
    }

    //开始将所有结点释放
    while(!list_empty(L))
    {
        //不断进行头删
        list_delete_head(L);
    }

    //释放头结点
    free(L);
    L = NULL;
    printf("销毁成功\n");
}

全部代码

doublelinklist.h

#ifndef DOUBLKELINKLIST_H
#define DOUBLKELINKLIST_H

typedef char datatype;  //数据元素类型

//定义双向链表结点类型
typedef struct Node
{
    union
    {
     datatype   data;     //普通结点数据域
     int len;           //头结点数据域
    };

     struct Node *prio;   //指向前驱节点的指针
     struct Node *next;   //指向后继节点的指针

}Node, *Node_ptr;

//创建双向链表
Node_ptr list_create();

//判空
int list_empty(Node_ptr L);

//头插
int list_insert_head(Node_ptr L, datatype e);

//遍历
void list_show(Node_ptr L);

//按位置查找返回结点
Node_ptr list_search_pos(Node_ptr L, int pos);

//任意位置插入
int list_insert_pos(Node_ptr L, int pos, datatype e);

//头删
int list_delete_head(Node_ptr L);

//任意位置删除
int list_delete_pos(Node_ptr L, int pos);

//按位置进行修改
int list_update_pos(Node_ptr L, int pos, datatype e);

//销毁双向链表
void list_destroy(Node_ptr L);




#endif

doublelinklist.c

#include<myhead.h>
#include"doublelinklist.h"

//创建双向链表
Node_ptr list_create()
{
    //堆区申请一个头结点的大小
    Node_ptr L = (Node_ptr)malloc(sizeof(Node));
    if(NULL==L)
    {
        printf("链表创建失败\n");
        return NULL;
    }

    //初始化头结点
    L->len = 0;          //链表长度
    L->prio = NULL;        //前驱指针为空
    L->next = NULL;        //后继指针为空

    printf("链表创建成功\n");
    return L;
}

//判空:1表示空，0表示非空
int list_empty(Node_ptr L)
{
    //判断逻辑
    if(NULL==L)
    {
        printf("链表不合法\n");
        return -1; 
    }
    return L->next==NULL;
}

//定义申请结点封装数据函数
static Node_ptr list_node_apply(datatype e)
{
    //堆区申请一个结点
    Node_ptr p = (Node_ptr)malloc(sizeof(Node));
    if(NULL==p)
    {
        printf("结点申请失败\n");
        return NULL;
    }
    //将数据封装进数据域
    p->data = e;
    p->next = NULL;
    p->prio = NULL;

    return p;
}

//头插
int list_insert_head(Node_ptr L, datatype e)
{
    //判断逻辑
    if(NULL == L)
    {
        printf("所给链表不合法\n");
        return -1;
    }

    //申请结点封装数据
    Node_ptr p = list_node_apply(e);
    if(NULL==p)
    {
        return -1;
    }

    //头插逻辑
    if(list_empty(L))
    {
        //链表为空
        p->prio = L;
        L->next = p;
    }else
    {
        //链表不为空
        p->next = L->next;
        p->prio = L;
        L->next->prio = p;   //p->next->prio = p;
        L->next = p;
    }
    //表长变化
    L->len++;
    printf("插入成功\n");
    return 0;
}

//遍历
void list_show(Node_ptr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("遍历失败\n");
        return ;
    }
    //遍历逻辑
    printf("当前链表中的元素分别是：");
    Node_ptr q = L->next;    //定义遍历指针从第一个结点出发
    while(q!=NULL)
    {
        printf("%c\t", q->data);
        q = q->next;
    }
    printf("\n");
}

//按位置查找返回结点
Node_ptr list_search_pos(Node_ptr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) ||pos<0 || pos>L->len)
    {
        printf("查找失败\n");
        return NULL;
    }

    //定义遍历指针从头结点出发
    Node_ptr q = L;
    for(int i=0; i<pos; i++)
    {
        q = q->next;
    }

    //将找到的结点返回
    return q;
}

//任意位置插入
int list_insert_pos(Node_ptr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || pos<1 || pos>L->len+1)
    {
        printf("插入失败\n");
        return -1;
    }

    //找到其前驱结点
    Node_ptr q = list_search_pos(L, pos-1);

    //申请结点封装数据
    Node_ptr p = list_node_apply(e);
    if(NULL==p)
    {
        return -1;
    }

    //插入逻辑
    if(q->next ==NULL)
    {
        //说明要进行尾插
        p->prio = q;
        q->next = p;
    }else
    {
        //中间任意位置
        p->next = q->next;
        p->prio = q;
        q->next->prio = p;
        q->next = p;
    }

    //表长变化
    L->len++;
    printf("插入成功\n");
    return 0;
}

//头删
int list_delete_head(Node_ptr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("删除失败\n");
        return -1;
    }
    //删除逻辑
    Node_ptr p = L->next;    //标记

    //判断要删除的结点后面是否还有结点
    if(NULL == p->next)
    {
        //说明p是链表中最后一个结点
        L->next = NULL;
    }else
    {
        //说明p不是最后一个结点
        L->next = p->next;
        p->next->prio = L;
    }

    free(p);          //释放结点
    p = NULL;

    //表长变化
    L->len--;
    printf("删除成功\n");
    return 0;
}

//任意位置删除
int list_delete_pos(Node_ptr L, int pos)
{
    //判断逻辑
    if(NULL==L ||list_empty(L) ||pos<1 || pos>L->len)
    {
        printf("删除失败\n");
        return -1;
    }
    //找到要删除的结点
    Node_ptr q = list_search_pos(L, pos);

    //删除逻辑
    if(q->next == NULL)
    {
        //说明要删除的是最后一个结点
        q->prio->next = NULL;   //将前面的结点后继指针置空
    }else
    {
        //交接工作
        q->prio->next = q->next;
        q->next->prio = q->prio;
    }

    free(q);       //释放结点
    q = NULL;

    //表长变化
    L->len--;
    printf("删除成功\n");
    return 0;
}

//按位置进行修改
int list_update_pos(Node_ptr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || list_empty(L) ||pos<1 || pos>L->len)
    {
        printf("修改失败\n");
        return -1;
    }

    //找到要修改的结点
    Node_ptr p = list_search_pos(L, pos);
    
    p->data = e;          //将当前数据域进行修改

    printf("修改成功\n");
    return 0;

}

//销毁双向链表
void list_destroy(Node_ptr L)
{
    //判断链表是否合法
    if(NULL == L)
    {
        return ;
    }

    //开始将所有结点释放
    while(!list_empty(L))
    {
        //不断进行头删
        list_delete_head(L);
    }

    //释放头结点
    free(L);
    L = NULL;
    printf("销毁成功\n");
}
main.c
#include"doublelinklist.h"
#include<myhead.h>

int main(int argc, const char *argv[])
{
    //调用创建链表函数
    Node_ptr L = list_create();
    if(NULL==L)
    {
        return -1;
    }

    //调用头插函数
    list_insert_head(L,'Q');
    list_insert_head(L,'W');
    list_insert_head(L,'E');
    list_insert_head(L, 'R');

    //调用遍历函数
    list_show(L);

    //调用任意位置插入函数
    list_insert_pos(L, 1, 'D');
    list_insert_pos(L, L->len+1, 'F');
    list_insert_pos(L, 3, 'K');
    list_show(L);

    //调用头删函数
    list_delete_head(L);
    list_delete_head(L);
    list_show(L);

    //调用任意位置删除函数
    list_delete_pos(L, 1);
    list_delete_pos(L, 3);
    list_show(L);

    //调用按位置修改函数
    list_update_pos(L, 1, 'M');
    list_show(L);

    //销毁双向链表
    list_destroy(L);
    L = NULL;

    list_show(L);


    
    return 0;
}

循环链表

1.循环链表：首尾相接的链表称为循环链表

        特点：在循环链表中，没有一个节点的指针域为空

分类：

        单向循环链表：将单链表最后一个节点的指针域指向第一个节点即可（或者指向头节点）

        双向循环链表：将头节点的前驱指针指向最后一个节点，最后一个节点的后继指针指向头节点

单向循环链表节点结构体

typedef struct Node
{
    union 
    {
        int len;   //头节点数据域
        datatype data;   //普通结点数据域
    };

    //指针域
    struct Node * next;   
}Node, *Node_ptr;

循环链表的创建

注意：创建链表时，头节点指针域指向自己

//创建循环链表
Node_ptr list_create()
{
    //在堆区申请一个头结点的空间
    Node_ptr L = (Node_ptr)malloc(sizeof(Node));
    if(NULL==L)
    {
        printf("创建链表失败\n");
        return NULL;
    }

    //初始化
    L->len = 0;
    L->next = L;          //指针域指向自己

    printf("循环链表创建成功\n");
    return L;
}

全部代码

looplinklist.h
#ifndef LOOPLINKLIST_H
#define LOOPLINKLIST_H

typedef char datatype;    //数据元素类型

//定义节点类型
typedef struct Node
{
    union 
    {
        int len;   //头节点数据域
        datatype data;   //普通结点数据域
    };

    //指针域
    struct Node * next;   
}Node, *Node_ptr;

//创建循环链表
Node_ptr list_create();

//判空
int list_empty(Node_ptr L);

//尾插
int list_insert_tail(Node_ptr L, datatype e);

//遍历
void list_show(Node_ptr L);

//尾删
int list_delete_tail(Node_ptr L);

//删除头结点
Node_ptr list_head_delete(Node_ptr L);

//销毁
void list_destroy(Node_ptr L);
//删除头结点的循环链表的遍历
void list_desplay(Node_ptr H);




#endif
looplinklist.c
#include"looplinklist.h"
#include<myhead.h>


//创建循环链表
Node_ptr list_create()
{
    //在堆区申请一个头结点的空间
    Node_ptr L = (Node_ptr)malloc(sizeof(Node));
    if(NULL==L)
    {
        printf("创建链表失败\n");
        return NULL;
    }

    //初始化
    L->len = 0;
    L->next = L;          //指针域指向自己

    printf("循环链表创建成功\n");
    return L;
}

//判空 ： 1表示空，0表示非空
int list_empty(Node_ptr L)
{
    if(NULL==L)
    {
        printf("链表不合法\n");
        return -1;
    }

    return L->next == L;  //判断是否为空格
}

//尾插
int list_insert_tail(Node_ptr L, datatype e)
{
    //判断逻辑
    if(NULL==L)
    {
        printf("插入失败\n");
        return -1;
    }

    //找到最后一个结点
    Node_ptr q = L;    //定义遍历指针从头结点出发
    while(q->next != L)
    {
        q = q->next;    //不断将遍历指针后移，直到移到最后一个结点位置
    }

    //申请结点将数据封装
    Node_ptr p = (Node_ptr)malloc(sizeof(Node));
    if(NULL==p)
    {
        printf("结点申请失败\n");
        return -1;
    }p->data = e;     //将数据封装进结点
    p->next = NULL;    //防止野指针


    //插入逻辑
    p->next = L;  //将新节点指针域指向头结点
    q->next = p;  //将最后一个结点的指针域指向自己

    //表长变化
    L->len++;
    printf("插入成功\n");
}

//遍历
void list_show(Node_ptr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("遍历失败\n");
        return ;
    }

    //遍历逻辑
    printf("链表中的元素分别是：");
    Node_ptr q = L->next;  //定义遍历指针从第一个结点开始
    while(q != L)
    {
        printf("%c\t", q->data);
        q = q->next;
    }
    printf("\n");

}

//尾删
int list_delete_tail(Node_ptr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("删除失败\n");
        return -1;
    }

    //找到倒数第二个结点
    Node_ptr q = L;
    while(q->next->next != L)
    {
        q = q->next;
    }

    //删除逻辑
    free(q->next);    //释放最后一个结点
    q->next = L;     //将新的最后一个结点指针域指向头结点

    //表长变化
    L->len--;

    printf("删除成功\n");
    return 0;
}

//删除头结点
Node_ptr list_head_delete(Node_ptr L)
{
    //判断逻辑
    if(NULL==L)
    {
        printf("去头失败\n");
        return NULL;
    }
    if(list_empty(L))        //如果为空，直接释放
    {
        free(L);        //释放头结点
        return NULL;
    }

    //遍历整个链表找到最后一个结点
    Node_ptr q = L->next;    //从第一个结点出发
    while(q->next != L)
    {
        q = q->next;
    }

    //将最后一个结点的指针域指向第一个结点
    q->next = L->next;

    free(L);    //将头结点释放
    L = NULL;

    printf("去头成功\n");
    return q->next;
}


//删除头结点的循环链表的遍历
void list_desplay(Node_ptr H)
{
    //判断链表释放为空
    if(NULL==H)
    {
        printf("遍历失败\n");
        return ;
    }

    //定义遍历指针从当前结点出发
    printf("链表总的结点元素分别是：");
    Node_ptr q = H;
    do
    {
        printf("%c\t", q->data);
        q = q->next;
    }while(q!=H);
    printf("\n");
}

//销毁
void list_destroy(Node_ptr H)
{
    if(NULL==H)   //说明已经销毁了
    {
        return;
    }

    //先将其他结点释放
    while(H->next != H)
    {
        Node_ptr p = H->next;   //标记下一个结点
        H->next = p->next;   //孤立
        free(p);    //释放
        p = NULL;
    }

    //将第一个结点释放
    free(H);
    H = NULL;
    printf("销毁成功\n");
    return ;
}
main.c
#include"looplinklist.h"
#include<myhead.h>

int main(int argc, const char *argv[])
{
    //调用创建链表函数
    Node_ptr L = list_create();
    if(NULL==L)
    {
        return -1;
    }
    
    //调用尾插函数
    list_insert_tail(L, 'Q');
    list_insert_tail(L, 'W');
    list_insert_tail(L, 'E');
    list_insert_tail(L, 'R');

    //调用遍历函数
    list_show(L);

    //调用尾删函数
    list_delete_tail(L);
    list_delete_tail(L);

    list_show(L);

    //调用循环链表去头操作
    Node_ptr H = list_head_delete(L);
    L = NULL;
    //此时的H就是指向链表的头指针
    
    //调用遍历函数，遍历去头后的链表
    list_desplay(H);

    //调用销毁函数
    list_destroy(H);
    H = NULL;
    list_desplay(H);

    
    return 0;
}

luochen330x
关注
数据结构(Java)——Day10(双向链表，栈)
LengchenAl的博客
11-24 906
数据结构(Java)——Day10(双向链表，栈)
Day27-【13003】短文，什么是单链表、循环链表、双向链表、双向循环链表？它们的操作时间复杂度是多少？如何进行存储单元的计算？
weixin_48146444的博客
01-27 1397
现在考虑当前指针的另一种定义方式。查看操作的步骤可知，插入操作及删除操作涉及的表结点都只有3个，即当前结点及它的前驱结点和新结点。现在改变当前指针指向的位置，让它前移一个位置即指向当前结点的前驱结点。也就是不要往后指，直接往前指这样，从当前指针所指位置开始，定位操作中涉及的3个结点就非常方便了，因为它们都在当前指针后面不远的地方。意思是都在当前指针后面了仍以图2-7为例，让指针curr前移一个结点，即curr指向结点B，那么在插入元素E时，创建新结点后，能很容易地找到并修改相关的指针。
DAY16 C语言双向链表
m0_69965956的博客
10-30 217
1、头插法创建双向链表，节点是学生信息（学号，分数，姓名）2、调用函数遍历链表所有信息3、调用函数，求出分数是完数的学生，并输出该学生所有信息4、调用函数，按照姓名查找某个学生是否存在，存在输出该学生是第几个节点。
day19 双向链表
qq_57100802的博客
07-29 255
思维导图 作业 i) 完成双向链表的创建、判空、申请节点封装数据、头插、遍历 ii) 任意位置插入（插入是否是最后一个位置，需要思考不同情景） iii) 如果有时间，可以继续写任意位置删除以及销毁。
day19双向链表
2301_77655036的博客
07-24 130
尾删代码：按位插入代码：按位删除代码：按位修改代码：按位查找代码：主函数部分：
Day15 双向链表 内核链表
m0_71562438的博客
02-17 173
【代码】Day15 双向链表 内核链表。
day6双向链表
m0_73912044的博客
08-29 80
Day06双向链表
hello_world_juns的博客
10-29 442
双向链表设计
day18双向链表和循环链表
m0_69277585的博客
07-22 627
3> 注意：对于双向链表的任意位置进行操作时（插入、删除），可以找到前驱结点处理也可以不用找到前驱结点。3> 双向循环链表：需要将最后一个阶段的指针域指向头结点，头结点的前驱指针指向最后一个阶段。1> 参数：不需要，只需要从堆区申请出一个头结点大小的空间，就创建了一个双向链表。3> 注意：需要使用一个遍历指针，从第一个节点出发，到最后一个节点。3> 注意：对于空链表和非空链表的插入，有所不同，并且不能合并。3> 注意：需要将所有的节点，全部删除后，然后删除头结点。1> 参数：链表、要删除的位置。
Day23 双向链表
oareen的博客
08-20 691
/ 存储字典条目：单词与释义// 单词// 释义} DATATYPE;// 链表节点结构// 数据域// 指针域，指向下一个节点} LinkNode;// 链表管理结构// 头节点指针int clen;// 当前有效元素个数} LinkList;// 函数声明#endif //!char sex;int age;int score;} DATATYPE;int clen;} DIRECT;// 函数声明。
数据结构day4双向链表
m0_74409800的博客
07-24 444
【代码】数据结构day4双向链表。
Java 手写双向链表
weixin_41914010的博客
04-14 997
Java 手写双向链表 DoubleLinkedList.java package com.muxiaofei.veryday.entity; /** * 双链表 * * @param <T> */ public class DoubleLinkedList<T> { //链表大小 public int size; // 头节点（先初始化一下） Node<T> head = new Node<>(); //
嵌入式学习-线性表Day05-双向链表
Xiaomo1536的博客
10-10 620
双向链表//双向链表的节点定义//数据域//指向下一个节点的指针 next 下一个//指向前一个节点的指针 prior 先前的//将双向链表的头指针和尾指针封装到一个节点体里//思想上有点像学的链式队列//指向双向链表的头指针//指向双向链表的尾指针int len;//用来保存当前双向链表的长度操作函数1）创建一个空的双向链表2）双向链表中间插入。
m数据结构 day10 树（三）线索二叉链表（双向链表）
wulimmya的博客
07-31 2268
二叉树的遍历 traversing binary tree 线性表的遍历很简单，因为元素具有一对一的前驱后继关系，遍历就是从头到尾，最多再来个循环遍历，双向遍历等。但是树的遍历更为复杂，因为一个结点访问后，下一个访问哪一个结点的选择不唯一。 我们喜欢用图的方式来表示树，即把树画成图，这样对我们人类很好理解，但是对于计算机，他只能处理线性序列，只能用循环和判断等方式，所以我们要通过遍历把树的所有结点变成某种意义的线性序列。 遍历是为了把树的所有结点变成某种意义的线性序列，以便计算机进行处理。 就这个次序最重
Redis 7 底层数据结构
WenZhang的博客
12-28 1344
Redis 7采用对象系统架构，所有数据存储在redisObject中，包含类型、编码、引用计数等元数据。字符串系统使用5种SDS结构，根据长度自动选择最优编码（INT/EMBSTR/RAW）。列表结构采用QuickList复合设计，结合双向链表与紧凑列表，通过智能压缩策略平衡内存与性能。哈希、集合等类型根据元素数量/大小自动选择最优编码（如LISTPACK或哈希表），实现内存高效利用。Redis 7通过精细化的数据结构设计和自适应编码转换机制，在保证高性能的同时优化内存使用。
数据结构--队列
2501_90980137的博客
12-28 301
• 入队（enqueue）：在队尾添加元素，若队列满则抛出异常或进行扩容。• 出队（dequeue）：删除并返回队头元素，若队列为空则抛出异常。队列是先进先出（FIFO）的线性数据结构，元素从队尾入队，队头出队。◦ 用单链表存储元素，队头指向链表头节点，队尾指向链表尾节点。• 判空（isEmpty）：判断队列中是否存在元素。• 查看队头（peek）：返回队头元素但不删除。• 查看大小（size）：获取队列中元素的个数。• 任务排队（如打印机任务队列、线程池任务队列）1. 数组实现（顺序队列）
数据结构--学生管理系统
2501_90980137的博客
12-28 344
System.out.println("学号：" + temp.id + " 姓名：" + temp.name + " 年龄：" + temp.age);manager.addStudent(new Student("001", "张三", 20));System.out.println("学号重复，添加失败");System.out.println("暂无学生信息");System.out.println("未找到该学生");◦ 查询：支持按学号精准查询、按姓名模糊查询，以及遍历展示所有学生。
数据结构(十一) 哈希表
C/C++技术栈
12-28 1047
哈希表是一种高效的查找结构，通过哈希函数建立关键码与存储位置的映射关系，实现O(1)的平均查找时间复杂度。文章详细介绍了两种哈希冲突解决方法：开放地址法（线性探测和二次探测）和链地址法（哈希桶），并分析了负载因子对性能的影响。同时阐述了哈希函数设计原则和常见方法（直接定址法、除留余数法等），并提供了C++实现代码，包括插入、查找、删除等核心操作。针对字符串等非整型数据，还介绍了特化的哈希函数处理方法。通过对比两种冲突解决方式的优缺点，为实际应用提供了选择依据。
数据结构-什么是单向链表？
最新发布
li_654的博客
12-28 602
单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。链表的知识点初学起来感觉很抽象，开始时可以先把链表的定义、查找、插入、删除这些基本操作用代码敲一下，然后，最好是实际应用一下，找一个例程把需要处理的数据通过链表存储起来，数据的查找、更新数据插入、删除旧的数据等这些操作都实践一下，只有用了，才能真正理解链表，只学习概念理论，没什么用。单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。3.然后修改指针，删除s所指向的结点；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值