双向链表

最新推荐文章于 2024-09-04 20:30:50 发布
最新推荐文章于 2024-09-04 20:30:50 发布
阅读量302 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GaoChuang_/article/details/51113213
版权
一、单链表的局限性
              1.单链表的结点都只有一个指向下一个结点的指针。
                    2.单链表的数据元素无法直接访问其前驱的元素
二、双向链表的定义
            在链表的指针中增加一个指向其前驱的pre指针
          
三、双向链表的操作
      1.插入操作
                                                                               

  
  

   
   

    
    

     
     current
     
     ->
     
     next
     
     =
     
     node
     
     ;
     
     

    
    

   
   

   
   

    
    node->next=next;
   
   

   
   

    
    next->pre=node;
   
   

   
   

    
    node->pre=curent;
      2.删除操作
                                                                 
  
  

   
   

    
    current->next=next;
   
   

   
   

    
    next->pre=current;
    四 、双向链表的新操作
      1.获取当前游标指向的数据元素
       2.将游标重置指向链表的第一个元素
      3.将游标移动指向到链表中的下一个元素
      4.将游标移动指向到链表中的上一个元素
      5.直接指定删除链表中的某个数据元素          
 
  
  

   
   

    
    DLinkListNode* DLinkList_DeleteNode(DLinkList*list,DLinkListNode*node);
   
   

   
   

    
    DLinkListNode* DLinkList_Reset(DLinkList* list);

   
   

   
   

    
    DLinkListNode* 
    
    DLinkList_current(DLinkList* list);
    
    

   
   

   
   

    
    DLinkListNode* DLinkList_Next(DLinkList* list);

   
   

   
   

    
    DLinkListNode* DLinkList_Pre(DLinkList* list);

五.双向链表实例
DlinkList.h 
   
   

    
    

     
     #ifndef _DLINKLIST_H_
    
    

    
    

     
     #define _DLINKLIST_H_
    
    

    
    

     
      
    
    

    
    

     
     typedef void DLinkList;
    
    

    
    

     
      
    
    

    
    

     
     typedef  struct _tag_DLinkListNode DLinkListNode;
    
    

    
    

     
     struct _tag_DLinkListNode
    
    

    
    

     
     {
    
    

    
    

     
     	DLinkListNode*  next;
    
    

    
    

     
     	DLinkListNode*  pre;
    
    

    
    

     
     };
    
    

    
    

     
      
    
    

    
    

     
     DLinkList*  DLinkList_Creat();
    
    

    
    

     
      
    
    

    
    

     
     void DLinkList_Destory(DLinkList* list);
    
    

    
    

     
      
    
    

    
    

     
     void DLinkList_Clear(DLinkList* list);
    
    

    
    

     
      
    
    

    
    

     
     int  DLinkList_Length(DLinkList* list);
    
    

    
    

     
      
    
    

    
    

     
     int DLinkList_Insert(DLinkList*list,DLinkListNode* node,int pos);
    
    

    
    

     
      
    
    

    
    

     
     DLinkListNode* DLinkList_Get(DLinkList* list, int pos);
    
    

    
    

     
      
    
    

    
    

     
     DLinkListNode* DLinkList_Delete(DLinkList* list,int pos);
    
    

    
    

     
      
    
    

    
    

     
     /*游标的操作*/
    
    

    
    

     
     DLinkListNode* DLinkList_DeleteNode(DLinkList*list, DLinkListNode*node);
    
    

    
    

     
     DLinkListNode* DLinkList_Reset(DLinkList* list);
    
    

    
    

     
     DLinkListNode* DLinkList_current(DLinkList* list);
    
    

    
    

     
     DLinkListNode* DLinkList_Next(DLinkList* list);
    
    

    
    

     
     DLinkListNode* DLinkList_Pre(DLinkList* list);
    
    

    
    


     
      
    
    

    
    

     
     #endif
