数据结构NO3--链表

最新推荐文章于 2022-12-08 17:57:59 发布
最新推荐文章于 2022-12-08 17:57:59 发布
阅读量247 收藏
点赞数 2
分类专栏： 随笔
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiguanlant/article/details/106432484
版权

看了这个妈妈再也不担心我的链表啦QVQ…

3.1链表的定义

找了一堆感觉都是废话

3.2动态内存分配

malloc：

fp = (数据类型*)malloc(sizeof(数据类型))

free：

free(void *fp)

3.3链表的建立

typedef struct list
{
    int num;
    struct list *next;
}node;
typedef node *link;

link creat_list(int n)
{
    link head;
    link ptr;
    int i;

    head = (link)malloc(sizeof(node));
    if(!head)
    {
        cout << "内存分配失败" << endl;
        return 0;
    }
    head->next = NULL;
    ptr = head;

    cout << "输入n个数据" << endl;
    for(i = 1; i <= n; ++i)
    {
        scanf("%d", &ptr->num);
        ptr->next = (link)malloc(sizeof(node));
        if(!ptr->next)
        {
            cout << "内存分配失败" << endl;
            return 0;
        }
        ptr->next->next = NULL;
        ptr = ptr->next;
    }
    return head;
}

3.4链表的遍历

link find_node(link head, int num)
{
    link ptr;
    ptr = head;
    while (ptr != NULL)
    {
        if(ptr->num == num)
            return ptr;
        ptr = ptr->next;
    }
    cout << "node" << endl;
    return ptr;
}

3.5链表的连接

link concatenate(link ptr1, link ptr2)
{
    link ptr;
    ptr = ptr1;
    while(ptr->next != NULL) //让ptr1的尾巴指向ptr2的头
        ptr = ptr->next;
    ptr->next = ptr2;
    return ptr1;
}

3.6链表内节点的删除

三种情况：

  • 删除第一个节点
  • 删除最后一个节点
  • 删除中间节点
link delete_node(link head, link ptr)
{
    link previous;
    if(ptr == head) //删头
        return head->next;
    else
    {
        previous = head;
        while (previous->next != ptr)
        {
            previous = previous->next;
        }
        previous->next = ptr->next;
    }
    free(ptr); //有借有还，再借不难
    return head;
}

3.7释放链表的内存空间

link destroy_list(link head)
{
    link ptr;
    while(head != NULL)
    {
        ptr = head;
        head = head->next;
        free(ptr);
    }
}

3.8链表内节点的插入

与删除一样会有三种情况

link insert_node(link head, link ptr, int value) //插入在ptr之后
{
    link new_node = (link)malloc(sizeof(node));
    if(!new_node)
    {
        cout << "分配内存失败" << endl;
        return NULL;
    }
    new_node->num = value;
    new_node->next = NULL;
    if(ptr == NULL) //头插
    {
        new_node->next = head;
        return new_node;
    }
    else
    {
        if(ptr->next == NULL) //尾插
            ptr->next = new_node;
        else //中间插
        {
            new_node->next = ptr->next;
            ptr->next = new_node;
        }
        
    }
    return head;
}

3.9链表结构的反转

link invert_list(link head)
{
    link mid, last;
    mid = NULL;
    while(head != NULL)
    {
        last = mid;
        mid = head;
        head = head->next;
        mid->next = last;
    }
    return mid;
}

让我们看看具体是怎么来的：

  1. 执行while之前 head指向链表第一个 mid == NULL， last无值
  2. 执行一次 head指向链表第二个 mid 指向 链表第一个 last == NULL
  3. 再执行一次 head指向链表第三个 mid 指向 链表第二个 last 指向 链表第一个 并且 mid的前驱是last
  4. 反复直到反转完成 返回mid 也就是反转后的头节点

3.10循环链表结构

头尾相连的链表

3.10.1首先建立链表
typedef struct clist
{
    int data;
    struct clist *next;
}cnode;
typedef cnode *clink;

