双向循环列表基本操作

和单项列表类似，这里介绍一些基本操作，虽然结构上比单向列表复杂，但是操作起来却简易的多。

test.c`

#include "List.h"
void TestList1()
{
	/*
	ListNode* phead = NULL;
	ListInit(&phead);*/
	ListNode* phead = ListInit();
	ListPushBack(phead,1);
	ListPushBack(phead,2);
	ListPushBack(phead,3);
	ListPushBack(phead,4);
	ListPrint(phead);
	ListPopBack(phead);
	ListPrint(phead);
	ListPopBack(phead);
	ListPushFront(phead, 5);
	ListPushFront(phead, 6);
	ListPrint(phead);
	ListPopFront(phead);
	ListPopFront(phead);
	ListPrint(phead);
	ListNode* pos = ListFind(phead,2);
	ListInsert(pos,30);
	ListPrint(phead);
	ListErase(pos);
	ListPrint(phead);
	ListNodeDestory(&phead);
}
int main()
{
	TestList1();
	return 0;
}

List.c

#include "List.h"
ListNode* BuyListNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	node->data = x;
	node->prev = NULL;
	node->next = NULL;
	return node;
}
ListNode* ListInit()
{
	ListNode* phead = BuyListNode(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}
void ListNodeClear(ListNode* phead)
{
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	phead->next = phead;
	phead->prev = phead;
}
void ListNodeDestory(ListNode** phead)
{
	assert(*phead);
	ListNodeClear(*phead);
	free(*phead);
	*phead = NULL;
}
/*
void ListInit(ListNode** pphead)
{
	*pphead = BuyListNode(0);
	(*pphead)->next = *pphead;
	(*pphead)->prev = *pphead;
}
*/
void ListPrint(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while ((cur != phead))
	{
		printf("%d ",cur->data);
		cur = cur->next;
	}
	printf("\n");
}
void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* tail = (phead)->prev;
	ListNode* newnode = BuyListNode(x);
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = (phead);
	(phead)->prev = newnode;

}
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* tail = phead->next;
	ListNode* newnode = BuyListNode(x);
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = tail;
	tail->prev = newnode;

}
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(phead!=phead->next);
	ListNode* tail = phead->prev;
	ListNode* tailPrev = tail->prev;
	phead->prev = tailPrev;
	tailPrev->next = phead;
	
	
	free(tail);
	tail = NULL;
}
void ListPopFront(ListNode* phead)
{
	assert(phead);
	assert(phead != phead->next);
	ListNode* tail = phead->next;
	ListNode* tailNext= tail->next;
	phead->next = tailNext;
	tailNext->prev = phead;
	free(tail);
	tail = NULL;
}
ListNode* ListFind(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur!=phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* posPrev = pos->prev;
	ListNode* newNode = BuyListNode(x);
	posPrev->next = newNode;
	newNode->prev = posPrev;
	newNode->next = pos;
	pos->prev = newNode;
}
void ListErase(ListNode* pos)
{
	assert(pos);
	//assert(pos!=phead);
	ListNode* posPrev = pos->prev;
	ListNode* posNext = pos->next;
	free(pos);
	posPrev->next = posNext;
	posNext->prev = posPrev;
}

List.h

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
typedef int LTDataType;
typedef struct ListNode{
	struct ListNode* prev;
	struct ListNode* next;
	LTDataType data;
}ListNode;
ListNode* ListInit();
void ListNodeDestory(ListNode** phead);
void ListNodeClear(ListNode* phead);
//void ListInit(ListNode* pphead);
ListNode ListNodeInit(ListNode* phead);
ListNode* BuyListNode(LTDataType x);
void ListPushBack(ListNode* phead, LTDataType x);
void ListPushFront(ListNode* phead, LTDataType x);
void ListPopBack(ListNode* phead);
ListNode* ListFind(ListNode* phead, LTDataType x);
//在pos前面插入x
void ListInsert(ListNode* pos, LTDataType x);
void ListErase(ListNode* pos);