DlinkList.c 
   
   

    
    

     
     #include<stdio.h>
    
    

    
    

     
     #include<malloc.h>
    
    

    
    

     
     #include"DLinkList.h"
    
    

    
    

     
      
    
    

    
    

     
     /*双向链表的头结点的结构*/
    
    

    
    

     
     typedef struct _tag_DLinkList
    
    

    
    

     
     {
    
    

    
    

     
     	DLinkListNode header;
    
    

    
    

     
     	DLinkListNode* slider;
    
    

    
    

     
     	int length;
    
    

    
    

     
      
    
    

    
    

     
     }TDlinkList;
    
    

    
    

     
      
    
    

    
    

     
     /*创建一个双向链表*/
    
    

    
    

     
     DLinkList*  DLinkList_Creat()
    
    

    
    

     
     {
    
    

    
    

     
     	TDlinkList* ret = (TDlinkList*)malloc(sizeof(TDlinkList));
    
    

    
    

     
     	if (ret != NULL)
    
    

    
    

     
     	{
    
    

    
    

     
     		ret->length = 0;
    
    

    
    

     
     		ret->header.next = NULL;
    
    

    
    

     
     		ret->header.pre = NULL;
    
    

    
    

     
     		ret->slider = NULL;
    
    

    
    

     
     	}
    
    

    
    

     
     	return ret;
    
    

    
    

     
     }
    
    

    
    

     
     /*销毁创建的双向链表*/
    
    

    
    

     
     void DLinkList_Destory(DLinkList* list)
    
    

    
    

     
     {
    
    

    
    

     
     	free(list);
    
    

    
    

     
     }
    
    

    
    

     
     /*清空创建的双向链表*/
    
    

    
    

     
     void DLinkList_Clear(DLinkList* list)
    
    

    
    

     
     {
    
    

    
    

     
     	TDlinkList* slist = (TDlinkList*)list;
    
    

    
    

     
     	if (slist != NULL)
    
    

    
    

     
     	{
    
    

    
    

     
     		slist->length = 0;
    
    

    
    

     
     		slist->header.next = NULL;
    
    

    
    

     
     		slist->header.pre = NULL;
    
    

    
    

     
     		slist->slider = NULL;
    
    

    
    

     
     	}
    
    

    
    

     
     }
    
    

    
    

     
      
    
    

    
    

     
     int  DLinkList_Length(DLinkList* list)
    
    

    
    

     
     {
    
    

    
    

     
     	TDlinkList* slist = (TDlinkList*)list;
    
    

    
    

     
     	int ret = -1;
    
    

    
    

     
     	if (slist != NULL)
    
    

    
    

     
     	{
    
    

    
    

     
     		ret = slist->length;
    
    

    
    

     
     	}
    
    

    
    

     
     	return ret;
    
    

    
    

     
     }
    
    

    
    

     
     /*向双向链表中插入一个元素*/ //O(n)
    
    

    
    

     
      
    
    

    
    

     
     int DLinkList_Insert(DLinkList*list, DLinkListNode* node, int pos)
    
    

    
    

     
     {
    
    

    
    

     
     	TDlinkList* slist = (TDlinkList*)list;
    
    

    
    

     
     	int i = 0;
    
    

    
    

     
     	int ret = (list != NULL) && (node != NULL) && (pos >=0);
    
    

    
    

     
     	if (ret)
    
    

    
    

     
     	{
    
    

    
    

     
     	    DLinkListNode* current = (DLinkListNode*)list;
    
    

    
    

     
     		DLinkListNode* next = NULL;
    
    

    
    

     
     		for (i = 0; (i < pos) && (current->next!=NULL); i++)
    
    

    
    

     
     		{
    
    

    
    

     
     			current = current->next;
    
    

    
    

     
     		}
    
    

    
    

     
     		next = current->next;
    
    

    
    

     
     		current->next = node;
    
    

    
    

     
     		node->next = next;
    
    

    
    

     
     		/*如果链表空链表的操作*/
    
    

    
    

     
     		if (next != NULL)
    
    

    
    

     
     	    {
    
    

    
    

     
     			next->pre = node;
    
    

    
    

     
     		}
    
    

    
    

     
     		node->pre = current;
    
    

    
    

     
     		/*如果插入的元素是第一个元素的话*/
    
    

    
    

     
     		if (slist->length == 0)
    
    

    
    

     
     		{
    
    

    
    

     
     			node->pre = NULL;
    
    

    
    

     
     			slist->slider = node;
    
    

    
    

     
     		}
    
    

    
    

     
     		slist->length++;
    
    

    
    

     
     	}
    
    

    
    

     
      
    
    

    
    

     
     	return ret;
    
    

    
    

     
      
    
    

    
    

     
     }
    
    

    
    

     
     /**从双向链表中取出一个元素*/
    
    

    
    

     
     DLinkListNode* DLinkList_Get(DLinkList* list, int pos)
    
    

    
    

     
     {
    
    

    
    

     
     	TDlinkList* slist = (TDlinkList*)list; 
    
    

    
    

     
     	DLinkListNode* ret=NULL;
    
    

    
    

     
     	int i = 0;
    
    

    
    

     
     	if ((slist != NULL) && (pos >= 0) && (pos < slist->length))
    
    

    
    

     
     	{
    
    

    
    

     
     		DLinkListNode* current = (DLinkListNode*)slist;
    
    

    
    

     
     		for (i = 0; i < pos; i++)
    
    

    
    

     
     		{
    
    

    
    

     
     			current = current->next;
    
    

    
    

     
     		}
    
    

    
    

     
     		ret = current->next;
    
    

    
    

     
     	}
    
    

    
    

     
     	return ret;
    
    

    
    

     
      
    
    

    
    

     
     }
    
    

    
    

     
      
    
    

    
    

     
     /*删除双向链表中的一个元素*/
    
    

    
    

     
     DLinkListNode* DLinkList_Delete(DLinkList* list, int pos)
    
    

    
    

     
     {
    
    

    
    

     
     	TDlinkList* slist = (TDlinkList*)list;
    
    

    
    

     
     	DLinkListNode* ret = NULL;
    
    

    
    

     
     	int i = 0;
    
    

    
    

     
     	if ((slist != NULL) && (pos >= 0) && (pos <= slist->length))
    
    

    
    

     
     	{
    
    

    
    

     
     		/*current指向表头*/
    
    

    
    

     
     		DLinkListNode* current = (DLinkListNode*)slist;
    
    

    
    

     
     		DLinkListNode* next=NULL;
    
    

    
    

     
     		/*找到要背删除的元素*/
    
    

    
    

     
     		for (i = 0; i < pos; i++)
    
    

    
    

     
     		{
    
    

    
    

     
     			current = current->next;
    
    

    
    

     
     		}
    
    

    
    

     
     		ret = current->next;
    
    

    
    

     
     		next = ret->next;
    
    

    
    

     
      
    
    

    
    

     
     		current->next = next;
    
    

    
    

     
     		if (next != NULL)
    
    

    
    

     
     		{
    
    

    
    

     
     			next->pre = current;
    
    

    
    

     
     			/*被删的元素为第一个*/
    
    

    
    

     
     			if (current == (DLinkListNode*)slist)
    
    

    
    

     
     			{
    
    

    
    

     
     				next->pre = NULL;
    
    

    
    

     
     			}
    
    

    
    

     
     		}
    
    

    
    

     
     		/*如果游标正好指向被删的元素*/
    
    

    
    

     
     		if (slist->slider == ret)
    
    

    
    

     
     		{
    
    

    
    

     
     			slist->slider = next;
    
    

    
    

     
     		
    
    

    
    

     
     		}
    
    

    
    

     
     		slist->length--;
    
    

    
    

     
     	}
    
    

    
    

     
     	return ret;
    
    

    
    

     
     }
    
    

    
    

     
      
    
    

    
    

     
     /*游标操作*/
    
    

    
    

     
      
    
    

    
    

     
     /*删除指定的某个结点*/
    
    

    
    

     
     DLinkListNode* DLinkList_DeleteNode(DLinkList*list, DLinkListNode*node)
    
    

    
    

     
     {
    
    

    
    

     
     	TDlinkList* slist = (TDlinkList*)list;
    
    

    
    

     
     	DLinkListNode* ret = NULL;
    
    

    
    

     
     	int i = 0;
    
    

    
    

     
     	if (slist != NULL)
    
    

    
    

     
     	{
    
    

    
    

     
     		DLinkListNode* current = (DLinkListNode*)slist;
    
    

    
    

     
     		for (i = 0; i < slist->length; i++)
    
    

    
    

     
     		{
    
    

    
    

     
     			if (current->next == node)
    
    

    
    

     
     			{
    
    

    
    

     
     				ret = current->next;
    
    

    
    

     
     				break;
    
    

    
    

     
     			}
    
    

    
    

     
     			current = current->next;
    
    

    
    

     
     		}
    
    

    
    

     
     		if (ret != NULL)
    
    

    
    

     
     		{
    
    

    
    

     
     			DLinkList_Delete(slist,i);
    
    

    
    

     
     		}     
    
    

    
    

     
     	}
    
    

    
    

     
     	return ret;
    
    

    
    

     
     }
    
    

    
    

     
      
    
    

    
    

     
     /*将游标重置指向链表的第一个元素*/
    
    

    
    

     
     DLinkListNode* DLinkList_Reset(DLinkList* list)
    
    

    
    

     
     {
    
    

    
    

     
     	TDlinkList* slist = (TDlinkList*)list;
    
    

    
    

     
     	DLinkListNode* ret = NULL;
    
    

    
    

     
     	if (slist != NULL)
    
    

    
    

     
     	{
    
    

    
    

     
     		slist->slider = slist->header.next;
    
    

    
    

     
     		ret = slist->slider;
    
    

    
    

     
     	}
    
    

    
    

     
      
    
    

    
    

     
     	return ret;
    
    

    
    

     
      
    
    

    
    

     
     }
    
    

    
    

     
     /*获取当前游标指向的数据元素*/
    
    

    
    

     
     DLinkListNode* DLinkList_current(DLinkList* list)
    
    

    
    

     
     {
    
    

    
    

     
     	TDlinkList* slist = (TDlinkList*)list;
    
    

    
    

     
     	DLinkListNode* ret = NULL;
    
    

    
    

     
     	if (slist != NULL)
    
    

    
    

     
     	{
    
    

    
    

     
     		ret = slist->slider;
    
    

    
    

     
     	}
    
    

    
    

     
      
    
    

    
    

     
     	return ret;
    
    

    
    

     
     }
    
    

    
    

     
     /*将游标移动指向到链表中的下一个元素*/
    
    

    
    

     
     DLinkListNode* DLinkList_Next(DLinkList* list)
    
    

    
    

     
     {
    
    

    
    

     
     	TDlinkList* slist = (TDlinkList*)list;
    
    

    
    

     
     	DLinkListNode* ret = NULL;
    
    

    
    

     
     	if ((slist != NULL)&&(slist->slider!=NULL))
    
    

    
    

     
     	{
    
    

    
    

     
     		ret = slist->slider;
    
    

    
    

     
     		slist->slider = ret->next;
    
    

    
    

     
     	}
    
    

    
    

     
     	return ret;
    
    

    
    

     
     	
    
    

    
    

     
     }
    
    

    
    

     
     /*将游标移动指向到链表中的上一个元素*/
    
    

    
    

     
     DLinkListNode* DLinkList_Pre(DLinkList* list)
    
    

    
    

     
     {
    
    

    
    

     
     	TDlinkList* slist = (TDlinkList*)list;
    
    

    
    

     
     	DLinkListNode* ret = NULL;
    
    

    
    

     
     	if ((slist != NULL) && (slist->slider != NULL))
    
    

    
    

     
     	{
    
    

    
    

     
     		ret = slist->slider;
    
    

    
    

     
     		slist->slider = ret->pre;	
    
    

    
    

     
     	}
    
    

    
    

     
     	return ret;
    
    

    
    

     
      
    
    

    
    

     
     }
