双向循环链表的基本操作

来源：互联网发布：js中给class移除样式编辑：程序博客网时间：2024/04/27 23:27

头文件：DuLinkList.h

#include<iostream>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
typedef int ElemType;
typedef int Status;

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

//构造一个空的双向循环链表L
Status InitList_DuL(DuLinkList& L)
{
L = (DuLinkList)malloc(sizeof(DuLNode));
if (!L)
exit(OVERFLOW);
L->prior = L;
L->next = L;
return OK;
}

//销毁双向循环链表L
Status DestroyList_DuL(DuLinkList& L)
{
DuLinkList p = L->next;
while (L!=p)
{
  DuLinkList q = p->next;
  free(p);
  p = q;
}
free(L);
L->next = NULL;
L->prior = NULL;
return OK;
}

//将双向循环线性链表置L为空表
Status ClearList_DuL(DuLinkList& L)
{
DuLinkList p = L->next;
while (L != p)
{
  DuLinkList q = p->next;
  free(p);
  p = q;
}
L->next = L;
L->prior = L;
return OK;
}

//若双向循环链表L为空表，则返回TRUE，否则返回FALSE
Status ListEmpty_DuL(DuLinkList L)
{
if (L->next == L || L->prior == L)
return TRUE;
else
return FALSE;
}

//返回双向循环链表L中数据元素个数
int ListLength_DuL(DuLinkList L)
{
DuLinkList p = L->next;
int length = 0;
while (L != p)
{
++length;
p = p->next;
}
return length;
}

//用p返回双向循环链表L中第i个结点
Status GetDuLNode_DuL(DuLinkList L, int i, DuLinkList& p)
{
if (i<1 || i>ListLength_DuL(L))
  return ERROR;
p = L->next;
int count = 0;
while (p != L)
{
  ++count;
  if (count == i)
   return OK;
  p = p->next;
}
return ERROR;
}

//用元素e返回双向循环链表L中第i个数据元素的值
Status GetElem_DuL(DuLinkList L, int i, ElemType& e)
{
if (i<1 || i>ListLength_DuL(L))
  return ERROR;
DuLinkList p = L->next;
int num = 0;
while (L!=p && num<i)
{
  ++num;
  if (num == i)
  {
   e = p->data;
   return OK;
  }
  p = p->next;
}
return ERROR;
}

//数据元素之间的关系，例如相等
Status compare(ElemType a, ElemType b)
{
if (a == b)
return TRUE;
else
return FALSE;
}

//返回双向循环链表L中第1个与元素e满足关系compare()的数据元素的位序。若这样的元素不存在则返回值为0
int LocateElem_DuL(DuLinkList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
int pos=0;
DuLinkList p = L->next;
while (L != p)
{
  ++pos;
  if (compare(e, p->data))
   return pos;
  p = p->next;
}
return 0;
}

//若cur_e是双向循环链表L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义
Status PriorElem_DuL(DuLinkList L, ElemType cur_e, ElemType& pre_e)
{
DuLinkList p = L->next;
while (L != p)
{
  if (p->data == cur_e && L->next!=p)
  {
   pre_e = p->prior->data;
   return OK;
  }
  p = p->next;
}
return INFEASIBLE;
}

//若cur_e是双向循环链表L的数据元素，且不是最后一个，则用next_e返回它的后继，否则操作失败，next_e无定义
Status NextElem_DuL(DuLinkList L, ElemType cur_e, ElemType& next_e)
{
DuLinkList p = L->next;
while (L != p)
{
  if (p->data == cur_e && p->next!=L)
  {
   next_e = p->next->data;
   return OK;
  }
  p = p->next;
}
return INFEASIBLE;
}

//在双向循环链表L中第i个位置之前插入新的数据元素e，表L的长度加1
Status ListInsert_DuL(DuLinkList& L, int i, ElemType e)
{
if (i<1 || i>ListLength_DuL(L) + 1)
  return ERROR;
DuLinkList s = (DuLinkList)malloc(sizeof(DuLNode));
if (!s)
  exit(OVERFLOW);
s->data = e;
if (i == ListLength_DuL(L) + 1)
{
  L->prior->next = s;
  s->prior = L->prior;
  L->prior = s;
  s->next = L;

}
else
{
  DuLinkList p;
  GetDuLNode_DuL(L, i, p);
  p->prior->next = s;
  s->prior = p->prior;
  p->prior = s;
  s->next = p;
}
return OK;
}

//删除双向循环链表L的第i个数据元素；并用e返回其值，表L的长度减1
Status ListDelete_DuL(DuLinkList& L, int i, ElemType& e)
{
DuLinkList p;
if (! GetDuLNode_DuL(L, i, p))
return ERROR;
e = p->data;
p->prior->next = p->next;
p->next->prior = p->prior;
free(p);
return OK;
}

//打印输出表L中数据元素
Status visit(ElemType e)
{
if (cout << e << " ")
return OK;
else
return ERROR;
}

//依次对双向循环链表L的每个数据元素调用函数visit().一旦visit()失败，则操作失败
Status ListTraverse_DuL(DuLinkList L, Status(*visit)(ElemType))
{
DuLinkList p;
for (int i = 1; i <= ListLength_DuL(L); ++i)
{
  GetDuLNode_DuL(L, i, p);
  if (!(*visit)(p->data))
   return ERROR;
}
return OK;
}

主函数：

#include"DuLinkList.h"
void main(void)
{
DuLinkList L;
InitList_DuL(L);
for (int i = 1, j = 1; i < 20; ++j, i += 2)
  ListInsert_DuL(L, j, i);
cout << "双向循环链表L的信息为：" << endl;
cout << "*******************************************" << endl;
cout << "长度为：" << ListLength_DuL(L) << endl;
cout << "数据元素分别为：";
ListTraverse_DuL(L, visit);
cout << endl;
cout << "*******************************************" << endl;
ElemType e;
GetElem_DuL(L, 6, e);
cout << "第6个数据是：" << e << endl;
ElemType pre;
if (PriorElem_DuL(L, e, pre) != INFEASIBLE)
  cout << e << "前面的数据是：" << pre << endl;
else
  cout << "数据元素" << e << "没有前驱！" << endl;
ElemType next;
if (NextElem_DuL(L, e, next) != INFEASIBLE)
  cout << e << "后面的数据是：" << next << endl;
else
  cout << "数据元素" << e << "没有后继！" << endl;
cout << "删除数据" << e << endl;
if (ListDelete_DuL(L, 6, e))
{
  cout << "删除数据成功！" << endl;
  cout << "更新后的数据是：" << endl;
  cout << "*******************************************" << endl;
  cout << "长度为：" << ListLength_DuL(L) << endl;
  cout << "数据元素分别为：";
  ListTraverse_DuL(L, visit);
  cout << endl;
  cout << "*******************************************" << endl;
}
else
  cout << "删除失败！" << endl;
cout << "值为7的数据元素的位置在：";
cout << "第" << LocateElem_DuL(L, 7, compare) << endl;
cout << "线性表L是否为空表：";
if (ListEmpty_DuL(L))
  cout << "是" << endl;
else
  cout << "否" << endl;
cout << "现将线性表L置为空表：" << endl;
ClearList_DuL(L);
cout << "线性表L是否为空表：";
if (ListEmpty_DuL(L))
  cout << "是" << endl;
else
  cout << "否" << endl;
cout << "将线性表L销毁！" << endl;
DestroyList_DuL(L);
}

0 0