链表

最新推荐文章于 2022-07-26 21:57:51 发布
最新推荐文章于 2022-07-26 21:57:51 发布
阅读量128 收藏
点赞数
分类专栏： UBOOT

转自     http://blog.csdn.net/feixiaoxing/article/details/6846664

一步一步写算法（之线性结构的处理）

 

我们知道，在内存中的空间都是连续的。也就是说，0x00000001下面的地址必然是0x00000002。所以，空间上是不会出现地址的突变的。那什么数据结构类型是连续内部空间呢，其实就是数组，当然也可以是堆。数组有很多优势，它可以在一段连续空间内保存相同类型的数据，并且对这些数据进行管理。所以从这个意义上说，掌握了数组才能说明你数据结构入门了。

    那么，在实际开发中，我们对线性结构应该注意些什么呢？我个人的观点：

    （1）数组的资源是有限的，必须确定资源的范围

    （2）数组中资源的申请和释放必须一一对应，否则很容易造成资源泄漏的现象h 

    （3）数组中的注意事项同样应用于堆分配的连续内存资源空间中

    下面是自己设计的一个int分配的小程序，大家可以一起尝试一下：

    a）设计内存节点的数据形式

[cpp] view plain copy

  1. typedef struct _DATA_NODE  
  2. {  
  3.     int* pData;  
  4.     char* pFlag;  
  5.     int num;  
  6. }DATA_NODE;  
  7.   
  8. #define STATUS int  
  9. #define TRUE 1  
  10. #define FALSE 0  

    b）创建内存节点

[cpp] view plain copy

  1. DATA_NODE* malloc_node(int number)  
  2. {  
  3.     DATA_NODE* pDataNode = NULL;  
  4.     if(0 == number)  
  5.         return NULL;  
  6.   
  7.     pDataNode = (DATA_NODE*) malloc(sizeof(DATA_NODE));  
  8.     assert(NULL != pDataNode);  
  9.     memset(pDataNode, 0, sizeof(DATA_NODE));  
  10.   
  11.     pDataNode->pData = (int*)malloc(sizeof(int) * number);  
  12.     if(NULL == pDataNode->pData){  
  13.         free(pDataNode);  
  14.         return NULL;  
  15.     }  
  16.   
  17.     pDataNode->pFlag = (char*) malloc( (number + 7) >> 3);  
  18.     if(NULL == pDataNode->pFlag){  
  19.         free(pDataNode->pData);  
  20.         free(pDataNode);  
  21.         return NULL;  
  22.     }  
  23.   
  24.     memset(pDataNode->pData, 0, sizeof(int) * number);  
  25.     memset(pDataNode->pFlag, 0, (number + 7) >> 3);  
  26.     pDataNode->num = number;  
  27.     return pDataNode;  
  28. }  

    c） 删除内存节点

[cpp] view plain copy

  1. STATUS free_node(const DATA_NODE* pDataNode)  
  2. {  
  3.     if(NULL == pDataNode)  
  4.         return FALSE;  
  5.   
  6.     assert(NULL != pDataNode ->pData);  
  7.     assert(NULL != pDataNode-> pFlag);  
  8.     assert(0 != pDataNode);  
  9.   
  10.     free(pDataNode->pFlag);  
  11.     free(pDataNode->pData);  
  12.     free((void*)pDataNode);  
  13.     return TRUE;  
  14. }  

    d）判断当前是否还有内存可以分配

[cpp] view plain copy

  1. int check_if_data_exist(const DATA_NODE* pDataNode)  
  2. {  
  3.     int number = pDataNode->num;  
  4.     char* pFlag = pDataNode->pFlag;  
  5.     unsigned char flag = 0;  
  6.     int loop = 1;  
  7.   
  8.     while(loop <= number){  
  9.         flag = pFlag[(loop + 7) >> 3 - 1] & (0x1 << ((loop + 7) % 8));  
  10.         if(0 != flag){  
  11.             return loop;  
  12.         }  
  13.   
  14.         loop ++;  
  15.     }  
  16.   
  17.     return -1;  
  18. }  

    e） 分配内存空间