clink creat_list(int n)
{
    clink head;
    clink ptr;
    int i;

    head = (clink)malloc(sizeof(cnode));
    if(!head)
    {
        cout << "内存分配失败" << endl;
        return 0;
    }
    head->next = NULL;
    ptr = head;

    cout << "输入n个数据" << endl;
    for(i = 1; i <= n; ++i)
    {
        scanf("%d", &ptr->data);
        ptr->next = (clink)malloc(sizeof(cnode));
        if(!ptr->next)
        {
            cout << "内存分配失败" << endl;
            return 0;
        }
        ptr->next->next = NULL;
        ptr = ptr->next;
    }
    ptr->next = NULL;
    return head;
}
3.10.2循环链表内节点的插入

  • 情况一 ：插在链表的头部成为链表的新开始

    • 将新节点的指针指向链表的第一个节点
    • 找到最后一个节点且将其指针指向新节点
    • 返回新节点 为链表新头部

  • 情况二：除情况一的其他情况，假设插在ptr之后

    • 将新节点的指针指向ptr下一节点
    • 将ptr的下一节点设为新节点
clink insert_node(clink head, clink ptr, int value)
{
    clink new_node = (clink)malloc(sizeof(cnode));
    clink previous;
    if(!new_node)
    {
        cout << "分配内存失败" << endl;
        return NULL;
    }
    new_node->data = value;
    new_node->next = NULL;
    if(head == NULL) //原先就是空表
    {
        new_node->next = new_node;
        return new_node;
    }
    if(ptr == NULL) // 头插
    {
        new_node->next = head;
        previous = head;
        while(previous->next != NULL)
            previous = previous->next;
        previous->next = new_node;
        head = new_node;
    }
    else
    {
        new_node->next = ptr->next;
        ptr->next = new_node;
    }
    return head;
}
3.10.3循环链表内节点的删除

  • 情况一：删第一个

    • 将链表的开始移向下一节点
    • 将最后一个节点指向第二个节点

  • 情况二：除情况一的其他情况，删除ptr

    • 找到ptr的前一个节点
    • 将ptr前一个节点的后继设为ptr的后继
clink delete_node(clink head, clink ptr)
{
    clink previous;
    if(head == NULL) //空表
        return NULL;
    previous = head;
    if(head != head->next) //不止一个节点
        while(previous->next != ptr)
            previous = previous->next;

    if(ptr == head) //头插
    {
        head = head->next;
        previous->next = ptr->next;
    }
    else
    {
        previous->next = ptr->next;
    }
    free(ptr);
    return head;
}

3.11双向链表结构

3.11.1双向链表的建立

俩个指针，一个指向前驱，一个指向后继

typedef struct dlist
{
    int data;
    struct dlist *front; //后继
    struct dlist *back; //前驱
}dnode;
typedef dnode *dlink;

dlink create_dlist(int *arr, int len)
{
    dlink head, before, new_node;
    int i;
    head = (dlink)malloc(sizeof(dnode));
    if(!head)
    {
        cout << "内存分配失败" << endl;
        return NULL;
    }
    head->data = arr[0];
    head->back = NULL;
    head->front = NULL;
    before = head;
    for(i = 1; i < len; ++i)
    {
        new_node = (dlink)malloc(sizeof(dnode));
        new_node->data = arr[i];
        new_node->front = NULL;
        new_node->back = before;
        before = new_node;
    }
    return head;
}
3.11.2双向链表的插入

  • 情况一：头插

    • 将新节点的指针front指向双向链表的开始
    • 将表头的back指向新节点
    • head = new_node

  • 情况二：尾插

    • 将最后一个节点的front指向新节点
    • 新节点的back指向尾部

  • 情况三：中间插，假设在ptr之后

    • 新节点的前驱指向ptr
    • 新节点的后继变为ptr的后继
    • ptr的后继指向新节点
    • 原ptr后继的前驱指向新节点
