双向链表实作-优快云博客

本文链接：https://blog.youkuaiyun.com/whynot_1/article/details/109464316

双向链表的实现

双向链表的应用背景主要是单向链表只能顺序访问，逆序访问单向链表（尤其是较大的单向链表是一件极其费时费力的工作），相比于单向链表，双向链表增加了一个域，这个域里面增加了一个指向前驱节点的指针，使得整个链表可以顺序访问或者逆序访问，来去自如；

//定义的双向链表的头文件，里面包含了双向链表的声明和数据类型的定义；
#ifndef _MY_DOUBLELIST_H
#define _MY_DOUBLELIST_H
typedef void DLinkList;
typedef struct _tag_DlinkListNode
{
	struct _tag_DlinkListNode* next;
	struct _tag_DlinkListNode* pre;
}DLinkListNode;
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_DeleteNode(DLinkList* list,DLinkListNode* node);
DLinkListNode* DLinkList_Reset(DLinkList* list);
DLinkListNode* DLinkList_Current(DLinkList* list);
DLinkListNode* DLinkList_Next(DLinkList* list);
DLinkListNode* DLinkList_prior(DLinkList* list);
#endif
/******************头文件中声明的函数的定义*********************/

#include<iostream>
using namespace std;
#include"doublelist.h"
typedef struct _tag_DlinkList
{
	DLinkListNode header;
	DLinkListNode* slider;
	int length;
}TDLinkList;
DLinkList* DLinkList_Create()
{
	TDLinkList* ret = (TDLinkList*)malloc(sizeof(TDLinkList));
	if (ret != NULL)
	{
		ret->length = 0;
		ret->slider = NULL;
		ret->header.next = NULL;
		ret->header.pre = NULL;
	}
	return ret;
}
void DLinkList_Destroy(DLinkList* list)
{
	TDLinkList* slist = (TDLinkList*)list;
	if (slist == NULL)
	{
		return;
	}
	free(slist);
}
void DLinkList_Clear(DLinkList* list)
{
	TDLinkList* slist = (TDLinkList*)list;
	if (slist == NULL)
	{
		return;
	}
	slist->length = 0;
	slist->header.next = NULL;
	slist->header.pre = NULL;
	slist->slider = NULL;
}
int DLinkList_Length(DLinkList* list)
{
	TDLinkList* slist = (TDLinkList*)list;
	if (slist != NULL)
	{
		return slist->length;
	}
}
int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos)
{
	TDLinkList* slist = (TDLinkList*)list;
	DLinkListNode* current = (DLinkListNode*)list;
	DLinkListNode* next =NULL;
	for (int i = 0; (i < pos) && (node != NULL) && (slist != NULL); i++)
	{
		current = current->next;
	}
	next = current->next;//增加了一个指针，这个指针指向要插入的位置的后一个结点
	node->next = next;
	current->next = node;
	if(next!=NULL)//增加一步判断，如果next==NULL,说明插入的是第一个元素；
	{ 
		next->pre = node;
	}
	node->pre = current;
	
	if (slist->length == 0)//如果长度是0，就指向第一个元素，换句话说：如果是第一次插入，游标就指向第一个元素；
	{
		slist->slider = node;
	}
	if (current == (DLinkListNode*)slist)
	{
		node->pre = NULL;
	}
	slist->length++;
	return 0;
}
DLinkListNode* DLinkList_Get(DLinkList* list, int pos)
{
	TDLinkList* slist = (TDLinkList*)list;
	DLinkListNode* current = (DLinkListNode*)list;
	if (slist != NULL)
	{
		for (int i = 0; (i < pos)&&(pos<slist->length); i++)
		{
			current = current->next;
		}
	}
	return current->next;
}
DLinkListNode* DLinkList_Delete(DLinkList* list, int pos)
{
	TDLinkList* slist = (TDLinkList*)list;
	DLinkListNode* ret = NULL;
	int i = 0;
	if (slist == NULL || pos < 0)
	{
		return NULL;
	}
	DLinkListNode* current = (DLinkListNode*)slist;
	DLinkListNode* next = NULL;
	for (i = 0; i < pos; i++)
	{
		current = current->next;
	}
	ret = current->next;
	next = ret->next;
	
	//步骤1
	current->next = next;
	//步骤2，next!=NULL 判断除了0号位置之外还有别的元素；
	if (next != NULL)
	{
		next->pre = current;
		if (current == (DLinkListNode*)list)
		{
			next->pre = NULL;//如果是删除的第0个位置，将后继结点的pre域指向NULL；
		}
	}
	if (slist->slider = ret)
	{
		slist->slider = next;//如果当前删除的结点是游标所指的元素，游标下移
	}
	slist->length--;
}

//与游标相关的函数
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_prior(DLinkList* list)//游标前移
{
	TDLinkList* slist = (TDLinkList*)list;
	DLinkListNode* ret = NULL;
	if ((slist != NULL) && (slist->slider != NULL))
	{
		ret = slist->slider;
		slist->slider = ret->pre;
	}
	return ret;
}

/*******************双向链表测试框架*********************/
#include<iostream>
#include"doublelist.h"
using namespace std;
typedef struct value
{
	DLinkListNode node;
	int v;

}Value;
int main()
{
	int i = 0;
	DLinkList* list = DLinkList_Create();
	Value v1, v2, v3, v4, v5;
	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));
	Value* pv = NULL;
	for (i = 0; i < DLinkList_Length(list); i++)
	{
		pv = (Value*)DLinkList_Get(list, i);
		cout << pv->v;
	}
	cout << endl;
	DLinkList_Delete(list, DLinkList_Length(list) - 1);
	DLinkList_Delete(list, 0);
	for (i = 0; i < DLinkList_Length(list); i++)
	{
		pv = (Value*)DLinkList_Get(list, i);
		cout << pv->v;
	}
	cout << endl;

	DLinkList_Reset(list);
	DLinkList_Next(list);
	pv = (Value*)DLinkList_Current(list);
	cout << pv->v;
	cout << endl;
	DLinkList_DeleteNode(list, (DLinkListNode*)pv);
	pv = (Value*)DLinkList_Current(list);
	cout << pv->v;
	cout << endl;
	DLinkList_prior(list);
	pv = (Value*)DLinkList_Current(list);
	cout << pv->v;
	cout << endl;
	return 0;

}

双向链表实现

双向链表的实现