[cpp] view plain copy

  1. int* alloca_data(const DATA_NODE* pDataNode)  
  2. {  
  3.     int* pData = NULL;  
  4.     int pos;  
  5.     if(NULL == pDataNode)  
  6.         return NULL;  
  7.   
  8.     if(-1 == (pos = check_if_data_exist(pDataNode)))  
  9.         return NULL;  
  10.   
  11.   
  12.     pDataNode->pFlag[(pos + 7) >> 3 - 1] |= 0x1 << ((pos + 7)% 8);  
  13.     return pDataNode->pData + (pos - 1);  
  14. }  

    f）回收内存空间

[cpp] view plain copy

  1. STATUS free_data(const DATA_NODE* pDataNode, const int* pData)  
  2. {  
  3.     int pos = 0;  
  4.     if(NULL == pDataNode || NULL == pData)  
  5.         return FALSE;  
  6.   
  7.     if(pData < pDataNode->pData || pData > (pDataNode->pData + pDataNode->num))  
  8.         return FALSE;  
  9.   
  10.     pos = (pData - pDataNode->pData) >> 3;  
  11.     pDataNode->pFlag[(pos + 7) -1]  &= ~(0x1 << ((pos + 7) % 8));  
  12.     return TRUE;  
  13. }  

    g）统计当前已经分配了多少DWORD空间

[cpp] view plain copy

  1. int count_free_space(const DATA_NODE* pDataNode)  
  2. {  
  3.     int count = 0;  
  4.     int loop = 1;  
  5.     char flag = 0;  
  6.     if(NULL == pDataNode)  
  7.         return 0;  
  8.   
  9.     for(; loop <= pDataNode->num; loop++)  
  10.     {  
  11.         flag = pDataNode->pFlag[(loop + 7) >> 3 - 1] & (0x1 << ((loop + 7) % 8));  
  12.         if(0 == flag){  
  13.             count ++;  
  14.         }  
  15.     }  
  16.       
  17.     return count;  
  18. }  


 

   上面的代码只是一个示范，大家可以在这个基础之上加以改进，比如说：

    （1）修改成可以自由分配很多内存，注意需要同时修改flag的结构类型

    （2）修改成先到先得的内存分配类型

    （3）修改成最合适空间的内存分配类型

    （4）修改成debug类型的内存分配形式，每次分配和释放的时候都检查内存是否越界、是否没有成对运行，注意需要添加对应的判断函数

 

 

一步一步写算法（之线性队列）

这里的线性结构实际上指的就是连续内存的意思，只不过使用“线性”这个词显得比较专业而已。前面一篇博客介绍了现象结构的处理方法，那么在这个基础之上我们是不是添加一些属性形成一种新的数据结构类型呢？答案是肯定的，队列便是其中的一种。

    队列的性质很简单：

    （1）队列有头部和尾部

    （2）队列从尾部压入数据

    （3）队列从头部弹出数据

    那么连续内存下的队列是怎么实现的呢？

    a）设计队列数据结构

[cpp] view plain copy

  1. typedef struct _QUEUE_NODE  
  2. {  
  3.     int* pData;  
  4.     int length;  
  5.     int head ;  
  6.     int tail;  
  7.     int count;  
  8. }QUEUE_NODE;  

    b）申请队列内存

[cpp] view plain copy

  1. QUEUE_NODE* alloca_queue(int number)  
  2. {  
  3.     QUEUE_NODE* pQueueNode;  
  4.     if( 0 == number)  
  5.         return NULL;  
  6.   
  7.     pQueueNode = (QUEUE_NODE*)malloc(sizeof(QUEUE_NODE));  
  8.     assert(NULL != pQueueNode);  
  9.     memset(pQueueNode, 0, sizeof(QUEUE_NODE));  
  10.   
  11.     pQueueNode->pData = (int*)malloc(sizeof(int) * number);  
  12.     if(NULL == pQueueNode->pData){  
  13.         free(pQueueNode);  
  14.         return NULL;  
  15.     }  
  16.   
  17.     pQueueNode->length = number;  
  18.     return pQueueNode;  
  19. }  

    c）释放队列内存

[cpp] view plain copy

  1. STATUS delete_queue(const QUEUE_NODE* pQueueNode)  
  2. {  
  3.     if(NULL == pQueueNode)   
  4.         return FALSE;  
  5.       
  6.     assert(NULL != pQueueNode->pData);  
  7.       
  8.     free(pQueueNode->pData);  
  9.     free((void*)pQueueNode);  
  10.     return TRUE;  
  11. }  

    d）把数据压入队列