dlink insert_node(dlink head, dlink ptr, int value)
{
    dlink new_node = (dlink)malloc(sizeof(dnode));
    if(!new_node)
    {
        cout << "内存分配失败" << endl;
        return NULL;
    }
    new_node->back = NULL;
    new_node->front = NULL;
    new_node->data = value;
    if(head == NULL) //空表
        return new_node;
    if(ptr == NULL) //头插
    {
        new_node->front = head;
        head->back = new_node;
        head = new_node;
    }
    else
    {
        if(ptr->front == NULL) //尾插
        {
            ptr->front = new_node;
            new_node->back = ptr;
        }
        else
        {
            ptr->front->back = new_node;
            new_node->front = ptr->front;
            new_node->back = ptr;
            ptr->front = new_node;
        }
        
    }
    return head;  
}
3.11.3双向链表节点的删除

  • 情况一：删头

    • 将指向链表开始节点的指针head指向第二个节点
    • 将第二个节点的前驱设为NULL

  • 情况二：删尾

    • 最后一节点的后继设为NULL

  • 情况三：删中间，删除ptr

    • ptr前驱的后继设为ptr后继的前驱
    • ptr后继的前驱设为ptr前驱的后继
dlink delete_node(dlink head, dlink ptr)
{
    if(ptr->back == NULL) //删头
    {
        head = head->front;
        head->back = NULL;
    }
    else
    {
        if(ptr->front == NULL) //删尾
        {
            ptr->back->front == NULL;
        }
        else
        {
            ptr->back->front = ptr->front;
            ptr->front->back = ptr->back;
        }
        
    }
    free(ptr);
    return head;
}

3.12循环双向链表

3.12.1建立
typedef struct dlist
{
    int data;
    struct dlist *front; //后继
    struct dlist *back; //前驱
}cdnode;
typedef cdnode *cdlink;

cdlink create_dlist(int *arr, int len)
{
    cdlink head, before, new_node;
    int i;
    head = (cdlink)malloc(sizeof(cdnode));
    if(!head)
    {
        cout << "内存分配失败" << endl;
        return NULL;
    }
    head->data = arr[0];
    head->back = NULL;
    head->front = NULL;
    before = head;
    for(i = 1; i < len; ++i)
    {
        new_node = (cdlink)malloc(sizeof(cdnode));
        new_node->data = arr[i];
        new_node->front = NULL;
        new_node->back = before;
        before = new_node;
    }
    head->back = new_node;
    new_node->front = head;
    //head->back = NULL;
    //new_node->front = NULL;
    return head;
}

  • 情况一：删除或插入第一个节点

  • 情况二：除情况一

3.12.2删除
cdlink delete_node(cdlink head, cdlink ptr)
{
    if(head == NULL)
        return NULL;
    if(ptr == head) head = head->front; //头
    ptr->back->front = ptr->front;
    ptr->front->back = ptr->back;
    free(ptr);
    return head;
}
3.12.3插入
cdlink insert_node(cdlink head, cdlink ptr, int value)
{
    cdlink new_node = (cdlink)malloc(sizeof(cdnode));
    if(!new_node)
    {
        cout << "内存分配失败" << endl;
        return NULL;
    }
    new_node->data = value;
    if(head == NULL) //空表
    {
        new_node->back = new_node;
        new_node->front = new_node;
        return new_node;
    }
    if(ptr == NULL) //头插
    {
        head->back->front = new_node;
        new_node->front = head;
        new_node->back = head->back;
        head->back = new_node;
        head = new_node;
    }
    else
    {
        ptr->front->back = new_node;
        new_node->front = ptr->front;
        new_node->back = ptr;
        ptr->front = new_node;
    }
    return head;
}

最后代码大汇总

#include <bits/stdc++.h>
using namespace std;

typedef struct list
{
    int num;
    struct list *next;
}node;
typedef node *link;

