数据结构之双向链表

最新推荐文章于 2023-12-20 13:35:53 发布
最新推荐文章于 2023-12-20 13:35:53 发布
阅读量553 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 双向循环链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxjzlj/article/details/27685645
版权

前面我们学习了单向链表，并且把单向链表改成了循环链表，但是操作单向链表在往后访问的时候速度是很快，

如果你要往前访问操作就比较繁琐，所以这课我们来学习下双向链表。我们把前面的循环链表拿过来直接改成双向的。

第五个例子，双向循环链表：

头文件

#ifndef _DLINKLIST_H_
#define _DLINKLIST_H_

typedef void DLinkList;
typedef struct tag_DLinkListNode DLinkListNode;
struct tag_DLinkListNode
{
    DLinkListNode* next;
    DLinkListNode* pre;
};

DLinkList* DLinkList_Create();

void DLinkList_Destroy(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_Current(DLinkList* list);

DLinkListNode* DLinkList_Pre(DLinkList* list);

DLinkListNode* DLinkList_Next(DLinkList* list);

DLinkListNode* DLinkList_Reset(DLinkList* list);

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

#endif
我个人有点小小的强迫症，代码尽量要求简洁，所以没有注释，有什么不明白的可以留言。

实现文件

#include "DLinkList.h"
#include <malloc.h>

typedef struct tag_DLinkList
{
    DLinkListNode header;
    DLinkListNode* slider;
    int length;
}TDLinkList;

DLinkList* DLinkList_Create()
{
    TDLinkList* ret = NULL;
    
    ret = (TDLinkList*)malloc(sizeof(TDLinkList));
    if (ret)
    {
  		ret->length = 0;
  		ret->header.next = NULL;
  		ret->header.pre = NULL;
  		ret->slider = NULL;
    }
    
    return (DLinkList*)ret;
}

void DLinkList_Destroy(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;
}

int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos)
{
 	TDLinkList* sList = (TDLinkList*)list;
 	int ret = (sList != NULL) && (node != NULL);
 	ret = ret && (pos >= 0);
 	int i = 0;
 	
 	if (ret)
 	{
        DLinkListNode* current = (DLinkListNode*)sList;
        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)
 		{
	  	    sList->slider = node;
        }
        
        sList->length++;
        
        if (current == (DLinkListNode*)sList)
 		{
		    DLinkListNode* last = DLinkList_Get(sList, sList->length - 1);
	        last->next = current->next;
	    }
    }
 	
 	return ret;
}

DLinkListNode* DLinkList_Get(DLinkList* list, int pos)
{
    TDLinkList* sList = (TDLinkList*)list;
 	DLinkListNode* ret = NULL;
 	int i = 0;
 	
 	if ((sList != NULL) && (pos >= 0))
 	{
  	    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) && (sList->length > 0))
 	{
  	    DLinkListNode* current = (DLinkListNode*)sList;
  	    DLinkListNode* last = NULL;
  	    DLinkListNode* next = NULL;
  	    
  	    for (i = 0; i < pos; i++)
  	    {
		 	current = current->next;
		}
		
		if (current == (DLinkListNode*)sList)
		{
		    last = (DLinkListNode*)DLinkList_Get(list, sList->length - 1);
		}
		
		ret = current->next;
		next = ret->next;
		
		current->next = next;
		
		if (next != NULL)
		{
		    next->pre = current;
		    
		    if (current == (DLinkListNode*)sList)
		    {
   			    next->pre = NULL;
   			}
		}
		
		sList->length--;
		
		if (last)
        {
	        sList->header.next= ret->next;
            last->next = ret->next;
        }
        
		if (sList->slider == ret)
		{
		     sList->slider = ret->next;
        }
		
		if (sList->length == 0)
		{
            sList->header.next = NULL;
            sList->slider = NULL;
        }
    }
 	
 	return ret;
}

DLinkListNode* DLinkList_Current(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
 	DLinkListNode* ret = NULL;
 	
 	if (sList != NULL)
 	{
        ret = sList->slider;
    }
 	
 	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;
}

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_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_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(list, i);
		}
    }
			   
 	return ret;
}
在实现文件里面，我们仅仅是添加了一些逆向操作的修改。
测试文件 

#include <stdio.h>
#include <stdlib.h>
#include "DLinkList.h"

typedef struct tag_Value
{
    DLinkListNode header;
    int v;
}Value;