[cpp] view plain copy

  1. STATUS insert_queue(QUEUE_NODE* pQueueNode, int value)  
  2. {  
  3.     if(NULL == pQueueNode)  
  4.         return FALSE;  
  5.   
  6.     if(pQueueNode->length == pQueueNode->count)  
  7.         return FALSE;  
  8.   
  9.     pQueueNode->pData[pQueueNode->tail] = value;  
  10.     pQueueNode->tail = (pQueueNode->tail + 1) % pQueueNode->length;    
  11.     pQueueNode->count ++;  
  12.     return TRUE;  
  13. }  

    e）把数据弹出队列

[cpp] view plain copy

  1. STATUS get_queue_data(QUEUE_NODE* pQueueNode, int* value)  
  2. {  
  3.     if(NULL == pQueueNode || NULL == value)  
  4.         return FALSE;  
  5.   
  6.     if(0 == pQueueNode->count)  
  7.         return FALSE;  
  8.   
  9.     *value = pQueueNode->pData[pQueueNode->head];  
  10.     pQueueNode-> pData[pQueueNode->head] = 0;   
  11.     pQueueNode-> count --;  
  12.     pQueueNode->head = (pQueueNode->head + 1) % pQueueNode->length;  
  13.     return TRUE;  
  14. }  

    f）统计当前队列中有多少数据

[cpp] view plain copy

  1. int  get_total_number(const QUEUE_NODE* pQueueNode)  
  2. {  
  3.     if(NULL == pQueueNode)  
  4.         return 0;  
  5.   
  6.     return pQueueNode->count;  
  7. }  

    g）查看队列中初始化的时候总长度是多少

[cpp] view plain copy

  1. int  get_total_number(const QUEUE_NODE* pQueueNode)  
  2. {  
  3.     if(NULL == pQueueNode)  
  4.         return 0;  
  5.   
  6.     return pQueueNode->length;  
  7. }  

 

 

一步一步写算法（之线性堆栈）

  前面我们讲到了队列，今天我们接着讨论另外一种数据结构：堆栈。堆栈几乎是程序设计的命脉，没有堆栈就没有函数调用，当然也就没有软件设计。那么堆栈有什么特殊的属性呢？其实，堆栈的属性主要表现在下面两个方面：

    （1）堆栈的数据是先入后出

    （2）堆栈的长度取决于栈顶的高度

    那么，作为连续内存类型的堆栈应该怎么设计呢？大家可以自己先试一下：

    （1）设计堆栈节点

[cpp] view plain copy

  1. typedef struct _STACK_NODE  
  2. {  
  3.     int* pData;  
  4.     int length;  
  5.     int top;  
  6. }STACK_NODE;  

    （2）创建堆栈

[cpp] view plain copy

  1. STACK_NODE* alloca_stack(int number)  
  2. {  
  3.     STACK_NODE* pStackNode = NULL;  
  4.     if(0 == number)  
  5.         return NULL;  
  6.       
  7.     pStackNode = (STACK_NODE*)malloc(sizeof(STACK_NODE));  
  8.     assert(NULL != pStackNode);  
  9.     memset(pStackNode, 0, sizeof(STACK_NODE));  
  10.       
  11.     pStackNode->pData = (int*)malloc(sizeof(int) * number);  
  12.     if(NULL == pStackNode->pData){  
  13.         free(pStackNode);  
  14.         return NULL;  
  15.     }  
  16.       
  17.     memset(pStackNode->pData, 0, sizeof(int) * number);  
  18.     pStackNode-> length = number;  
  19.     pStackNode-> top= 0;  
  20.     return pStackNode;  
  21. }  

    （3）释放堆栈

[cpp] view plain copy

  1. STATUS free_stack(const STACK_NODE* pStackNode)  
  2. {  
  3.     if(NULL == pStackNode)  
  4.         return FALSE;  
  5.       
  6.     assert(NULL != pStackNode->pData);     
  7.           
  8.     free(pStackNode->pData);  
  9.     free((void*)pStackNode);  
  10.     return TRUE;  
  11. }  

    （4）堆栈压入数据

[cpp] view plain copy

  1. STATUS stack_push(STACK_NODE* pStackNode, int value)  
  2. {  
  3.     if(NULL == pStackNode)  
  4.         return FALSE;  
  5.           
  6.     if(pStackNode->length == pStackNode->top)  
  7.         return FALSE;  
  8.           
  9.     pStackNode->pData[pStackNode->top ++] = value;  
  10.     return TRUE;  
  11. }  

    （5）堆栈弹出数据