link creat_list(int n)
{
    link head;
    link ptr;
    int i;

    head = (link)malloc(sizeof(node));
    if(!head)
    {
        cout << "内存分配失败" << endl;
        return 0;
    }
    head->next = NULL;
    ptr = head;

    cout << "输入n个数据" << endl;
    for(i = 1; i <= n; ++i)
    {
        scanf("%d", &ptr->num);
        ptr->next = (link)malloc(sizeof(node));
        if(!ptr->next)
        {
            cout << "内存分配失败" << endl;
            return 0;
        }
        ptr->next->next = NULL;
        ptr = ptr->next;
    }
    return head;
}

link find_node(link head, int num)
{
    link ptr;
    ptr = head;
    while (ptr != NULL)
    {
        if(ptr->num == num)
            return ptr;
        ptr = ptr->next;
    }
    cout << "node" << endl;
    return ptr;
}

link concatenate(link ptr1, link ptr2)
{
    link ptr;
    ptr = ptr1;
    while(ptr->next != NULL)
        ptr = ptr->next;
    ptr->next = ptr2;
    return ptr1;
}

link delete_node(link head, link ptr)
{
    link previous;
    if(ptr == head)
        return head->next;
    else
    {
        previous = head;
        while (previous->next != ptr)
        {
            previous = previous->next;
        }
        previous->next = ptr->next;
    }
    free(ptr);
    return head;
}

link destroy_list(link head)
{
    link ptr;
    while(head != NULL)
    {
        ptr = head;
        head = head->next;
        free(ptr);
    }
}

link insert_node(link head, link ptr, int value) //插入在ptr之后
{
    link new_node = (link)malloc(sizeof(node));
    if(!new_node)
    {
        cout << "分配内存失败" << endl;
        return NULL;
    }
    new_node->num = value;
    new_node->next = NULL;
    if(ptr == NULL) //头插
    {
        new_node->next = head;
        return new_node;
    }
    else
    {
        if(ptr->next == NULL) //尾插
            ptr->next = new_node;
        else //中间插
        {
            new_node->next = ptr->next;
            ptr->next = new_node;
        }
        
    }
    return head;
}

link invert_list(link head)
{
    link mid, last;
    mid = NULL;
    while(head != NULL)
    {
        last = mid;
        mid = head;
        head = head->next;
        mid->next = last;
    }
    return mid;
}

int main()
{

    return 0;
}   

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

typedef struct clist
{
    int data;
    struct clist *next;
}cnode;
typedef cnode *clink;

clink creat_list(int n)
{
    clink head;
    clink ptr;
    int i;

    head = (clink)malloc(sizeof(cnode));
    if(!head)
    {
        cout << "内存分配失败" << endl;
        return 0;
    }
    head->next = NULL;
    ptr = head;

    cout << "输入n个数据" << endl;
    for(i = 1; i <= n; ++i)
    {
        scanf("%d", &ptr->data);
        ptr->next = (clink)malloc(sizeof(cnode));
        if(!ptr->next)
        {
            cout << "内存分配失败" << endl;
            return 0;
        }
        ptr->next->next = NULL;
        ptr = ptr->next;
    }
    ptr->next = NULL;
    //ptr->next = head;
    return head;
}

clink insert_node(clink head, clink ptr, int value)
{
    clink new_node = (clink)malloc(sizeof(cnode));
    clink previous;
    if(!new_node)
    {
        cout << "分配内存失败" << endl;
        return NULL;
    }
    new_node->data = value;
    new_node->next = NULL;
    if(head == NULL) //原先就是空表
    {
        new_node->next = new_node;
        return new_node;
    }
    if(ptr == NULL) // 头插
    {
        new_node->next = head;
        previous = head;
        while(previous->next != NULL)
            previous = previous->next;
        previous->next = new_node;
        head = new_node;
    }
    else
    {
        new_node->next = ptr->next;
        ptr->next = new_node;
    }
    return head;
}

