双向链表和双向循环链表

目录

一.前言

二. 双向链表的操作和建立

三. 双向循环链表建立

---

一.前言

        所谓双向链表就是在单链表的每一个结点里增加一个指向其直接前驱的指针域prior，这样链表中就形成了有两个方向不同的链，故称为双向链表。

双向链表的结构定义如下所示：

typedef struct DuLnode{
    Elemtype data;
    struct DuLnode* prior,*next;
}DuLnode,*DuLinkList;

其中，prior和next分别表示该双向链表中的前驱指针和后继指针。

二. 双向链表的操作和建立

        在双向链表中有些操作，如查找，取值，销毁，清空等操作，因为只涉及一个方向的指针，所以这些操作的算法和单链表的算法是相同，在我之前的博客关于单链表的操作里面就有算法源代码。但在插入，删除的时候，由于需要同时修改两个方向上的指针，所以算法发生了改变。我们下面主要来讲下双向链表的删除和插入操作。

1）双向链表的插入：

在带头结点的双向链表中的第i个位置之前插入元素e，如下所示：

int ListInsert(DuLinkList &L,int i,ElemType e){
    if(!(p=GetElem_DuL(L,i)) return ERROR;    //获取第i个位置的数据
    s=new DuLnode;        //创建一个新结点，并分配空间
    s->data=e;            //给要插入的值赋值给结点的数据域
    s->prior=p->prior;    //进行插入操作的指针改变
    p->prior->next=s;
    s->next=p;
    p->prior=s;
    return OK;
}

2）双向链表的删除：

删除带头结点的双向链表L的第i个元素，并用e返回，如下所示：

int ListDelete(DuLnode&L,int i,ElemType &e){
    if(!(p=GetElem_DuL(L,i)) return ERROR;
    e=p->data;
    p->prior->next=p->next;    //删除操作对指针域的改变
    p->next->prior=p->prior;
    free(p);
    return OK;
}

其中p=GetElem_DuL（L,i）大家可以理解为取双向链表中第i个位置的地址。实现该操作的代码，我之前的博客都有。

在知道了如何操作双向链表之后，肯定还不够，还得有双向链表的具体数据来给我们操作啊。下面我们来看下建立双向链表的完整源代码，在建立好双向链表之后，就能用到之前我们所学习的查找，取值，插入，删除等操作了。如下所示：

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;

typedef char ElemType;
//双向链表的定义
typedef struct DuLnode {
	ElemType data;
	struct DuLnode* prior;	//前驱指针
	struct DuLnode* next;	//后继指针
}DuLnode,*DuLinkList;

//双向链表结点的创建
DuLnode* CreateList(int n) {
	DuLnode* head, * Current;
	head = new DuLnode;
	if (!head) exit(-1);
	Current = head;
	head->data = n;
	head->prior = NULL;
	head->next = NULL;
	return head;
}

//开始创建一个双向链表
void CreateDuList(DuLnode** head,int data) {
	DuLnode* newLnode = CreateList(data);
	if (*head == NULL) {
		*head = newLnode;
	}
	else {
		newLnode->next = *head;
		(*head)->prior = newLnode;
		*head = newLnode;
	}
}

//双向链表的遍历
void travelList(DuLnode* head) {
	DuLnode* p = head;
	while (p != NULL) {
		printf(" %d", p->data);
		p = p->next;
	}
	printf("\n");
}

//双向链表的释放
void freeList(DuLnode* head) {
	DuLnode* temp;
	while (head != NULL) {
		temp = head;
		head = head->next;
		free(temp);
	}
}

int main() {
	DuLnode* head = NULL;		//首先定义一个头指针为空的双向链表
	CreateDuList(&head, 10);	//接着开始对它进行赋值
	CreateDuList(&head, 20);
	CreateDuList(&head, 30);

	travelList(head);			//遍历双向链表
	freeList(head);				
}

因为我们给我们的双向链表赋值了，下面我们来看下运行结果，是否都在里面：

 

我们从运行结果中可以看到，遍历这个双向链表的结果都是我们所放进去的数据。在有了这些数据之后，我们做取值，查找等操作的时候，就都会有一个具体的返回值了。

三. 双向循环链表建立

        双向循环链表同双向链表一样，除了插入，删除操作与 单链表的算法不一样之外，其他的算法都是相同的。由于只是多了两个指针域，所以，双向循环链表的插入，删除操作算法跟双向链表的算法也是相同的。所以在这里我们主要讲，如何建立一个带有具体指的双向链表，在建立好之后，同学们就可以在主函数中使用相关操作的函数对其进行相关操作。包括对它的数值重新赋值，进行删除等等。如下所示：

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

typedef char ElemType;
//双向链表的创建
typedef struct DuLnode {
	ElemType data;
	struct DuLnode* prior;
	struct DuLnode* next;
}DuLnode,*DuLinkList;

//双向循环链表结点的创建
DuLnode* Create(int n) {
	DuLnode* newnode;
	newnode = new DuLnode;
	if (!newnode) exit(-1);
	newnode->data = n;
	newnode->prior = newnode->next = newnode;
	return newnode;
}

//开始创建双向循环链表
void CreateDuCircle(DuLnode** head,int data) {
	DuLnode* newnode = Create(data);
	if (*head == NULL) {
		*head = newnode;
	}
	else {
		DuLnode* temp = *head;
		newnode->next = temp;
		newnode->prior = temp->prior;	//新增结点的前驱都是最右边的结点
		temp->prior->next = newnode;	//每新增一个结点，就要更新这个链表中最右边的结点的后继，也就是头结点前驱的后继
		temp->prior = newnode;			
		*head = newnode;
	}
}

void travel(DuLnode* head) {
	if (!head) return;
	DuLnode* Current = head;
	 do{
		printf("%d ", Current->data);
		Current = Current->next;
	 } while (Current != head);
	 printf("\n");
}

void free(DuLnode* head) {
	DuLnode* temp;
	do {
		temp = head;
		head = head->next;
		free(temp);
	} while (head != head->next);
}

int main() {
	DuLinkList L = NULL;
	CreateDuCircle(&L, 30);
	CreateDuCircle(&L, 20);
	CreateDuCircle(&L, 10);
	travel(L);
	free(L);
}