main.c 
   
   

    
    

     
     #include<stdio.h>
    
    

    
    

     
     #include"Dlinklist.h"
    
    

    
    

     
      
    
    

    
    

     
     struct Value
    
    

    
    

     
     {
    
    

    
    

     
     	DLinkListNode header;
    
    

    
    

     
     	int v;
    
    

    
    

     
      
    
    

    
    

     
     };
    
    

    
    

     
     int main()
    
    

    
    

     
     {
    
    

    
    

     
     	int i = 0;
    
    

    
    

     
     	DLinkList* list = DLinkList_Creat();
    
    

    
    

     
     	struct Value v1;
    
    

    
    

     
     	struct Value v2;
    
    

    
    

     
     	struct Value v3;
    
    

    
    

     
     	struct Value v4;
    
    

    
    

     
     	struct Value v5;
    
    

    
    

     
     	struct Value* pv;
    
    

    
    

     
     	v1.v = 1;
    
    

    
    

     
     	v2.v = 2;
    
    

    
    

     
     	v3.v = 3;
    
    

    
    

     
     	v4.v = 4;
    
    

    
    

     
     	v5.v = 5;
    
    

    
    

     
      
    
    

    
    

     
     	DLinkList_Insert(list,(DLinkListNode*)&v1,DLinkList_Length(list));
    
    

    
    

     
     	DLinkList_Insert(list,(DLinkListNode*)&v2, DLinkList_Length(list));
    
    

    
    

     
     	DLinkList_Insert(list,(DLinkListNode*)&v3, DLinkList_Length(list));
    
    

    
    

     
     	DLinkList_Insert(list,(DLinkListNode*)&v4, DLinkList_Length(list));
    
    

    
    

     
     	DLinkList_Insert(list,(DLinkListNode*)&v5, DLinkList_Length(list));
    
    

    
    

     
      
    
    

    
    

     
      
    
    

    
    

     
     	for (i = 0; i < DLinkList_Length(list); i++)
    
    

    
    

     
     	{
    
    

    
    

     
     		pv = (struct Value*)DLinkList_Get(list, i);
    
    

    
    

     
     		printf("%d\n",pv->v);
    
    

    
    

     
     	}
    
    

    
    

     
      
    
    

    
    

     
     	printf("\n");
    
    

    
    

     
      
    
    

    
    

     
     	DLinkList_Delete(list, DLinkList_Length(list)-1);
    
    

    
    

     
     	DLinkList_Delete(list,0);
    
    

    
    

     
     	for (i = 0; i < DLinkList_Length(list); i++)
    
    

    
    

     
     	{
    
    

    
    

     
     		pv = (struct Value*)DLinkList_Next(list);
    
    

    
    

     
     		printf("%d\n", pv->v);
    
    

    
    

     
     	}
    
    

    
    

     
      
    
    

    
    

     
     	printf("\n");
    
    

    
    

     
      
    
    

    
    

     
     	 DLinkList_Reset(list);
    
    

    
    

     
     	 DLinkList_Next(list);
    
    

    
    

     
     	pv = (struct Value*)DLinkList_current(list);
    
    

    
    

     
     	printf("%d\n", pv->v);
    
    

    
    

     
     	 
    
    

    
    

     
     	printf("\n");
    
    

    
    

     
     	DLinkList_DeleteNode(list,(DLinkListNode*)pv);
    
    

    
    

     
     	pv = (struct Value*)DLinkList_current(list);
    
    

    
    

     
     	printf("%d\n", pv->v);
    
    

    
    

     
      
    
    

    
    

     
        printf("\n");
    
    

    
    

     
        DLinkList_Pre(list);
    
    

    
    

     
      
    
    

    
    

     
        pv = (struct Value*)DLinkList_current(list);
    
    

    
    

     
        printf("%d\n", pv->v);
    
    

    
    

     
        DLinkList_Destory(list);
    
    

    
    

     
     	return 0;
    
    

    
    

     
     }