clink delete_node(clink head, clink ptr)
{
    clink previous;
    if(head == NULL) //空表
        return NULL;
    previous = head;
    if(head != head->next) //不止一个节点
        while(previous->next != ptr)
            previous = previous->next;

    if(ptr == head) //头插
    {
        head = head->next;
        previous->next = ptr->next;
    }
    else
    {
        previous->next = ptr->next;
    }
    free(ptr);
    return head;
}

int main()
{
    
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef struct dlist
{
    int data;
    struct dlist *front; //后继
    struct dlist *back; //前驱
}dnode;
typedef dnode *dlink;

dlink create_dlist(int *arr, int len)
{
    dlink head, before, new_node;
    int i;
    head = (dlink)malloc(sizeof(dnode));
    if(!head)
    {
        cout << "内存分配失败" << endl;
        return NULL;
    }
    head->data = arr[0];
    head->back = NULL;
    head->front = NULL;
    before = head;
    for(i = 1; i < len; ++i)
    {
        new_node = (dlink)malloc(sizeof(dnode));
        new_node->data = arr[i];
        new_node->front = NULL;
        new_node->back = before;
        before = new_node;
    }
    return head;
}

dlink insert_node(dlink head, dlink ptr, int value)
{
    dlink new_node = (dlink)malloc(sizeof(dnode));
    if(!new_node)
    {
        cout << "内存分配失败" << endl;
        return NULL;
    }
    new_node->back = NULL;
    new_node->front = NULL;
    new_node->data = value;
    if(head == NULL) //空表
        return new_node;
    if(ptr == NULL) //头插
    {
        new_node->front = head;
        head->back = new_node;
        head = new_node;
    }
    else
    {
        if(ptr->front == NULL) //尾插
        {
            ptr->front = new_node;
            new_node->back = ptr;
        }
        else
        {
            ptr->front->back = new_node;
            new_node->front = ptr->front;
            new_node->back = ptr;
            ptr->front = new_node;
        }
        
    }
    return head;  
}

dlink delete_node(dlink head, dlink ptr)
{
    if(ptr->back == NULL) //删头
    {
        head = head->front;
        head->back = NULL;
    }
    else
    {
        if(ptr->front == NULL) //删尾
        {
            ptr->back->front == NULL;
        }
        else
        {
            ptr->back->front = ptr->front;
            ptr->front->back = ptr->back;
        }
        
    }
    free(ptr);
    return head;
}

int main()
{

    return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef struct dlist
{
    int data;
    struct dlist *front; //后继
    struct dlist *back; //前驱
}cdnode;
typedef cdnode *cdlink;

cdlink create_dlist(int *arr, int len)
{
    cdlink head, before, new_node;
    int i;
    head = (cdlink)malloc(sizeof(cdnode));
    if(!head)
    {
        cout << "内存分配失败" << endl;
        return NULL;
    }
    head->data = arr[0];
    head->back = NULL;
    head->front = NULL;
    before = head;
    for(i = 1; i < len; ++i)
    {
        new_node = (cdlink)malloc(sizeof(cdnode));
        new_node->data = arr[i];
        new_node->front = NULL;
        new_node->back = before;
        before = new_node;
    }
    head->back = new_node;
    new_node->front = head;
    //head->back = NULL;
    //new_node->front = NULL;
    return head;
}

cdlink delete_node(cdlink head, cdlink ptr)
{
    if(head == NULL)
        return NULL;
    if(ptr == head) head = head->front; //头
    ptr->back->front = ptr->front;
    ptr->front->back = ptr->back;
    free(ptr);
    return head;
}

cdlink insert_node(cdlink head, cdlink ptr, int value)
{
    cdlink new_node = (cdlink)malloc(sizeof(cdnode));
    if(!new_node)
    {
        cout << "内存分配失败" << endl;
        return NULL;
    }
    new_node->data = value;
    if(head == NULL) //空表
    {
        new_node->back = new_node;
        new_node->front = new_node;
        return new_node;
    }
    if(ptr == NULL) //头插
    {
        head->back->front = new_node;
        new_node->front = head;
        new_node->back = head->back;
        head->back = new_node;
        head = new_node;
    }
    else
    {
        ptr->front->back = new_node;
        new_node->front = ptr->front;
        new_node->back = ptr;
        ptr->front = new_node;
    }
    return head;
}

int main()
{

    return 0;
}
xiguanlant
关注
专栏目录
C/C++ 单链表的创建、插入、删除、查找实现（简单 - 完整代码）
SanpTap的博客
06-15 3万+
单链表的增删改查实现 温馨提示：阅读本文需要15-25分钟 单链表的创建第一步也是最重要的一步就是要创建结构体，怎样创建结构体好理解呢？以下的定义结构体的方式是我看过那么多别人的代码以来让我感觉最容易看懂的，对新手也是很友好的，反正我创建新结点或者是传参只需要写一种形式struct List* ptr = ...; 就可以了。 struct List { int val;...
常用数据结构--线性结构
qzp1991的专栏
03-23 1729
常用数据结构--线性结构
链表的基本操作
m0_55205575的博客
10-19 303
链表的常规操作1.创建链表二级目录三级目录 1.创建链表 #include <iostream> #include <stdlib.h>//用于malloc, free 内存申请及释放 using namespace std; struct List { int data;// 数据 struct List* next;//存入下一个结点的地址 }; /*链表的创建*/ void chreat(struct List *L) { int m; cin>>
链表基本操作详解
qq_39720552的博客
10-24 674
链表通过结构体将数据以一个一个节点的方式存储，然后通过指针将各个节点的地址串联起来。这里可以改进：通过将尾节点的位置存储起来，避免每次插入时循环找尾节点；同时：可以加入新参数（上一节点地址）实现各种位置的插入；
数据结构与算法篇-单链表
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
06-20 207
????????关注后回复“进群”，拉你进程序员交流群????????作者丨写代码的牛顿来源丨编程学习总站01—单链表结点定义以及操作函数声明我们知道在C语言里数组可以存储大量相同数据...
c语言怎么实现list结构体,C语言实现的list -- 源码摘自wine
weixin_39845206的博客
05-21 497
#ifndef __WINE_SERVER_LIST_H#define __WINE_SERVER_LIST_H#include struct list{struct list *next;struct list *prev;};/* add an element after the specified one */static inline void list_add_after( struct...
地铁订票系统（数据结构课设）
jggcicky的博客
12-08 4802
参考图中郑州地铁一号线部分线路图设计一个地铁订票系统图一订票管理系统应实现地铁站的插入、删除、修改、查询、排序以及票价查询等工作，请设计一个计算 机系统，实现上述功能。（1）使用合适的数据结构存储地铁站数据并将示意图中的数据存入你选择的数据结构中。（2）由于地铁还在不断扩建，请实现地铁站的更新、删除与插入功能。（3）用户购票时只需输入上车站与下车站，由系统自动计算出票价（两站之内 2 元，三到四站 3 元，以此类推）。（4）输出用户票价的同时输出用户经过的地铁站。
c语言链表中何时用点何时用箭头,链表基本操作及其过程详细叙述
weixin_36354355的博客
05-21 2795
链表概述：链表是一种常见的数据结构。数组可以存放数据，但是使用数组时要先指定数组中包含元素的个数，即数组长度。但是如果向这个数组中加入的元素个数超过了数组的大小时，便不能将内容完全保存。例如在定义一个班级的人数时，如果小班是30人，普通班是50人，且定义班级人数时使用数组，那么要定义数组的个数为最大，也就是最少为50个元素，否则不满足最大时的情况。这种方式非常浪费空间。而链表，其存储元素的个数不受...
常用数据结构：线性结构
编程领域的博客
11-30 3320
目录 2022最新为初学者而著！ 顺序表 链表 单链表： 结点的删除： 结点的插入： 循环链表 双链表 结点的删除： 结点的插入： 栈 队列 2022最新为初学者而著！ Java基础是初学者的起点，是帮助你从小白入门到精通必学基础课程！ B站最新录制Java300集>>> 适合准备入行开发的零基础员学习Java，基于最新JDK13、IDEA平台讲解的，视频中穿插多个实战项目。每一个知识点都讲解的通俗易懂，由浅入深。不仅适用于零基础的初学者，有经验的..
大数据技术之_16_Scala学习_07_数据结构(上)-集合
黑泽君
03-31 284
大数据技术之_16_Scala学习_07第十章 数据结构(上)-集合
单向链表
qq_47218406的博客
09-22 543
《数据结构严蔚敏第二版》2.52，单向链表的链式表示与实现 （来了来了兄弟们，小手点一下右上角，来一波博主养成关注） 接第一篇博客，线性表包括顺序实现和链式实现，两者的底层存储区别体现在顺序表是开辟连续地址空间存储，而链表则不用连续地址空间存储，哪儿有空位往哪儿插入数据，对存储空间要求不高。 ----这是我的大白话（以下是书上正儿八经的解释） 链表和顺序表空间性能的比较： 存储空间： 由于顺序表的存储空间必须预先分配，容易造成存储空间浪费或者空间溢出（简单来说
C语言—通用链表
别呀的博客
03-28 1787
思考：当一个项目里要使用多种结构体类型的链表，例如点菜系统里有人员、菜谱两种结构体，若要对这两种链表操作，就需要编写2套链表操作代码，对链表的操作有链表创建、添加节点、删除节点、获取链表节点个数、获取链表结点数据、释放链表等，这就会花费我们大量的时间。对于这2种业务，对链表的操作是相同的，那能不能编写一套通用的链表操作函数，这2种应用只要调用相应的操作函数即可？面临这样的问题，所以有了通用链表。 这里写目录标题通用链表设计通用链表基本操作通用链表示例 通用链表设计 通用链表结构体： struct lis.
linux内核部件分析（一）——连通世界的list
qb_2008的专栏
10-01 6349
在linux内核中，有一种通用的双向循环链表，构成了各种队列的基础。链表的结构定义和相关函数均在include/linux/list.h中，下面就来全面的介绍这一链表的各种API。 struct list_head { struct list_head *next, *pr
linux内核链表操作
z1179675084的专栏
03-30 612
与linux链表有关的操作定义在linux/list.h链表头：struct list_head { struct list_head *next, *prev; };该结构体为链接结构中的成员，这样将链表的指针域与链表的数据域分开 链表头的初始化 1.#define LIST_HEAD_INIT(name) { &(name), &(name) } #define LIST_HE
双向链表 struct list_head 个人认识
ayuchou的专栏
04-17 1879
强大的原理小弟不才，未能见识，只是因为在驱动代码中
list图解
qinrenzhi的博客
07-14 967
struct list { struct list *next, *prev; }; static inline void list_init(struct list *list) { list->next = list; list->prev = list; } static inline int list_empt
1、链表操作(加新的结点,排列),结构体的定义及相关操作
hopegrace的博客
03-09 460
1、实现链表中添加新的结点，并按序排列 #include"stdio.h" #include"stdlib.h" #defineN8 typedefstructlist { intdata; structlist*next; }SLIST; voidfun(SLIST*h,intx)//生成链表，实现插入 { SLIST*...
Linux中通用链表(list)的解析
liumingkong的专栏
11-30 854
在Linux中的list是系统通用链表，它广泛应用在系统各个地方，如系统消息队列、进程列表等地。可以说，只要有表的地方，就会用到这个list。 今天我们先解析一下跟初始化有关的代码： 1. 表头结点结构 struct list_head {          struct list_head *next, *prev; }; 这和我们通常写链表一样，定义一个表头结点。 从next,
数据结构----单向链表
最新发布
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值