list

最新推荐文章于 2024-07-03 08:00:00 发布
最新推荐文章于 2024-07-03 08:00:00 发布
阅读量166 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ddddfang/article/details/88895898
版权

list.h

这个list.h其实是linux内核中链表实现的精简版(只需要一个头文件)，linux提供的这套接口更像是构造list的零部件。用户可以选择直接用它定制化自己的 list型数据结构，甚至可以实现一个更为 高层次的、通用的 list接口（如下面的clist）

#ifndef _LIST_H_
#define _LIST_H_
#ifdef __cplusplus
extern "C"
{
#endif

struct list_node
{
    struct list_node *next;
    struct list_node *prev;
};

/**
* ListNodeToItem - get the struct for this entry
* @node:    the &struct list_node pointer.
* @container:    the type of the struct this is embedded in.
* @member:    the name of the list_struct within the struct.
*/
#define ListNodeToItem(node, container, member) \
    (container *) (((char*) (node)) - ((unsigned long) &((container *)0)->member))

#define ListDeclare(name) \
    struct list_node name = { \
        .next = &name, \
        .prev = &name, \
    }

/**
* ListForEach    -    iterate over a list
* @node:    the &struct list_node to use as a loop cursor.
* @list:    the head for your list.
*/
#define ListForEach(node, list) \
    for (node = (list)->next; node != (list); node = node->next)

/**
* ListForEachReverse    -    iterate over a list backwards
* @node:    the &struct list_node to use as a loop cursor.
* @list:    the head for your list.
*/
#define ListForEachReverse(node, list) \
    for (node = (list)->prev; node != (list); node = node->prev)

/**
* ListForEachSafe - iterate over a list safe against removal of list entry
* @node:    the &struct list_node to use as a loop cursor.
* @n:        another &struct list_node to use as temporary storage
* @list:    the head for your list.
*/
#define ListForEachSafe(node, n, list) \
    for (node = (list)->next, n = node->next; \
         node != (list); \
         node = n, n = node->next)

static inline void ListInit(struct list_node *node)
{
    node->next = node;
    node->prev = node;
}

/**
* ListAddTail - add a new entry
* @head: list head to add it before
* @item: new entry to be added
*
* Insert a new entry before the specified head.
* This is useful for implementing queues.
*/
static inline void ListAddTail(struct list_node *head, struct list_node *item)
{
    item->next = head;
    item->prev = head->prev;
    head->prev->next = item;
    head->prev = item;
}

/**
* ListAddHead - add a new entry
* @head: list head to add it after
* @item: new entry to be added
*
* Insert a new entry after the specified head.
* This is good for implementing stacks.
*/
static inline void ListAddHead(struct list_node *head, struct list_node *item)
{
    item->next = head->next;
    item->prev = head;
    head->next->prev = item;
    head->next = item;
}

/**
* ListAppend - let list2(head2) append to the tail of list1(head1)
*/
static inline void ListAppend(struct list_node *head1, struct list_node *head2)
{
    head2->prev->next = head1;
    head2->next->prev = head1->prev;
    head1->prev->next = head2->next;
    head1->prev = head2->prev;

    head2->prev = head2;
    head2->next = head2;
}

static inline void ListReverse(struct list_node *head)
{
    struct list_node *pNode = head;
    struct list_node *pTmp = NULL;
    while(pNode->next != head)
    {
        //store the next node
        pTmp = pNode->next;
        //swap
        //pTmp = pNode->next;
        pNode->next = pNode->prev;
        pNode->prev = pTmp;

        pNode = pTmp;
    }
    //last swap
    pTmp = pNode->next;
    pNode->next = pNode->prev;
    pNode->prev = pTmp;
}

/*
* ZX_ListRemove - delete a list entry
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void ListRemove(struct list_node *item)
{
    item->next->prev = item->prev;
    item->prev->next = item->next;
}

#define ListIsEmpty(list) ((list) == (list)->next)
#define ListHead(list) ((list)->next)
#define ListTail(list) ((list)->prev)

#ifdef __cplusplus
}
#endif
#endif //LIST_H_

直接使用 list.h

在头文件中,定义一个node,一个manager

//自己实现的一个stack(queue也是可以实现的)
typedef struct {
    pthread_mutex_t lock;           //这里应该有一个mutex lock的,但是写的时候忘记加了
    unsigned int u32StackSize;
    struct zxlist_node listNode;
}FRAME_UI_STACK_MGR;                 //stack manager结构体

typedef struct {
    UI_FRAME_S *pUIFrame;
    struct zxlist_node listNode;
}FRAME_UI_STACK_NODE;

在.c文件中,

static FRAME_UI_STACK_MGR gstFrameUIStack = {
    .lock = PTHREAD_MUTEX_INITIALIZER,
};

static int frameUIStackInit() {
    gstFrameUIStack.u32StackSize = 0;
    ZX_ListInit(&gstFrameUIStack.listNode);
    return 0;
}

static int frameUIStackDeinit() {//descroy the stack
    zxlist_node *pListNode = NULL;
    FRAME_UI_STACK_NODE *pStackNode = NULL;
    while(!ZX_ListEmpty(&gstFrameUIStack.listNode)) {
        pListNode = ZX_ListTail(&gstFrameUIStack.listNode);
        pStackNode = ZX_ListNodeToItem(pListNode, FRAME_UI_STACK_NODE, listNode);
        ZX_ListRemove(pListNode);
        free(pStackNode);
    }
    gstFrameUIStack.u32StackSize = 0;
    return 0;
}

static int frameUIStackPush(UI_FRAME_S *pUIFrame) {
    if(pUIFrame == NULL) {
        printf("frameUIStackPush error: invalid param\n");
        return -1;
    }
    FRAME_UI_STACK_NODE *pUINode = (FRAME_UI_STACK_NODE *)malloc(sizeof(FRAME_UI_STACK_NODE));
    if(pUINode == NULL) {
        printf("frameUIStackPush add node error: no more availiable mem\n");
        return -1;
    }
    pUINode->pUIFrame = pUIFrame;
    ZX_ListAddTail(&gstFrameUIStack.listNode,&(pUINode->listNode));    //add to tail
    gstFrameUIStack.u32StackSize++;
    return 0;
}

static int frameUIStackTop(UI_FRAME_S **ppUIFrame) {
    if(ppUIFrame == NULL) {
        printf("frameUIStackTop error: invalid param\n");
        return -1;
    }
    if(gstFrameUIStack.u32StackSize == 0) {
        if(ZX_ListEmpty(&gstFrameUIStack.listNode)) {//confirm
            printf("frameUIStackTop stack is empty!\n");
            *ppUIFrame = NULL;
            return 0;
        } else {
            printf("frameUIStackTop error!\n");
            *ppUIFrame = NULL;
            return -1;
        }
    }
    zxlist_node *pListNode = ZX_ListTail(&gstFrameUIStack.listNode);        //just get the tail
    FRAME_UI_STACK_NODE *pStackNode = ZX_ListNodeToItem(pListNode, FRAME_UI_STACK_NODE, listNode);
    *ppUIFrame = pStackNode->pUIFrame;
    return 0;
}

static int frameUIStackPop(UI_FRAME_S **ppUIFrame) {
    if(gstFrameUIStack.u32StackSize == 0) {
        if(ZX_ListEmpty(&gstFrameUIStack.listNode)){
            printf("frameUIStackPop stack is empty!\n");
            *ppUIFrame = NULL;
            return 0;
        } else {
            printf("frameUIStackPop error!\n");
            *ppUIFrame = NULL;
            return -1;
        }
    }
    zxlist_node *pListNode = ZX_ListTail(&gstFrameUIStack.listNode);    //get the tail
    FRAME_UI_STACK_NODE *pStackNode = ZX_ListNodeToItem(pListNode, FRAME_UI_STACK_NODE, listNode);
    if(ppUIFrame != NULL) {//if param is null, just discard top element
        *ppUIFrame = pStackNode->pUIFrame;
    }
    ZX_ListRemove(pListNode);                                                                       //remove the tail
    free(pStackNode);
    gstFrameUIStack.u32StackSize--;
    return 0;
}

数组实现的stack和queue比链表效率更高一点

  • 数组实现的stack应该很简单
  • 数组实现的queue分为两种：
    • 使用环形队列，效率高，但需要考虑wrap的情况 (RingBuf)
    • 不用环形队列，使用memmove，效率有折损但简单（bufQueue）
      list、stack、fifo(即queue)都属于线性结构，stack和fifo可以看作阉割版的list

cList.c，这是在学习了《c 接口与实现》第7章 后弄的一个类 lisp 链表 的实现

#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "cList.h"

//将一个数据push到list的head
clist List_push(clist list, void *x)
{
    unsigned int flag=0;
    clist listTmp = NULL;
    clistNode *pNodeTmp = NULL;
    if(!list)
    {    //new malloc a list manager node and init
        listTmp = (clist)malloc(sizeof(struct clistManager));
        if(!listTmp)
            goto FAIL_1;
        ListInit(&listTmp->listNode);
        listTmp->u32ListSize = 0;
        flag = 1;
    }
    else
        listTmp = list;

    //new list node and init
    pNodeTmp = (clistNode *)malloc(sizeof(clistNode));
    if(!pNodeTmp)
        goto FAIL_2;
    ListInit(&pNodeTmp->listNode);
    pNodeTmp->data = x;

    //add list node to clist manager(header)
    ListAddHead(&listTmp->listNode, &pNodeTmp->listNode);
    listTmp->u32ListSize++;
    return listTmp;

FAIL_2:
    if(flag)
        free(listTmp);
FAIL_1:
    return NULL;
}

//构造一个list,应该以NULL或者其他为false的值结尾
clist List_list(void *x, ...)
{
    va_list ap;
    va_start(ap, x);

    clist listTmp = NULL;
    clistNode *pNodeTmp = NULL;
    struct list_node *plistNode = NULL;

    //new malloc a list manager node and init
    listTmp = (clist)malloc(sizeof(struct clistManager));
    if(!listTmp)
        goto FAIL_1;
    ListInit(&listTmp->listNode);
    listTmp->u32ListSize = 0;

    for ( ; x; x = va_arg(ap, void *))
    {
        //new list node and init
        pNodeTmp = (clistNode *)malloc(sizeof(clistNode));
        if(!pNodeTmp)    // TODO: this may cause memleak
            goto FAIL_2;
        ListInit(&pNodeTmp->listNode);
        pNodeTmp->data = x;

        ListAddTail(&listTmp->listNode, &pNodeTmp->listNode);
        listTmp->u32ListSize++;
    }
    va_end(ap);
    return listTmp;

FAIL_2:
    List_free(&listTmp);
FAIL_1:
    return NULL;
}

clist List_append(clist list, clist tail)
{
    if(!list)
        return tail;

    if(tail)
    {
        ListAppend(&list->listNode, &tail->listNode);
        list->u32ListSize += tail->u32ListSize;
        tail->u32ListSize = 0;
    }
    return list;
}

clist List_copy(clist list)
{
    clist listTmp = NULL;
    clistNode *pNodeTmpSrc = NULL;
    clistNode *pNodeTmpDst = NULL;

    if(list)
    {
        //new malloc a list manager node and init
        listTmp = (clist)malloc(sizeof(struct clistManager));
        if(!listTmp)
            goto FAIL_1;
        ListInit(&listTmp->listNode);
        listTmp->u32ListSize = 0;

        struct list_node *plistNode = NULL;
        ListForEach(plistNode,&list->listNode)
        {
            pNodeTmpSrc = ListNodeToItem(plistNode, clistNode, listNode);
            //new list node and init
            pNodeTmpDst = (clistNode *)malloc(sizeof(clistNode));
            if(!pNodeTmpDst)
                goto FAIL_2;
            ListInit(&pNodeTmpDst->listNode);
            pNodeTmpDst->data = pNodeTmpSrc->data;
            //insert
            ListAddTail(&listTmp->listNode, &pNodeTmpDst->listNode);
            listTmp->u32ListSize++;
        }
    }
    return listTmp;

FAIL_2:
    List_free(&listTmp);
FAIL_1:
    return NULL;
}

clist List_pop(clist list, void **x)
{
    struct list_node *plistNode = NULL;
    clistNode *pNodeTmp = NULL;
    if (list && !ListIsEmpty(&list->listNode))
    {
        plistNode = ListHead(&list->listNode);
        pNodeTmp = ListNodeToItem(plistNode, clistNode, listNode);
        if (x)
            *x = pNodeTmp->data;
        ListRemove(plistNode);
        free(pNodeTmp);
        list->u32ListSize--;
    }
    return list;
}

//NOTE :param list and returned list both reversed!
clist List_reverse(clist list)
{
    if(list)
        ListReverse(&list->listNode);
    return list;
}

int List_length(clist list)
{
    int n=0;
    if(list)
        n = list->u32ListSize;
    return n;
}

void List_free(clist *plist)
{
    struct list_node *plistNode = NULL;
    clistNode *pNodeTmp = NULL;
    clist list = NULL;
    if (plist)
    {
        list = *plist;
        if(list)
        {
            while(!ListIsEmpty(&list->listNode))
            {
                plistNode = ListHead(&list->listNode);
                pNodeTmp = ListNodeToItem(plistNode, clistNode, listNode);
                ListRemove(plistNode);
                free(pNodeTmp);
                list->u32ListSize--;
            }
            free(list);
        }
        *plist = NULL;
    }
}

void List_map(clist list, void apply(void **x,int index, void *cl), void *cl)
{
    struct list_node *plistNode = NULL;
    clistNode *pNodeTmp = NULL;
    int i=0;
    if(apply && list)
    {
        ListForEach(plistNode,&list->listNode)
        {
            //apply 使用的是指向 first 的指针,因此可能改变 first 指针的指向
            pNodeTmp = ListNodeToItem(plistNode, clistNode, listNode);
            apply(&pNodeTmp->data,i++,cl);    //
        }
    }
}

void **List_toArray(clist list, void *end)
{
    int i=0, n;
    struct list_node *plistNode = NULL;
    clistNode *pNodeTmp = NULL;
    void **array = NULL;
    if(list)
    {
        n = list->u32ListSize;
        array = (void **)malloc((n + 1)*sizeof (void *));
        if(!array)
            return NULL;
        ListForEach(plistNode,&list->listNode)
        {
            pNodeTmp = ListNodeToItem(plistNode, clistNode, listNode);
            array[i++] = pNodeTmp->data;
        }
        array[i] = end;    
    }
    return array;
}
//cList.h
#ifndef _COMMON_LIST_H
#define _COMMON_LIST_H

#include "list.h"

typedef struct clistManager{
    struct list_node listNode;
    unsigned int u32ListSize;
} *clist;

typedef struct {
    struct list_node listNode;
    void *data;
} clistNode;

clist List_push(clist list, void *x);
clist List_list(void *x, ...);
clist List_append(clist list, clist tail);
clist List_copy(clist list);
clist List_pop(clist list, void **x);
clist List_reverse(clist list);
int List_length(clist list);
void List_free(clist *plist);
void List_map(clist list, void apply(void **x,int index, void *cl), void *cl);
void **List_toArray(clist list, void *end);


#endif

 

ddddfang
关注
专栏目录
list_add_tail()
kernel_details的专栏
01-12 3万+
将new所代表的list_head插入head所索引的队列的尾部static inline void list_add_tail(struct list_head *new, struct list_head *head)...{    __list_add(new, head->prev, head);}将new所代表的list_head插入到next索引的双链表(next索引双
m_strokeList.AddTail(pStrokeItem);会报错？
longlongqin的博客
08-18 197
发现问题出现在【m_strokeList】，只需将其定义： CTypedPtrList<CObList, CObList*> m_strokeList; //模板的实例 改为：_CTypedPtrList<CObList, CObList*> m_strokeList;
基于双向循环链表构建的hash表
dp__mcu的专栏
12-09 154
/* * vim: ai ts=4 sts=4 sw=4 cinoptions=>4 expandtab */ #define _GNU_SOURCE #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <errno.h> #include <sys/mman.h> #include <sys/types.h> #include <sy..
在Linux下链表使用介绍二：list_add/list_add_tail、list_for_each/list_for_each_safe等
咸鱼弟的博客
07-01 2万+
在上一篇我们介绍了list_head；并定义了结构体节点，如何把该类型的结构体节点串成一个链表呢？1、必须专门定义一个链表头，并初始化：struct list_head ListHead; INIT_LIST_HEAD(&amp;ListHead);其中INIT_LIST_HEAD的定义为#define INIT_LIST_HEAD(ptr) do { \ (ptr)-&g...
stack的常见用法详解
09-04 4万+
stack翻译为栈，是STL中实现的一个后进先出的容器。要使用 stack，应先添加头文件include<stack>，并在头文件下面加上“ using namespacestd;" 1. stack的定义 其定义的写法和其他STL容器相同, typename可以任意基本数据类型或容器： stack<typename> name; 2. stack容器内元素的访问...
解决SQL中的“Expression #1 of SELECT list is not in GROUP BY clause“错误
最新发布
沉淀、分享、成长，让自己和他人都能有所收获！
07-03 4万+
在日常开发中，我们经常会遇到SQL查询中的一些错误，尤其是在处理复杂的查询时。今天，默语将带大家一起深入探讨并解决一个常见的SQL错误：“Expression #1 of SELECT list is not in GROUP BY clause and contains nonaggregated column”。通过这篇文章，您将了解该错误的原因及其解决方案，提升您的SQL技能。在SQL查询中，GROUP BY子句用于将结果集按一个或多个列进行分组。
Alist一键安装
routeros专栏
10-08 1万+
alist-install.sh #!/bin/bash clear echo NOTE='\033[36m ========================================================================== \r\n Alist 一键部署脚本\r\n Alist是一款阿里云盘的目录文件列表程序，后端基于golang最好的http框架gin\r 前端使用vue和ant design\r 项目地址：htt...
【C++入门到精通】C++入门 —— list (STL)
Yawesh的博客
08-14 2600
本文首先介绍了list的概念和特点。list是C++中的容器之一，采用双向链表存储元素，可以在O(1)时间内插入和删除操作，但访问效率较低。接下来，文章详细探讨了list的使用方式。包括如何构造list对象，并介绍了常见的操作方法，如增加、删除、查找和修改list中的元素。最后，文章进行了list与vector的对比。分析了它们在数据存储方式、动态性、访问效率、插入和删除操作以及内存使用等方面的差异。这有助于读者根据实际需求选择合适的容器。通过本文，读者可以深入了解list的特性和用法，以及与其
List转Map的三种方法
zhangruibo_code的博客
06-30 9万+
for循环 、使用guava、Java8新特性Stream的Collectors类
C++ STL list的初始化、添加、遍历、插入、删除、查找、排序、释放
热门推荐
烟花易冷
08-20 16万+
list是C++标准模版库(STL,Standard Template Library)中的部分内容。实际上,list容器就是一个双向链表,可以高效地进行插入删除元素。 使用list容器之前必须加上STL的list容器的头文件：#include; list属于std命名域的内容，因此需要通过命名限定：using std::list;也可以直接使用全局的命名空间方式：using nam
两个list如何根据一个list中的属性去过滤掉另一个list中不包含这部分的属性，用流实现
舒一笑的博客
08-16 1万+
你可以使用Java 8的流来实现这个功能。假设你有两个包含对象的List，每个对象有一个属性，你想根据一个List中的属性值来过滤掉另一个List中不包含这个属性值的对象。下面是一种使用流的方式来实现这个功能在上面的例子中，我们有两个List：list1包含了MyClass对象，每个对象有一个属性property；list2包含了一些属性值。我们使用流来筛选list1中的对象，只保留那些property值在list2中存在的对象，最后将筛选后的结果收集到filteredList中。AB。
AttributeError: ‘list‘ object has no attribute ‘size‘解决方案
weixin_43178406的博客
11-28 4万+
本文主要介绍了AttributeError: ‘list’ object has no attribute 'size’解决方案，希望能对使用transformers的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
Java List集合
m0_62143653的博客
02-12 5523
Java List集合
网络设备-思科-交换机（例3750）stack-wise堆叠终结配置篇
weixin_34302561的博客
06-11 2527
各位，我又回来了，上次俩篇介绍了华为stack、华三的firewall的irf。这次就来介绍下思科的堆叠（stack），虽然实现思路都一致，但配置也有需要注意的地方，尤其是现在做二级运营商的网工们，所有产商全得会，压力确实大。PS：过了一阵重新回来看这篇文章发现有几个错误特意进行了修正和一些细节上的补充，温故而知新啊！！先说下拓扑环境：此项目为某全国物流公司网络中标方案某部分...
list_add_tail 添加双向链表结点讲解
sunweizhong1024的专栏
05-21 9546
我是在看linux 的input subsystem 的时候，用到的这个函数，当时我对链表还不怎么清楚 struct list_head {     struct list_head *next, *prev; };  list_add_tail(&dev->node, &input_dev_list); /**  * list_add_tail - add a new
大顶堆
ddddfang的专栏
03-29 5742
1. 概述: 最大堆(大顶堆) 一句话 heap：一种数据结构，完全二叉树（若二叉树高 h，则除过最底层 h 层，其他 1~h-1 层都是满的；并且最底层从左到右不能有空隙）。有最大堆和最小堆两种，最大堆即根节点的键值比其他所有节点键值都大；最小堆即根节点的键值比其他所有节点键值都小。在实现上，它没有选择一般的二叉树数据结构（即一个节点包含指向两个孩子的指针），使用的是数组；heap 最为常用的...
Freemarker遍历与排序List详解
"Freemarker中遍历list集合实例" 在Freemarker，一个基于模板语言的动态网页生成工具，遍历List集合是常见的操作。开发者经常需要从List中提取数据，对其进行处理，然后以适当的形式展示给用户。下面我们将深入探讨...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值