六、双向链表的优势
       1.双向链表在单链表的基础上增加了指向前驱的指针
       2.功能上双向链表可以完全取代单链表
      3.循环链表的Next ,Pre和Current可以高效的遍历链表中所有的元素

GaoChuang_
关注
专栏目录
数据结构之双向链表详解
小源_ 的博客
12-20 3609
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
C 双向链表
weixin_33748818的博客
09-13 166
单链表的结点都只有一个指向下一个结点的指针 单链表的数据元素无法直接访问其前驱元素 逆序访问单链表中的元素是极其耗时的操作！ len = LinkList_Length(list); for (i=len-1; len&gt;=0; i++) //O(n) { LinkListNode *p = LinkList_Get(list, i); //O(n)...
双向链表介绍
MHD0815的博客
08-22 728
双向链表（也称为双链表）是链表的一种重要数据结构，其特点在于每个数据节点中都有两个指针，分别指向其直接前驱和直接后继节点。这种结构使得从双向链表中的任意一个节点开始，都可以方便地访问其前驱和后继节点。
数据结构——双向链表
麦麦的博客
03-11 2311
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
数据结构--双向链表
m0_62706197的博客
06-24 1055
为了和前几篇文章的链表做比较，双向链表结构体也尽量定义相似的。// 前驱指针// 后驱指针。
单向链表与双向链表
qq_57106106的博客
07-29 954
可以解决顺序表存储空间上限，插入和删除效率低的问题链表：链式存储的线性表链表的组成：由一个个节点组成节点：由数据域和指针域组成数据域：存放数据的区域指针域：存放下一个节点地址的指针单向链表，双向链表，循环链表只能通过头节点或者头指针单向的访问后继节点的链表，称为单向链表。每个节点的指针域只记录其后继节点的地址。（火车结构）头节点结构体格式：int len；//头节点的数据域普通节点结构体格式：int data；//普通节点的数据域unionint len；//头节点的数据域。
双向链表C++
alanmian的博客
11-06 3483
双向链表，顾名思义，一条可双向进行的就叫双向链表。那怎么搞？也就是有前驱跟后继，有些时候有人不明白什么是前驱跟后继啊，浅显的讲讲，前驱就是当前结点指向上一个结点的箭头，那么上一个结点就是当前结点的前驱，后继就是当前结点的前一个结点，从上一个结点指向当前结点就叫后继，也就是说上个结点作为头，那当前结点作为尾，头的后继不就是尾嘛。 然后有头尾指针，双向嘛。头指针运动，尾指针也运动，所以这里要多存个尾指针。那说了这么多，先来构造给双向链表吧。 定义结构体老掉牙的东西了 思路！： 1.刚前面说了有前驱跟后继，那么
什么是双向链表，一篇搞懂双向链表
hahaha_1112的博客
03-12 1047
双向链表，python3
数据结构—双向链表
最新发布
LEE_C17的博客
09-04 990
主要结构是由，这三个结构组成，通过prev找到前一个节点，next指向下一个节点。结构：节点（Node）：每个节点包含三部分：数据（Data）：存储节点的值。前指针（Prev）：指向链表中前一个节点的指针。后指针（Next）：指向链表中下一个节点的指针。在双向链表中同样可以实现单向链表中的头插，尾插，头删等操作。此外，如用到结构体，结构体可以整体赋值。特点：单向遍历：单向链表只能从头节点开始，按顺序向下遍历，直到链表的末尾。无法逆向遍历。
操作系统课设-线程安全的双向链表
04-25
操作系统课程设计中实现线程安全的双向链表是一项重要的实践任务，这涉及到多线程编程、数据结构以及并发控制等核心知识点。在这个项目中，我们主要关注如何在多线程环境下构建一个能够正确操作（如插入、删除）而不...
创建双向链表_双向链表_
09-30
双向链表是一种特殊类型的数据结构，与常见的单向链表相比，它具有更丰富的操作能力，可以支持前后两个方向的遍历。本篇文章将深入探讨如何创建双向链表以及其在增加和删除操作中的应用。 双向链表的每个节点不仅...
双向链表.cpp 双向链表类定义及测试代码 c++
12-02
双向链表类定义及测试文件 对应于数据机构与算法分析（c++版）第三版或第二版 Clifford A.Shaffer 重庆大学使用教材
stm32f103 双向链表
08-16
在这个项目中，我们讨论的是如何在STM32F103上实现一个双向链表的数据结构。双向链表是一种特殊的数据结构，它允许我们在列表中的节点之间进行前向和后向的移动，这在处理动态数据集合时非常有用。 首先，我们要...
线性链表的顺序存储结构
GaoChuang_的博客
04-10 1081
线性表（List）        线性表 是数据元素的有序的并且有限的集合，线性表中的数据元素必须是同种类型的；        线性表的常用操作：                                          1.创建线性表                                      List*   List_Creat(
线性表--链表描述
GaoChuang_的博客
03-30 870
#ifndef _LIST_H_ #define _LIST_H_ #include /*线性表的抽象类*/ template class LineList { public: virtual ~LineList(){}; virtual bool empty() const =0; //判断线性表是否为空 virtual int size() cons
静态链表
GaoChuang_的博客
04-10 824
一、静态链表的定义：                            1.顺序表数组中的元素由两个数据域组成：date 和 next                        2.date域用来存储数据                        3.next域用来存储下一个元素在数组中的下标                 
基于C++模板 单链表基本操作
GaoChuang_的博客
03-16 649
涵盖单链表的基本操作方法,如有不足，欢迎提意见! list.h #ifndef _LIST_H_ #define _LIST_H_ /*节点类*/ template class Node { public: T data; Node* node; }; /*链表类*/ template class List { private: Node* head; //头节点 publ
双向链表数据管理
"多重双向链表的实现及操作" 多重双向链表是一种复杂的数据结构，它不仅包含元素节点，还包含多个指向不同属性的链接。在这个实现中，链表用于存储具有姓名、性别、信仰和职务等信息的员工数据。链表的每个节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值