数据结构学习，双向链表

数据结构学习，双向链表

目录

预先要引用的头文件以及宏定义

所使用双向链表的结构

其基本 *** 作接口

初始化双向链表

销毁双向链表

双向链表L置空

双向链表L判空

求双向链表L的长度

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

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

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

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

在p结点前插入q

在p结点后插入q

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

遍历双向链表L

一些接口的测试

---

预先要引用的头文件以及宏定义

#include
#include

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<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);
}