C的数据结构---双向链表

 1.插入思想

 2.删除思想

优点：

双向链表在单链表的基础上增加了指向前驱的指针

功能上双向链表可以完全代替单链表使用

双向链表的Next，Pre和Current操作可以搞笑的遍历链表中的元素

 

#pragma once
#include <crtdbg.h> 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

typedef void BidLinkList;

typedef struct BidListNode      //结点
{
	struct BidListNode *next;   //指向后继
	struct BidListNode *pre;    //指向前驱
}BidListNode;

typedef struct HeadNode
{
	BidListNode head;
	BidListNode *cursor;
	int lenth;
}HeadNode;

BidLinkList* BidLinkList_Creat();  //创建链表

void BidLinkList_Destroy(BidLinkList *list); //销毁链表

void BidLinkList_Clear(BidLinkList *list);  //清空链表

int BidLinkList_Length(BidLinkList *list); //链表的当前长度

void BidLinkList_Insert(BidLinkList *list, BidListNode *node, int pos); //链表插入结点

BidListNode* BidLinkList_Get(BidLinkList *list, int pos);  //获取某位置结点

BidListNode* BidLinkList_Delete(BidLinkList *list, int pos); //删除某位置结点

BidListNode* BidLinkList_Reset(BidLinkList *list);     //重置游标,指向链表的第一个元素

BidListNode* BidLinkList_Current(BidLinkList *list);   //当前游标指向的数据元素

BidListNode* BidLinkList_DeleteNode(BidLinkList *list, BidListNode *node); //直接删除链表中的某个数据元素

BidListNode* BidLinkList_Next(BidLinkList *list);  //把当前游标返回，并且游标下移

 

#include "Bid_link_list.h"


BidLinkList* BidLinkList_Creat()  //创建链表
{
	HeadNode *tlist = (HeadNode*)malloc(sizeof(HeadNode));
	assert(tlist != NULL);
	tlist->cursor = NULL;
	tlist->head.next = NULL;
	tlist->head.pre = NULL;
	tlist->lenth = 0;
	return (BidLinkList*)tlist;
}

void BidLinkList_Destroy(BidLinkList *list) //销毁链表
{
	HeadNode *tlist = (HeadNode*)list;
	free(tlist);
}

void BidLinkList_Clear(BidLinkList *list)  //清空链表
{
	assert(list != NULL);
	HeadNode *tlist = (HeadNode*)list;
	tlist->lenth = 0;
	tlist->head.next = NULL;
	tlist->head.pre = NULL;
	tlist->cursor = NULL;
}

int BidLinkList_Length(BidLinkList *list)  //链表的当前长度
{
	assert(list != NULL);
	HeadNode *tlist = (HeadNode*)list;
	return tlist->lenth;
}

BidListNode* BidLinkList_Get(BidLinkList *list, int pos)  //获取某位置结点
{
	assert(list != NULL && pos >= 0);
	HeadNode *tlist = (HeadNode*)list;
	BidListNode *pCur = &tlist->head;
	for (int i = 0; i < pos && (pCur->next != NULL); i++)
	{
		pCur = pCur->next;
	}
	return pCur->next;
}


void BidLinkList_Insert(BidLinkList *list, BidListNode *node, int pos) //链表插入结点
{
	assert(list != NULL && node != NULL && pos >= 0);
	HeadNode *tlist = (HeadNode*)list;
	BidListNode *pCur = &tlist->head;
	for (int i = 0; i < pos && (pCur->next != NULL); i++)
	{
		pCur = pCur->next;
	}
	BidListNode *next = pCur->next;

	pCur->next = node;
	node->next = next;  //后继
	

	node->pre = pCur;	      //前驱

	if (next != NULL)         //插入第一个元素时，需要特殊处理
	{
		next->pre = node;
	}

	if (tlist->lenth == 0)
	{
		tlist->cursor = node;
	}

	//0号位置插入
	if (pCur == &tlist->head)
	{
		node->pre = NULL;
	}
  
	tlist->lenth++;
}