[cpp] view plain copy

  1. STATUS stack_pop(STACK_NODE* pStackNode, int* value)  
  2. {  
  3.     if(NULL == pStackNode || NULL == value)  
  4.         return FALSE;  
  5.           
  6.     if(0 == pStackNode->top)  
  7.         return FALSE;  
  8.           
  9.     *value = pStackNode->pData[-- pStackNode->top];  
  10.     return TRUE;  
  11. }  

    （6）统计当前堆栈中包含多少数据

[cpp] view plain copy

  1. int count_stack_number(const STACK_NODE* pStackNode)  
  2. {  
  3.     return pStackNode->top;  
  4. }  


    建议： 堆栈是函数调用的基础，是递归调用的基础，是很多问题的根源，建议朋友们平时有时间好好练习一下

一步一步写算法（之单向链表）

 

 有的时候，处于内存中的数据并不是连续的。那么这时候，我们就需要在数据结构中添加一个属性，这个属性会记录下面一个数据的地址。有了这个地址之后，所有的数据就像一条链子一样串起来了，那么这个地址属性就起到了穿线连结的作用。

    相比较普通的线性结构，链表结构的优势是什么呢？我们可以总结一下：

    （1）单个节点创建非常方便，普通的线性内存通常在创建的时候就需要设定数据的大小

    （2）节点的删除非常方便，不需要像线性结构那样移动剩下的数据

    （3）节点的访问方便，可以通过循环或者递归的方法访问到任意数据，但是平均的访问效率低于线性表

    那么在实际应用中，链表是怎么设计的呢？我们可以以int数据类型作为基础，设计一个简单的int链表：

    （1）设计链表的数据结构

[cpp] view plain copy

  1. typedef struct _LINK_NODE  
  2. {  
  3.     int data;  
  4.     struct _LINK_NODE* next;  
  5. }LINK_NODE;  


    （2）创建链表

[cpp] view plain copy

  1. LINK_NODE* alloca_node(int value)  
  2. {  
  3.     LINK_NODE* pLinkNode = NULL;  
  4.     pLinkNode = (LINK_NODE*)malloc(sizeof(LINK_NODE));  
  5.       
  6.     pLinkNode->data = value;  
  7.     pLinkNode->next = NULL;  
  8.     return pLinkNode;  
  9. }  

    （3）删除链表

[cpp] view plain copy

  1. void delete_node(LINK_NODE** pNode)  
  2. {  
  3.     LINK_NODE** pNext;  
  4.     if(NULL == pNode || NULL == *pNode)  
  5.         return ;  
  6.           
  7.     pNext = &(*pNode)->next;  
  8.     free(*pNode);  
  9.     delete_node(pNext);   
  10. }  

    （4）链表插入数据

[cpp] view plain copy

  1. STATUS _add_data(LINK_NODE** pNode, LINK_NODE* pDataNode)  
  2. {  
  3.     if(NULL == *pNode){  
  4.         *pNode = pDataNode;  
  5.         return TRUE;  
  6.     }  
  7.       
  8.     return _add_data(&(*pNode)->next, pDataNode);  
  9. }  
  10.   
  11. STATUS add_data(const LINK_NODE** pNode, int value)  
  12. {  
  13.     LINK_NODE* pDataNode;  
  14.     if(NULL == *pNode)  
  15.         return FALSE;  
  16.           
  17.     pDataNode = alloca_node(value);  
  18.     assert(NULL != pDataNode);  
  19.     return _add_data((LINK_NODE**)pNode, pDataNode);  
  20. }  

    （5）删除数据

[cpp] view plain copy

  1. STATUS _delete_data(LINK_NODE** pNode, int value)  
  2. {  
  3.     LINK_NODE* pLinkNode;  
  4.     if(NULL == (*pNode)->next)  
  5.         return FALSE;  
  6.       
  7.     pLinkNode = (*pNode)->next;  
  8.     if(value == pLinkNode->data){  
  9.         (*pNode)->next = pLinkNode->next;  
  10.         free(pLinkNode);  
  11.         return TRUE;  
  12.     }else{  
  13.         return _delete_data(&(*pNode)->next, value);  
  14.     }  
  15. }  
  16.   
  17. STATUS delete_data(LINK_NODE** pNode, int value)  
  18. {  
  19.     LINK_NODE* pLinkNode;  
  20.     if(NULL == pNode || NULL == *pNode)  
  21.         return FALSE;  
  22.   
  23.     if(value == (*pNode)->data){  
  24.         pLinkNode = *pNode;  
  25.         *pNode = pLinkNode->next;  
  26.         free(pLinkNode);  
  27.         return TRUE;  
  28.     }         
  29.       
  30.     return _delete_data(pNode, value);  
  31. }  

    （6）查找数据

