第五周周记

Posted 2020-06-29

双向链表的基本操作

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

typedef int DataType;
typedef struct LNode {
DataType data; /*存储结点值*/
LNode *prior;/*前驱结点地址*/
LNode *next; /*后继结点的地址*/
}Lnode,*LinkList;

/*函数声明*/
void InitList(LinkList &L);/*初始化链表*/
void ClearList(LinkList L);/*清空表*/
void DestroyList(LinkList &L);/*销毁双向链表*/
bool ListEmpty(LinkList L);/*判断表是否为空*/
int ListLength(LinkList L);/*判断表的长度*/
DataType GetElem(LinkList L,int i,DataType &e);/*返回第i个元素的值*/
int LocateElem(LinkList L,DataType e,DataType(*compare)(DataType,DataType));/*返回L中第1个与e满足关系compare()的数据元素的位序*/
DataType PriorElem(LinkList L,DataType cur_e,DataType &pre_e);/*前驱判断*/
DataType NextElem(LinkList L,DataType cur_e,DataType &next_e);/*后继判断*/
LinkList GetElem(LinkList L,int i);/*返回第i个元素的地址*/
DataType ListInsert(LinkList L,int i,DataType e);/*在表的第i个位置之前插入元素e*/
DataType ListDelete(LinkList L,DataType &e,int i);/*删除表中第i个元素*/
void ListTraverse(LinkList L);/*正序对每个元素调用函数visit()*/
void ListTraverseBack(LinkList );/*逆序对每个元素调用函数visit()*/

void InitList(LinkList &L)
{/*产生空间的双向循环链表*/
L=(LinkList)malloc(sizeof(LNode));
if(L)
L->next=L->prior=L;
else
exit(1);
}

void ClearList(LinkList L)
{ /*清空链表*/
LinkList p=L->next;/*p指向第一个结点*/
while(p!=L)
{ p=p->next;
free(p->prior);
}
L->next=L->prior=L;/*头结点的两个指针域指向其身*/

}
void DestroyList(LinkList &L)
{ ClearList(L);/*将L清空*/
free(L);
L=NULL;
}
bool ListEmpty(LinkList L)
{ /*判断表是否为空*/
if(L->next==L&&L->prior==L)
return true;
else
return false;
}
int ListLength(LinkList L)
{ /*返回表的长度*/
int i=0;
LinkList p=L->next;/*p指向第一个结点*/
while(p!=L)
{ i++;
p=p->next;
}
return i;
}

DataType GetElem(LinkList L,int i,DataType &e)
{ /*当第i个元素存在，将值赋给e*/
int j=1;
LinkList p=L->next;/*p指向第一个结点*/
while(p!=L&&j<i)/*顺指针向后查找，直到p指向第i个元素*/
{ j++;
p=p->next;
}
if(p==L||j>i)
return -1;
e=p->data;
return 1;
}
int LocateElem(LinkList L,DataType e,DataType(*compare)(DataType,DataType))
{ /*返回表中第1个与e满足关系compare()的数据元素的位序*/
int i=0;
LinkList p=L->next;
while(p!=L)/*p未指向头结点*/
{ i++;/*计数器加1*/
if(compare(p->data,e))/*找到这样的元素*/
return i;
p=p->next;
}
return 0;
}
DataType PriorElem(LinkList L,DataType cur_e,DataType &pre_e)
{ LinkList p=L->next->next;/*p指向第2个元素*/
while(p!=L)
{ if(p->data==cur_e)/*p指向值为cur_e的结点*/
{ pre_e=p->prior->data;/*将p的前驱结点的值赋给*/
return 1;
}

p=p->next;
}
return 0;
}

