数据结构（10）线性表之双向链表
- 导言
- 双向链表
- 存储结构
- 双向链表的示例图
- 示例
- 双向链表取得元素算法
- 双向表插入算法
- 双向表删除算法
- 双向链表的实现源码
- 运行结果
- 双向链表
导言
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
双向表的结点有两个指针域，一个是其直接前驱，一个是其直接后继。
双向链表
存储结构
typedef struct DuLNode
{
ElemType data;
struct DuLNode *prior;
struct DuLNode *next;
}DuLNode,*DuLinkList;
双向链表也有循环表形式
双向链表中，若d指向表中的某一个结点的指针（即d为DuLinkList型变量），则显然有：d⟶next⟶prior=d⟶prior⟶next=d
双向链表的示例图
双向链表操作，如ListLength、GetElem和LocateElem等仅需要涉及一个方向的指针，则它们的算法描述与线性表的操作相同，但插入、删除却有很大不同，需要改变两个方向上的指针。
示例
双向链表取得元素算法
Status GetElemP_DuL(DuLinkList va, int i, ElemType *e) {
// L为带头结点的单链表的头指针。
// 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
DuLinkList p;
p = va->next;
int j = 1; // 初始化，p指向第一个结点，j为计数器
while (p != va && j<i) { //顺指针向后查找，直到p指向第i个元素或p为空
p = p->next;
++j;
}
if (p == va || j > i) return ERROR; // 第i个元素不存在
*e = p->data; /* 取第i个元素 */
return OK;
} // GetElem_L双向表插入算法
Status ListInsert_DuL(DuLinkList &L, int i, ElemType e) { //算法2.18
// 在带头结点的双链循环线性表L的第i个元素之前插入元素e，
// i的合法值为1≤i≤表长+1。
DuLinkList p,s;
if (!(p = GetElemP_DuL(L, i))) // 在L中确定第i个元素的位置指针p
return ERROR; // p=NULL, 即第i个元素不存在
if (!(s = (DuLinkList)malloc(sizeof(DuLNode))))
return ERROR;
s->data = e;
s->prior = p->prior;
p->prior->next = s;
s->next = p;
p->prior = s;
return OK;
} // ListInsert_DuL
双向表删除算法
Status ListDelete_DuL(DuLinkList &L, int i, ElemType &e) {//算法2.19
// 删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
DuLinkList p;
if (!(p = GetElemP_DuL(L, i))) // 在L中确定第i个元素的位置指针p
return ERROR; // p=NULL, 即第i个元素不存在
e = p->data;
p->prior->next = p->next;
p->next->prior = p->prior;
free(p);
return OK;
} // ListDelete_DuL双向链表的实现源码
//所有定义
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define TRUE 1
#define FALSE 0
typedef int Status;//为了方便算法可用性，算法的Status可以通过这里可改
typedef char ElemType;//为了输出的可用性，数据的ElemType可以通过这里更改
#include <iostream>
using namespace std;
typedef struct DuLNode
{
ElemType data;
struct DuLNode *prior;
struct DuLNode *next;
}DuLNode, *DuLinkList;
void InitList(DuLinkList &L)
{ /* 产生空的双向循环链表L */
L = (DuLinkList)malloc(sizeof(DuLNode));
if (L)
L->next = L->prior = L;
else
exit(OVERFLOW);
}
void DestroyList(DuLinkList L)
{
DuLinkList q, p = L->next; /* p指向第一个结点 */
while (p != L) /* p没到表头 */
{
q = p->next;
free(p);
p = q;
}
free(L);
L = NULL;
}
void ClearList(DuLinkList L) /* 不改变L */
{
DuLinkList q, p = L->next; /* p指向第一个结点 */
while (p != L) /* p没到表头 */
{
q = p->next;
free(p);
p = q;
}
L->next = L->prior = L; /*头结点的两个指针域均指向自身 */
}
Status ListEmpty(DuLinkList L)
{ /* 初始条件：线性表L已存在*/
if(L->next == L && L->prior == L)
return TRUE;
else
return FALSE;
}
int ListLength(DuLinkList L)
{ /* 初始条件：L已存在。操作结果： */
int i = 0;
DuLinkList p = L->next; /* p指向第一个结点 */
while (p != L) /* p没到表头 */
{
i++;
p = p->next;
}
return i;
}
Status GetElemP_DuL(DuLinkList va, int i, ElemType *e) {
// L为带头结点的单链表的头指针。
// 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
DuLinkList p;
p = va->next;
int j = 1; // 初始化，p指向第一个结点，j为计数器
while (p != va && j<i) { //顺指针向后查找，直到p指向第i个元素或p为空
p = p->next;
++j;
}
if (p == va || j > i) return ERROR; // 第i个元素不存在
*e = p->data; /* 取第i个元素 */
return OK;
} // GetElem_L
int LocateElem(DuLinkList L, ElemType e, Status(*compare)(ElemType, ElemType))
{ /* 初始条件：L已存在，compare()是数据元素判定函数 */
/* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int i = 0;
DuLinkList p = L->next; /* p指向第1个元素 */
while (p != L)
{
i++;
if (compare(p->data, e)) /* 找到这样的数据元素*/
return i;
p = p->next;
}
return 0;
}
Status equal(ElemType c1, ElemType c2)
{ /* 判断是否相等的函数，Union()用到 */
if (c1 == c2)
return TRUE;
else
return FALSE;
}
Status PriorElem(DuLinkList L, ElemType cur_e, ElemType *pre_e)
{ /* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */
/* 否则操作失败，pre_e无定义 */
DuLinkList p = L->next->next; /* p指向第2个元素 */
while (p != L) /* p没到表头 */
{
if (p->data == cur_e)
{
*pre_e = p->prior->data;
return TRUE;
}
p = p->next;
}
return FALSE;
}
Status NextElem(DuLinkList L, ElemType cur_e, ElemType *next_e)
{ /* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
/* 否则操作失败，next_e无定义 */
DuLinkList p = L->next->next; /* p指向第2个元素 */
while (p != L) /* p没到表头 */
{
if (p->prior->data == cur_e)
{
*next_e = p->data;
return TRUE;
}
p = p->next;
}
return FALSE;
}
DuLinkList GetElemP_DuL(DuLinkList va, int i) {
// L为带头结点的单链表的头指针。
// 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
DuLinkList p;
p = va->next;
int j = 1; // 初始化，p指向第一个结点，j为计数器
while (p != va && j<i) { //顺指针向后查找，直到p指向第i个元素或p为空
p = p->next;
++j;
}
if (p == va && j<i) return NULL; // 第i个元素不存在
else return p;
} // GetElem_L
Status ListInsert_DuL(DuLinkList &L, int i, ElemType e) { //算法2.18
// 在带头结点的双链循环线性表L的第i个元素之前插入元素e，
// i的合法值为1≤i≤表长+1。
DuLinkList p, s;
if (!(p = GetElemP_DuL(L, i))) // 在L中确定第i个元素的位置指针p
return ERROR; // p=NULL, 即第i个元素不存在
if (!(s = (DuLinkList)malloc(sizeof(DuLNode))))
return ERROR;
s->data = e;
s->prior = p->prior;
p->prior->next = s;
s->next = p;
p->prior = s;
return OK;
} // ListInsert_DuL
Status ListDelete_DuL(DuLinkList &L, int i, ElemType &e) {//算法2.19
// 删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
DuLinkList p;
if (!(p = GetElemP_DuL(L, i))) // 在L中确定第i个元素的位置指针p
return ERROR; // p=NULL, 即第i个元素不存在
e = p->data;
p->prior->next = p->next;
p->next->prior = p->prior;
free(p);
return OK;
} // ListDelete_DuL
void ListTraverse(DuLinkList L, void(*visit)(ElemType))
{ /* 由双链循环线性表L的头结点出发，正序对每个数据元素调用函数visit() */
DuLinkList p = L->next; /* p指向头结点 */
while (p != L)
{
visit(p->data);
p = p->next;
}
}
void visit(ElemType elem)
{
cout << elem << " ";
}
int main()
{
//本程序说明，是在VS2013中运行的，若是其他地方无法运行，建议修改代码
//程序声明
cout << "***************************************************************************" << endl;
cout << " 《数据结构》<C语言版本>严蔚敏 吴伟名 编著 " << endl;
cout << " 编写年月2016年3月 " << endl;
cout << " 编写者:YuYunTan " << endl;
cout << " 双向链表 " << endl;
cout << "***************************************************************************" << endl;
DuLinkList A=NULL;
InitList(A);
ListInsert_DuL(A, 1, 'A');
ListInsert_DuL(A, 2, 'B');
ListInsert_DuL(A, 3, 'C');
ListInsert_DuL(A, 4, 'D');
ListInsert_DuL(A, 5, 'F');
cout << "List A = < ";
ListTraverse(A, visit);
cout << ">" << endl;
ElemType pa,prior_a,a_next;
GetElemP_DuL(A, 3, &pa);
cout << "第三个元素为"<< pa <<endl;
PriorElem(A, pa, &prior_a);
NextElem(A, pa, &a_next);
cout << pa << "的直接前驱是"<<prior_a << endl;
cout << pa << "的直接后继是" << a_next << endl;
cout << a_next << "在A中的位序是" << LocateElem(A, a_next, equal) << endl;
cout << "清空表A" << endl;
ClearList(A);
cout << "List A = < ";
ListTraverse(A, visit);
cout << ">" << endl;
DestroyList(A);
system("pause");
return 0;
}运行结果
双向链表到这里为止~