[cpp] view plain copy

  1. LINK_NODE* find_data(const LINK_NODE* pLinkNode, int value)  
  2. {  
  3.     if(NULL == pLinkNode)  
  4.         return NULL;  
  5.       
  6.     if(value == pLinkNode->data)  
  7.         return (LINK_NODE*)pLinkNode;  
  8.       
  9.     return find_data(pLinkNode->next, value);  
  10. }  

    （7）打印数据

[cpp] view plain copy

  1. void print_node(const LINK_NODE* pLinkNode)  
  2. {  
  3.     if(pLinkNode){  
  4.         printf("%d\n", pLinkNode->data);  
  5.         print_node(pLinkNode->next);  
  6.     }  
  7. }  

    （8）统计数据

[cpp] view plain copy

  1. int count_node(const LINK_NODE* pLinkNode)  
  2. {  
  3.     if(NULL == pLinkNode)  
  4.         return 0;  
  5.           
  6.     return 1 + count_node(pLinkNode->next);  
  7. }
  1.  

一步一步写算法（之双向链表）

 前面的博客我们介绍了单向链表。那么我们今天介绍的双向链表，顾名思义，就是数据本身具备了左边和右边的双向指针。双向链表相比较单向链表，主要有下面几个特点：

    （1）在数据结构中具有双向指针

    （2）插入数据的时候需要考虑前后的方向的操作

    （3）同样，删除数据的是有也需要考虑前后方向的操作

    那么，一个非循环的双向链表操作应该是怎么样的呢？我们可以自己尝试一下：

    （1）定义双向链表的基本结构

[cpp] view plain copy

  1. typedef struct _DOUBLE_LINK_NODE  
  2. {  
  3.     int data;  
  4.     struct _DOUBLE_LINK_NODE* prev;  
  5.     struct _DOUBLE_LINK_NODE* next;  
  6. }DOUBLE_LINK_NODE;  

    （2）创建双向链表节点

[cpp] view plain copy

  1. DOUBLE_LINK_NODE* create_double_link_node(int value)  
  2. {  
  3.     DOUBLE_LINK_NODE* pDLinkNode = NULL;  
  4.     pDLinkNode = (DOUBLE_LINK_NODE*)malloc(sizeof(DOUBLE_LINK_NODE));  
  5.     assert(NULL != pDLinkNode);  
  6.   
  7.     memset(pDLinkNode, 0, sizeof(DOUBLE_LINK_NODE));  
  8.     pDLinkNode->data = value;  
  9.     return pDLinkNode;  
  10. }  

    （3）删除双向链表
 

[cpp] view plain copy

  1. void delete_all_double_link_node(DOUBLE_LINK_NODE** pDLinkNode)  
  2. {  
  3.     DOUBLE_LINK_NODE* pNode;  
  4.     if(NULL == *pDLinkNode)  
  5.         return ;  
  6.   
  7.     pNode = *pDLinkNode;  
  8.     *pDLinkNode = pNode->next;  
  9.     free(pNode);  
  10.     delete_all_double_link_node(pDLinkNode);  
  11. }  

    （4）在双向链表中查找数据
 

[cpp] view plain copy

  1. DOUBLE_LINK_NODE* find_data_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode, int data)  
  2. {  
  3.     DOUBLE_LINK_NODE* pNode = NULL;  
  4.     if(NULL == pDLinkNode)  
  5.         return NULL;  
  6.   
  7.     pNode = (DOUBLE_LINK_NODE*)pDLinkNode;  
  8.     while(NULL != pNode){  
  9.         if(data == pNode->data)  
  10.             return pNode;  
  11.         pNode = pNode ->next;  
  12.     }  
  13.       
  14.     return NULL;  
  15. }  

    （5）双向链表中插入数据
 