int main(int argc, char *argv[])
{
    DLinkList* list = DLinkList_Create();
    
    Value a,b,c,d,e,f,g;
    
    a.v = 1;
    b.v = 2;
    c.v = 3;
    d.v = 4;
    e.v = 5;
    f.v = 6;
    g.v = 7;
    int i = 0;
    
    DLinkList_Insert(list, (DLinkListNode*)&a, 0);
    DLinkList_Insert(list, (DLinkListNode*)&b, 0);
    DLinkList_Insert(list, (DLinkListNode*)&c, 0);
    DLinkList_Insert(list, (DLinkListNode*)&d, 0);
    DLinkList_Insert(list, (DLinkListNode*)&e, 0);
    
    printf("length = %d\n", DLinkList_Length(list));
    
    for (i = 0; i < DLinkList_Length(list); i++)
    {
	 	Value* p = (Value*)DLinkList_Get(list, i);
	 	printf("%d\n", p->v);
    }
    
    printf("------------------\n");
    while(DLinkList_Length(list) > 0)
    {
        Value* pv = (Value*)DLinkList_Delete(list, DLinkList_Length(list) - 1);
        printf("%d\n", pv->v);
    }
    printf("length = %d\n", DLinkList_Length(list));
    
    DLinkList_Insert(list, (DLinkListNode*)&a, 0);
    DLinkList_Insert(list, (DLinkListNode*)&b, 0);
    DLinkList_Insert(list, (DLinkListNode*)&c, 0);
    DLinkList_Insert(list, (DLinkListNode*)&d, 0);
    DLinkList_Insert(list, (DLinkListNode*)&e, 0);
    DLinkList_Insert(list, (DLinkListNode*)&f, 0);
    DLinkList_Insert(list, (DLinkListNode*)&g, 0);
    
    printf("length = %d\n", DLinkList_Length(list));
    
    Value* pc = (Value*)DLinkList_Current(list);
    printf("cur = %d\n", pc->v);
    
    while (DLinkList_Length(list) > 0)
    {
	 	Value* pp = (Value*)DLinkList_Pre(list);
	 	printf("%d\n", pp->v);
	 	
	 	DLinkList_DeleteNode(list, (DLinkListNode*)pp);
    }
    
    printf("length = %d\n", DLinkList_Length(list));
    
  	DLinkList_Destroy(list);
  	
    system("PAUSE");	
    return 0;
}
双向链表的操作跟单向链表大同小异，所以你前面单向链表能看懂，这个应该不在话下吧！

好了，双向链表介绍完毕！温馨提示：所有代码都可以直接添加到工程复用。


懒懒de剑剑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】双向链表实现
Chen_yuazzy的博客
07-28 549
代码实现： #include<stdio.h> #include<math.h> #include<stdlib.h> #include<time.h> #define Elemtype int typedef struct D_linklist{ Elemtype data; struct D_linklist *front,*nex...
数据结构之双向链表（C语言实现）
kang___xi的博客
11-26 9543
数据结构之双向链表（C语言实现）
数据结构之双向链表详解
最新发布
小源_ 的博客
12-20 3440
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
C#数据结构之双向链表(DbLinkList)实例详解
09-03
在C#中，双向链表（Double-Linked List，简称DbLinkList）是一种重要的数据结构，它允许在列表中的每个元素都有两个链接：一个指向前一个元素，另一个指向后一个元素。这种数据结构使得在链表中进行前向和后向遍历变...
Python数据结构之双向链表的定义与使用方法示例
09-20
Python中的双向链表是一种线性数据结构，与单链表相比，它在每个节点中不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这使得双向链表可以在正向和反向两个方向上进行遍历，提高了操作的灵活性。 ...
JavaScript数据结构之双向链表定义与使用方法示例
10-19
在JavaScript中，数据结构是构建高效算法的基础，而双向链表是一种重要的线性数据结构。本文将深入探讨双向链表的定义、工作原理以及如何在JavaScript中实现和使用它。 双向链表，顾名思义，是每个节点不仅包含指向...
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
在JavaScript中，数据结构是构建复杂程序的基础，其中双向链表和双向循环链表是两种重要的线性数据结构。本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）...
数据结构之静态链表
zxjzlj的专栏
05-28 687
学习数据结构已经很久了，一直没有用上，最近时间有点空闲，所以翻出来炒一炒。子曰：温故而知新。当初学习数据结构的时候，买的是国嵌唐老师的视频，所以这些代码很唐老师写的几乎一模一样，若转载请注明出自国嵌唐老师数据结构教程。 首先来看第三个例子，顺序表： 头文件
数据结构之链式链表
zxjzlj的专栏
05-28 655
学习数据结构已经很久了，一直没有用上，最近时间有点空闲，所以翻出来炒一炒。子曰：温故而知新。当初学习数据结构的时候，买的是国嵌唐老师的视频，所以这些代码很唐老师写的几乎一模一样，若转载请注明出自国嵌唐老师数据结构教程。 首先来看第二个例子，链式lian'bi： 头文件
数据结构之进阶排序（希尔排序、快速排序、归并排序）
zxjzlj的专栏
06-24 645
我们学习了最基础的三种排序，它们都有个共同点，
数据结构之循环链表
zxjzlj的专栏
05-30 568
前面学习了链式结构链表，那么链式结构链表也y
数据结构之链式栈
zxjzlj的专栏
06-10 478
好久不见，前面我们学过了数据结构的顺序栈。今天我们来学习下链式栈的实现，链式栈的话，还是要利用前面我们实现的链式链表，不知道链式链表的，出门左转，前面就有介绍。 第五个例子，链式栈的实现： 注：把我们先前实现的链式链表的头文件和实现文件包含进来 头文件 #ifndef _LINKSTACK_H_ #define _LINKSTACK_H_ typedef void Lin
数据结构之顺序链表
zxjzlj的专栏
05-28 473
学习数据结构已经很久了，
数据结构之链式队列
zxjzlj的专栏
06-19 464
我们实现了顺序

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值