DataType NextElem(LinkList L,DataType cur_e,DataType &next_e)
{/*返回后继*/
LinkList p=L->next->next;/*p指向第二个元素*/
while(p!=L)
{ if(p->prior ->data==cur_e)/*p所指结点的前驱指向cur_e*/
{ next_e=p->data;/*将p所指结点的值赋给next_e*/
return 1;
}
p=p->next;
}
return 0;
}
LinkList GetElemP(LinkList L,int i)
{/*在双向链表中返回第i个元素的地址*/
int j;
LinkList p=L;/*p指向头结点*/
if(i<0||i>ListLength(L))
return NULL;
for(j=1;j<=i;j++)/*p指向第i个结点*/
p=p->next;//p指向下一个结点*/
return p;
}
DataType ListInsert(LinkList L,int i,DataType e)
{ /*在链表第i个位置上插入元素*/
LinkList p,s;
if(i<1||i>ListLength(L)+1)
return 0;
p=GetElemP(L,i-1);/*在L中确定第i个结点前驱的位置指针p*/
if(!p) return 0;
s=(LinkList)malloc(sizeof(LNode));/*生成新结点*/
if(!s) return 0;

s->data=e;/*将e赋给新的结点*/
s->prior=p;/*新结点的前驱为第i-1个结点*/
s->next=p->next;/*新结点的后继为第i个结点*/
p->next->prior=s;/*第i个结点的前驱指向新结点*/
p->next=s;/*第i-1个结点的后继指向新结点*/
return 1;
}

DataType ListDelete(LinkList L,DataType &e,int i)
{ /*删除第i个结点*/
LinkList p;

if(i<1)
return 0;
p=GetElemP(L,i);/*在L中确定第i个元素的位置指针*/
if(!p) return 0;
e=p->data;/*把第i个结点的元素的值赋给e*/
p->prior->next=p->next;/*第原i-1个结点的后继指向原第i+1个结点*/
p->next->prior=p->prior;/*第原i+1个结点的前驱指向原第i-1个结点*/
free(p);
return 1;
}

void ListTraverse(LinkList L)
{/*由双向循环链表的表头出发，正序对每个数据元素调用函数visit()*/
LinkList p=L->next;/*p指向首元结点*/
while(p!=L)
{ printf("%d %c",p->data,‘ ‘);/*对p所指结点调用函数visit()*/
p=p->next;
}
printf("\n");
}

void ListTraverseBack(LinkList L)
{ /*由双向循环链表的表头出发，逆序对每个元素调用函数visit()*/
LinkList p=L->prior;/*p指向尾结点*/
while(p!=L)
{ printf("%d %c",p->data,‘ ‘);;
p=p->prior;
}
printf("\n");
}

void print(DataType e)
{ printf("%2d",e);
}

void main()
{ LinkList L;
int i,k;
DataType e0,e,e1;
InitList(L);
for(i=1;i<=5;i++)
ListInsert(L,i,i);
printf("正序输出:");
ListTraverse(L);
printf("逆序输出:");
ListTraverseBack(L);
k=ListEmpty(L);
printf("\n判断表是否为空:k=%d(1,是;0,否)",k);
printf("\n判断表的长度:%d\n",ListLength(L));
printf("\n清空表\n");
ClearList(L);
printf("\n再次判断表是否为空\n");
k=ListEmpty(L);
printf("\n判断表是否为空:k=%d(1,是;0,否)",k);
printf("\n判断表的长度:%d\n",ListLength(L));

printf("重新插入元素\n");
for(i=1;i<=10;i++)
ListInsert(L,i,i);
ListTraverse(L);
printf("\n前驱判断\n");
for(i=1;i<=10;i++)
{ GetElem(L,i,e);/*将第i个元素的值赋给e*/
k=PriorElem(L,e,e0);/*判断前驱*/
if(k==0)
printf("元素%d没有前驱\n",e);
else
printf("元素%d的前驱为%d\n",e,e0);
}

printf("\n后继判断\n");
for(i=1;i<=10;i++)
{ GetElem(L,i,e);
k=NextElem(L,e,e1);
if(k==0)
printf("元素%d没有后继\n",e);
else
printf("元素%d的前驱为%d\n",e,e1);
}

printf("\n删除元素\n");
for(i=1;i<=10;i++)
{ GetElem(L,i,e);
ListDelete(L,e,i);
printf("删除第%d个元素后,e值为%d\n",i,e);
}
printf("\n清空表");
ClearList(L);
k=ListEmpty(L);
printf("\n判断表是否为空:k=%d(1,是;0,否)",k);
printf("\n判断表的长度:%d\n",ListLength(L));

}