#include<stdio.h>
#include<iostream>

using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int ElemType;
typedef int Status;

所使用双向链表的结构

typedef struct DuLNode {
	ElemType data;
	struct DuLNode* prior;
	struct DuLNode* next;
}DuLNode,*DuLinkList;

其基本操作接口

Status InitList_DuL(DuLinkList& L);					//初始化双向链表
Status DestroyList_DuL(DuLinkList& L);				//销毁双向链表
Status ClearList_DuL(DuLinkList& L);				//双向链表L置空
Status ListEmpty_DuL(DuLinkList L);					//双向链表L判空
int Listlength_DuL(DuLinkList L);					//求双向链表L的长度
DuLNode* Search_DuL(DuLinkList L, ElemType e);		//查找。返回双向链表L中第一个数据域值为e的结点地址，若不存在则返回NULL
DuLNode* PriorElem_DuL(DuLNode* p);					//返回p结点的直接前驱的指针，若p结点是头结点则返回NULL
DuLNode* NextElem_Dul(DuLNode* p);					//返回p结点的直接后继的指针，若p结点是尾结点则返回NULL
DuLNode* MakeNode_DuL(ElemType e);					//分配一个数据域为e的结点，返回该结点的指针
Status InsertBefore_DuL(DuLNode* p, DuLNode* q);	//在p结点前插入q
Status InsertAfter_DuL(DuLNode* p, DuLNode* q);		//在p结点后插入q
Status Delete_DuL(DuLNode* p, ElemType& e);			//删除p所指向的结点，并用参数e返回p的元素值
void ListTraverse_DuL(DuLinkList L);				//遍历双向链表L

初始化双向链表

Status InitList_DuL(DuLinkList& L)
{
	L = (DuLinkList)malloc(sizeof(DuLNode));
	if (L == NULL)
	{
		return OVERFLOW;
	}
	else
	{
		L->next = NULL;
		L->prior = NULL;
		return OK;
	}
}

销毁双向链表

Status DestroyList_DuL(DuLinkList& L)
{
	if (L == NULL)
	{
		return OVERFLOW;
	}
	else
	{
		DuLNode* p, * q;
		p = L->next;
		while (p != NULL)
		{
			q = p;
			p = p->next;
			free(q);
		}
		L->next = NULL;
		free(L);
		return OK;
	}
}

双向链表L置空

Status ClearList_DuL(DuLinkList& L)
{
	if (L == NULL)
	{
		return OVERFLOW;
	}
	else
	{
		DuLNode* p, * q;
		p = L->next;
		while (p != NULL)
		{
			q = p;
			p = p->next;
			free(q);
		}
		L->next = NULL;
		return OK;
	}
}

双向链表L判空

Status ListEmpty_DuL(DuLinkList L)
{
	if (L->next == NULL)
	{
		return TRUE;
	}
	else
	{
		return ERROR;
	}
}

求双向链表L的长度

int Listlength_DuL(DuLinkList L)
{
	if (L == NULL)
	{
		return OVERFLOW;
	}
	else
	{
		int sum = 0;
		DuLNode* p;
		p = L->next;
		while (p != NULL)
		{
			sum++;
			p = p->next;
		}
		return sum;
	}
}

查找。返回双向链表L中第一个数据域值为e的结点地址，若不存在则返回NULL

DuLNode* Search_DuL(DuLinkList L, ElemType e)
{
	if (L == NULL)
	{
		return NULL;
	}
	else
	{
		DuLNode* p;
		p = L->next;
		while (p != NULL)
		{
			if (p->data == e)
			{
				break;
			}
			else
			{
				p = p->next;
			}
		}
	}
}

返回p结点的直接前驱的指针，若p结点是头结点则返回NULL

DuLNode* PriorElem_DuL(DuLNode* p)
{
	if (p == NULL)
	{
		return NULL;
	}
	else
	{
		return p->prior;
	}
}

返回p结点的直接后继的指针，若p结点是尾结点则返回NULL

DuLNode* NextElem_Dul(DuLNode* p)
{
	if (p == NULL)
	{
		return NULL;
	}
	else
	{
		return p->next;
	}
}

分配一个数据域为e的结点，返回该结点的指针

DuLNode* MakeNode_DuL(ElemType e)
{
	DuLNode* p = (DuLinkList)malloc(sizeof(DuLNode));
	if(p!=NULL)
	{
		p->data = e;
		p->next = NULL;
		p->prior = NULL;
		return p;
	}
}

在p结点前插入q

Status InsertBefore_DuL(DuLNode* p, DuLNode* q)
{
	if (p == NULL || q == NULL || p->prior == NULL)
	{
		return ERROR;
	}
	else
	{
		q->prior = p->prior;
		q->next = p;
		q->prior->next = q;
		p->prior = q;
		return OK;
	}
}

在p结点后插入q

Status InsertAfter_DuL(DuLNode* p, DuLNode* q)//在p结点后插入q
{
	if (p == NULL || q == NULL)
	{
		return ERROR;
	}
	else
	{
		if (p->next != NULL)//p结点不是尾结点
		{
			q->next = p->next;
			q->next->prior = q;
		}
		p->next = q;
		q->prior = p;
	}
}

删除p所指向的结点，并用参数e返回p的元素值

Status Delete_DuL(DuLNode* p, ElemType& e)
{
	if (p == NULL || p->prior == NULL)//p为空或p为头结点
	{
		return ERROR;
	}
	else
	{
		if (p->next != NULL)//判断p是不是尾结点。不是则对p的直接后继操作。
		{
			p->next->prior = p->prior;
		}
		p->prior->next = p->next;
		e = p->data;
		free(p);
		return OK;
	}
}

遍历双向链表L

void ListTraverse_DuL(DuLinkList L)
{
	if (L != NULL)
	{
		DuLNode* p;
		p = L->next;
		while (p != NULL)
		{
			cout<<p->data;
			p = p->next;
		}
	}
}

一些接口的测试

int main()
{
	//双向链表
	DuLinkList L;
	InitList_DuL(L);
	cout << ListEmpty_DuL(L) << endl;
	DuLNode* p = L;
	for (int i = 0; i < 5; i++)
	{
		DuLNode* q = MakeNode_DuL(i);
		InsertAfter_DuL(p, q);
		p = q;
	}
	cout << ListEmpty_DuL(L) << endl;
	cout << Listlength_DuL(L) << endl;
	DuLNode* q = MakeNode_DuL(9);
	InsertBefore_DuL(p, q);
	ListTraverse_DuL(L);
	cout << "\n";
	ElemType e;
	Delete_DuL(p, e);
	cout << e << endl;
	ListTraverse_DuL(L);
	cout << "\n";
	ClearList_DuL(L);
	cout << ListEmpty_DuL(L) << endl;
	DestroyList_DuL(L);
}

标签：结点,NULL,DuL,next,链表,双向,DuLNode,数据结构
来源： https://blog.csdn.net/xiangdahaodaima/article/details/122758884