双向循环链表

#define _CRT_SECURE_NO_WARNINGS

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2


typedef int Status;

typedef struct {
	double a;
	int b;
}ElemType;

typedef struct DuLnode {
	ElemType elem;
	struct DuLnode* prior, * next;
}DuLnode, *DuLinkList;


void visit(ElemType e);								
Status InitList(DuLinkList &L);										//初始化链表
Status ListLength(DuLinkList L);									//返回线性表的长度
DuLnode* GetElem(DuLinkList L, int i);								//返回线性表中第i个元素的值
Status ListInsert_Dul(DuLinkList& L, int i, ElemType e);			//双向循环链表的插入
Status ListDelete_Dul(DuLinkList& L, int i, ElemType& e);			//双向循环链表的删除
void ListTraverse(DuLinkList L);									//遍历双向循环链表


int main()
{
	DuLinkList L = NULL;
	InitList(L);

	ElemType elem;
	int sum = 0;
	scanf("%d", &sum);
	for (int i = 0; i < sum; i++)
	{
		scanf("%lf%d", &elem.a, &elem.b);
		ListInsert_Dul(L, i + 1, elem);
	}
	printf("--------------------------------------\n");
	ListTraverse(L);
	printf("--------------------------------------\n");

	ListDelete_Dul(L, 3, elem);
	printf("删除双向循环链表中第3个元素e是：");
	visit(elem);

	printf("--------------------------------------\n");
	ListTraverse(L);
	
	return 0;
}


Status InitList(DuLinkList& L)
{
	L = (DuLinkList)malloc(sizeof(DuLnode));
	L->prior = L->next = L;

	if (!L)
		exit(OVERFLOW);
	return OK;
}


Status ListLength(DuLinkList L)
{
	int length = 0;
	DuLnode* p = L->next;
	while (p != L)
	{
		length++;
		p = p->next;
	}
	return length;
}


DuLnode* GetElem(DuLinkList L, int i)
{
	if (i < 1)
		return L;

	int j = 1;
	DuLnode* p = L->next;
	while (p != L && j < i)
	{
		p = p->next;
		j++;
	}
	if (p == L)
		return L;

	return p;
}


Status ListInsert_Dul(DuLinkList& L, int i, ElemType e)
{
	DuLnode* p = NULL;
	if (!(p = GetElem(L, i)) && ListLength(L))
		return ERROR;
	
	DuLnode* s = (DuLnode*)malloc(sizeof(DuLnode));
	s->elem = e;

	s->prior = p->prior;
	s->next = p;
	p->prior->next = s;
	p->prior = s;
	
	return OK;
}


Status ListDelete_Dul(DuLinkList& L, int i, ElemType& e)
{
	DuLnode* p = L;
	if(!(p = GetElem(L, i)))
		return ERROR;

	e = p->elem;
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	return OK;
}


void visit(ElemType e)
{
	printf("%lf %d\n", e.a, e.b);
}

void ListTraverse(DuLinkList L)
{
	DuLnode* p = L->next;
	while (p != L)
	{
		visit(p->elem);
		p = p->next;
	}
}