[cpp] view plain copy

  1. STATUS insert_data_into_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int data)  
  2. {  
  3.     DOUBLE_LINK_NODE* pNode;  
  4.     DOUBLE_LINK_NODE* pIndex;  
  5.   
  6.     if(NULL == ppDLinkNode)  
  7.         return FALSE;  
  8.   
  9.     if(NULL == *ppDLinkNode){  
  10.         pNode = create_double_link_node(data);  
  11.         assert(NULL != pNode);  
  12.         *ppDLinkNode = pNode;  
  13.         (*ppDLinkNode)->prev = (*ppDLinkNode)->next = NULL;  
  14.         return TRUE;  
  15.     }  
  16.   
  17.     if(NULL != find_data_in_double_link(*ppDLinkNode, data))  
  18.         return FALSE;  
  19.   
  20.     pNode = create_double_link_node(data);  
  21.     assert(NULL != pNode);  
  22.   
  23.     pIndex = *ppDLinkNode;  
  24.     while(NULL != pIndex->next)  
  25.         pIndex = pIndex->next;  
  26.   
  27.     pNode->prev = pIndex;  
  28.     pNode->next = pIndex->next;  
  29.     pIndex->next = pNode;  
  30.     return TRUE;  
  31. }  

    （6）双向链表中删除数据
 

[cpp] view plain copy

  1. STATUS delete_data_from_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int data)  
  2. {  
  3.     DOUBLE_LINK_NODE* pNode;  
  4.     if(NULL == ppDLinkNode || NULL == *ppDLinkNode)  
  5.         return FALSE;  
  6.   
  7.     pNode = find_data_in_double_link(*ppDLinkNode, data);  
  8.     if(NULL == pNode)  
  9.         return FALSE;  
  10.   
  11.     if(pNode == *ppDLinkNode){  
  12.         if(NULL == (*ppDLinkNode)->next){  
  13.             *ppDLinkNode = NULL;  
  14.         }else{  
  15.             *ppDLinkNode = pNode->next;  
  16.             (*ppDLinkNode)->prev = NULL;  
  17.         }  
  18.   
  19.     }else{  
  20.         if(pNode->next)  
  21.             pNode->next->prev = pNode->prev;  
  22.         pNode->prev->next = pNode->next;  
  23.     }  
  24.   
  25.     free(pNode);  
  26.     return TRUE;  
  27. }  

    （7）统计双向链表中数据的个数
 

[cpp] view plain copy

  1. int count_number_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode)  
  2. {  
  3.     int count = 0;  
  4.     DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode;  
  5.   
  6.     while(NULL != pNode){  
  7.         count ++;  
  8.         pNode = pNode->next;  
  9.     }  
  10.     return count;  
  11. }  

    （8）打印双向链表中数据

[cpp] view plain copy

  1. void print_double_link_node(const DOUBLE_LINK_NODE* pDLinkNode)  
  2. {  
  3.     DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode;  
  4.   
  5.     while(NULL != pNode){  
  6.         printf("%d\n", pNode->data);  
  7.         pNode = pNode ->next;  
  8.     }  
  9. }  

    注意：

        今天我们讨论的双向链表是非循环的，大家可以考虑一下如果改成循环双向链表，应该怎么写？如果是有序的循环双向链表，又该怎么写？

 

 

 

 

最近在接触内核方面的东西，遇见如下一段代码：

struct list_head {

        struct list_head *next, *prev;        //双向链表

};

 

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

 

#define LIST_HEAD(name) \

        struct list_head name = LIST_HEAD_INIT(name)

 

#define INIT_LIST_HEAD(ptr) do { \

        (ptr)->next = (ptr); (ptr)->prev = (ptr); \

} while (0)


 


 

 

在网上看了很多前人工作，在这里自己做下总结。

 

 

 

来看数据结构体:

 

struct list_head {         struct list_head *next, *prev; };

//宏定义如下:

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

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

 


 

举例如下：

 

 

struct list_head foo = { &(foo) , &(foo)}

 

相当于:

 

struct list_head foo; foo.next = &foo; foo.prev = &foo;

 

另一个例子:

 

struct list_head test = LIST_HEAD (check); LIST_HEAD (check);

 

在C语言中我们使用的结构体对应实例:例如:

 

struct student{long int num;

 

char name[20];char sex;

 

char addr[20];

 

}a={10101,"Li yong tian",'M',“513477736”};

 

 

 

a的初始化是四项，与结构体的成员是一一对应的。而结构体中:

 

struct list_head foo = { &(foo) , &(foo)}

 