BidListNode* BidLinkList_Delete(BidLinkList *list, int pos) //删除某位置结点
{
	assert(list != NULL && pos >= 0);
	HeadNode *tlist = (HeadNode*)list;
	BidListNode *pCur = &tlist->head;
	for (int i = 0; i < pos && (pCur->next != NULL); i++)
	{
		pCur = pCur->next;
	}
	BidListNode *tmp = pCur->next;
	pCur->next = tmp->next;

	if (tmp->next != NULL)   //处理尾删   
	{
		tmp->next->pre = pCur;
		if (pCur == &tlist->head)  //处理头删 
		{
			tmp->next->pre = NULL;
		}
	}
	if (tlist->cursor == tmp)
	{
		tlist->cursor = tlist->cursor->next;
	}
	tlist->lenth--;
	return tmp;
}

BidListNode* BidLinkList_Reset(BidLinkList* list)     //重置游标,指向链表的第一个元素
{
	assert(list != NULL);
	HeadNode *tlist = (HeadNode*)list;
	tlist->cursor = tlist->head.next;
	return tlist->cursor;
}

BidListNode*BidLinkList_Current(BidLinkList *list)   //当前游标指向的数据元素
{
	assert(list != NULL);
	HeadNode *tlist = (HeadNode*)list;
	return tlist->cursor;
}

BidListNode* BidLinkList_DeleteNode(BidLinkList *list, BidListNode *node) //直接删除链表中的某个数据元素
{
	assert(list != NULL && node != NULL);
	HeadNode* tlist = (HeadNode*)list;
	BidListNode* pCur = &tlist->head;
	BidListNode* tmp = NULL;
	int i = 0;
	//查找node在链表中的位置
	for (; i < tlist->lenth; i++)
	{
		if (pCur->next == node)
		{
			tmp = pCur->next;
			break;
		}
		pCur = pCur->next;
	}
	if (tmp != NULL)
	{
		BidLinkList_Delete(list, i);
	}
	return tmp;
}

BidListNode* BidLinkList_Next(BidLinkList *list)  //把当前游标返回，并且游标下移
{
	assert(list != NULL);
	HeadNode* tlist = (HeadNode*)list;
	assert(tlist->cursor != NULL);
	BidListNode *tmp = tlist->cursor;
	tlist->cursor = tmp->next;
	return tmp;
}

struct Value
{
	BidListNode node;
	int v;
};

int main()
{
	BidLinkList *list = BidLinkList_Creat();
	struct Value v1, v2, v3, v4, v5;
	v1.v = 1; v2.v = 2, v3.v = 3, v4.v = 4, v5.v = 5;

	BidLinkList_Insert(list, (BidListNode*)&v1, BidLinkList_Length(list));
	BidLinkList_Insert(list, (BidListNode*)&v2, BidLinkList_Length(list));
	BidLinkList_Insert(list, (BidListNode*)&v3, BidLinkList_Length(list));
	BidLinkList_Insert(list, (BidListNode*)&v4, BidLinkList_Length(list));
	BidLinkList_Insert(list, (BidListNode*)&v5, BidLinkList_Length(list));
	
	for (int i = 0; i < BidLinkList_Length(list); i++)
	{
		struct Value *pv = (struct Value*)BidLinkList_Get(list, i);
		printf("%d  ", pv->v);
	}
	printf("\n");
	BidLinkList_Delete(list, BidLinkList_Length(list) - 1); //尾删
	BidLinkList_Delete(list, 0);  //头删

	for (int i = 0; i < BidLinkList_Length(list); i++)
	{
		struct Value *pv = (struct Value*)BidLinkList_Next(list);
		printf("%d  ", pv->v);
	}
	printf("\n");
	BidLinkList_Destroy(list);
	_CrtDumpMemoryLeaks();
	system("pause");
	return 0;
}