在本文中等价与

 

:struct list_head {        struct list_head *next, *prev; } foo = { &(foo) , &(foo)};

 

按照成员的对应赋值就是:

 

struct list_head foo; foo.next = &foo; foo.prev = &foo;

 

 

 

//如果我有一个定义了一个对象：

struct list_head mylist;

 

//then

 

LIST_HEAD(mylist);

==

struct list_head mylist = { &(mylist), &(mylist) } ;

 

 


 

总而言之：用同一个对象初始化next 和 prev

 

 

 

而对于最后一段代码：

 

 

 

#define INIT_LIST_HEAD(ptr) do { \

        (ptr)->next = (ptr); (ptr)->prev = (ptr); \

} while (0)

 


 

 

 

初始化就是把指针指向自己。在不同版本的源码中，这些函数的实现方式略有不同，例如在linux-2.6.26中，此函数不是宏定义，而是一个内联函数，不过它们所做的工作都是大同小异的，这一点在本文其他部分都一样，下面就不再提醒了。

 

yu704645129
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
链表的几种基本子函数
weixin_45983950的博客
03-17 290
Search()函数 struct linknode *Search(struct linknode *head,int n) { int i=1; struct linknode *p=head; for(p=head;p!=NULL;p=p->next,i++) if(i==n) break; if(i<n) return NULL; else return p； } 查找函数，...
C语言链表超详解
k666499436的博客
05-17 10万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 15万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
C++ 链表
m0_62175410的博客
07-26 3万+
C++链表笔记
21. 合并两个有序链表
01-20
将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 解题思路 解法一：迭代法 复杂度分析： 时间复杂度：O(n ...
链表填空题（打印）1
08-08
/*链表的结点删除部分略*/}程序运行结果为： 333 gong 222 chen 111 wang3. 以下结点node定义了一个学生的信息，函数del
9-7链表数据求和操作1
08-08
算法训练 9-7链表数据求和操作 时间限制：1.0s 内存限制：512.0MB 读入10个复数，建立对应链表，然后求所有复数的和。样例输入1 2
删除排序链表中的重复元素
12-22
删除排序链表中的重复元素 题目 给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。 链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/ 思路 由于是排序链表，所以只需...
关于__Federico Milano 的电力系统分析工具箱.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
mlab-upenn 研究小组的心脏模型模拟.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
混合图像创建大师matlab代码.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
中序遍历二叉树-java版本
04-26
在Java中，实现二叉树的中序遍历同样可以通过递归来完成。中序遍历的顺序是：首先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。 在这段代码中，Node类定义了二叉树的节点，BinaryTree类包含一个指向根节点的指针和inOrder方法，用于递归地进行中序遍历。printInOrder方法调用inOrder方法并打印出遍历的结果。 在Main类中，我们创建了一个示例二叉树，并调用printInOrder方法来输出中序遍历的结果。输出应该是：4 2 5 1 3，这表示中序遍历的顺序是左子树（4），然后是根节点（2），接着是右子树的左子树（5），然后是右子树的根节点（1），最后是右子树的右子树（3）。
无头单向非循环链表的实现（SList.c）
最新发布
04-26
无头单向非循环链表的实现（函数定义文件）
两个有序链表的合并pta
04-26
"PTA" 通常指的是一种在线编程平台，例如“Pata”或者某些特定学校或组织的编程练习与自动评测系统。在这种平台或系统中，学生或程序员会提交代码来解决各种问题，然后系统会自动运行并评测这些代码的正确性。 当提到“两个有序链表的合并PTA”时，这通常意味着在PTA平台上解决一个特定的问题，即合并两个有序链表。具体任务可能是给定两个已按升序排序的链表，要求编写代码来合并这两个链表，形成一个新的有序链表。
在 Matlab 中创建的图形工具可改善航空航天数据的可视化.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
搜索引擎的设计与实现.zip
04-26
搜索引擎的设计与实现
年公司财务会计岗位工作总结（二）.docx
04-26
工作总结，新年计划，岗位总结，工作汇报，个人总结，述职报告，范文下载，新年总结，新建计划。
python 链表
09-13
链表是一种常见的数据结构，用于存储一个序列的元素。在Python中，可以用链表来表示和操作数据。 在链表中，每个元素被称为节点（Node），每个节点包含两部分：数据和指针。数据部分存储节点的值，指针部分指向下一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值