项目1：线性链表的基本操作

#include<iostream>
#define ok 1
#define error 0
using namespace std;

typedef int Status;
typedef int ElemType;
typedef struct Lnode{
ElemType data;
Lnode	 *next;
} *Link,*Position;
typedef struct{
Link head,tail;
int len;
} LinkList;

class ListOperation
{
public:
//分配由p指向的值为e的结点，并返回ok；若分配失败，则返回error;
Status MakeNode(Link &p,ElemType e);
//释放p所指结点
void FreeNode(Link &p);
//构造一个空的线性链表L
Status InitList(LinkList &L);
//将线性链表重置为空表，并释放原链表的结点空间
Status ClearList(LinkList &L);
//销毁线性链表L，L不再存在
Status DestroyList(LinkList &L);
//已知h指向线性链表的头结点，将s所指结点插入在第一个结点之前
Status InsFirst(LinkList &L,Link h,Link s);
//已知h指向线性链表的头结点，删除链表中的第一个结点并以q返回
Status DelFirst(LinkList &L,Link h,Link &q);
//将指针s所指（彼此以指针相链）的一串结点链接在线性链表L的最后一个结点
//之后，并改变链表的L的尾指针指向新的尾结点
Status Append(LinkList &L,Link s);
//删除线性链表L中的尾结点并以q返回，改变链表的L的尾指针指向新的尾结点
Status Remove(LinkList &L,Link &q);
//已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前
//并修改指针p指向新插入的结点
Status InsBefore(LinkList &L,Link &p,Link s);
//已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之后
//并修改指针p指向新插入的结点
Status InsAfter(LinkList &L,Link &p,Link s);
//已知p指向线性链表L中一个结点，用e更新p所指结点中数据元素的值
Status SetCurElem(Link &p,ElemType e);
//已知p指向线性链表中一个结点，返回p所结点中数据元素的值
ElemType GetCurElem(Link p);
//若线性链表L为空表，则返回true，否则返回false
bool ListEmpty(LinkList L);
//返回线性链表L中元素个数
int ListLength(LinkList L);
//返回线性链表中头结点位置
Position GetHead(LinkList L);
//返回线性链表中最后一个结点的位置
Position GetLast(LinkList L);
//已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置
//若无前驱，则返回NULL
Position PriorPos(LinkList L,Link p);
//已知p指向线性链表L中的一个结点，返回p所指结点的直接后继的位置
//若无后继，则返回NULL
Position NextPos(LinkList L,Link p);
//返回p指向线性链表L中第i个结点的位置并返回ok，i值不合法时返回error
Status LocatePos(LinkList L,int i,Link p);
//返回线性链表L中第一个与e满足函数compare()判定关系的位置，
//若不存在这样的元素则返回NULL,此处compare是指向函数的指针变量
//Status compare(ElemType x,ElemType y);
Position LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType ,ElemType));
//依次对L的每个元素调用函数visit（）。一旦visit（）失败，则操作失败
//Status visit(ElemType x);
Status ListTraverse(LinkList L,Status(*visit)(ElemType));
};

Status ListOperation::MakeNode(Link &p,ElemType e)
{
p=new Lnode;
p->data=e;
if(p)
return ok;
else
return error;
}

void ListOperation::FreeNode(Link &p)
{
delete p;
p=NULL;
}

Status ListOperation::InitList(LinkList &L)
{
L.head=new Lnode;
L.head->next=NULL;
L.tail=L.head;
L.len=0;
if(L.head)
{
cout<<"线性链表初始化成功"<<endl;
return ok;
}
else
return error;
}

Status ListOperation::ClearList(LinkList &L)
{
Link p=L.head->next;
while(p)
{
L.head->next=p->next;
delete p;
p=NULL;
L.len--;
p=L.head->next;
}
if(L.head->next==NULL)
{
//cout<<"线性链表重置为空"<<endl;
return ok;
}
else
return error;
}

Status ListOperation::DestroyList(LinkList &L)
{
ClearList(L);
delete L.head;
L.head=NULL;
L.tail=NULL;
if(!L.head)
return ok;
else
return error;
}

Status ListOperation::InsFirst(LinkList &L,Link h,Link s)
{
s->next=h->next;
h->next=s;
if(h==L.tail)
L.tail=h->next;
L.len++;
return ok;

}

Status ListOperation::DelFirst(LinkList &L,Link h,Link &q)
{
if(!L.head)
{
cout<<"线性链表不存在"<<endl;
return error;
}
q=h->next->next;;
if(h->next==L.tail)
L.tail=L.head;
delete h->next;
h->next=q;
L.len--;
return ok;
}

Status ListOperation::Append(LinkList &L,Link s)
{
L.tail->next=s;
while(L.tail->next!=NULL)
{
L.len++;
L.tail=L.tail->next;
}
return ok;
}

Status ListOperation::Remove(LinkList &L,Link &q)
{
if(!L.head)
{
cout<<"线性链表不存在"<<endl;
return error;
}
q=L.head;
while(q->next!=L.tail)
{
q=q->next;
}
L.tail=q;
q=q->next;
L.tail->next=NULL;
L.len--;
delete q;
q=NULL;
return ok;
}

Status ListOperation::InsBefore(LinkList &L,Link &p,Link s)
{
Link q=L.head;
if(!L.head)
{
cout<<"线性链表不存在"<<endl;
return error;
}
while(q->next!=p)
{
q=q->next;
}
q->next=s;
s->next=p;
p=s;
L.len++;
return ok;
}

Status ListOperation::InsAfter(LinkList &L,Link &p,Link s)
{
if(!L.head)
{
cout<<"线性链表不存在"<<endl;
return error;
}
s->next=p->next;
p->next=s;
if(p==L.tail)//空链表
L.tail=L.tail->next;
p=s;
L.len++;
return ok;
}

Status ListOperation::SetCurElem(Link &p,ElemType e)
{
p->data=e;
return ok;
}

ElemType ListOperation::GetCurElem(Link p)
{
return p->data;
}

bool ListOperation::ListEmpty(LinkList L)
{
if(!L.head)
{
cout<<"线性链表不存在"<<endl;
return error;
}
if(L.head->next==NULL)
return true;
else
return false;
}

int ListOperation::ListLength(LinkList L)
{
if(!L.head)
{
cout<<"线性链表不存在"<<endl;
return error;
}
return L.len;
}

Position ListOperation::GetHead(LinkList L)
{
if(!L.head)
{
cout<<"线性链表不存在"<<endl;
return error;
}
return L.head;
}
Position ListOperation::GetLast(LinkList L)
{
if(!L.head)
{
cout<<"线性链表不存在"<<endl;
return error;
}
return L.tail;
}

Position ListOperation::PriorPos(LinkList L,Link p)
{
Link q=L.head;
if(!L.head)
{
cout<<"线性链表不存在"<<endl;
return error;
}
if(p==L.head)
return NULL;
while(q->next!=p)
{
q=q->next;
}
return q;
}

Position ListOperation::NextPos(LinkList L,Link p)
{
if(!L.head)
{
cout<<"线性链表不存在"<<endl;
return error;
}
if(p==L.tail)
return NULL;
return p->next;
}

Status ListOperation::LocatePos(LinkList L,int i,Link q)
{
int j=0;
Link pt=L.head;
while(pt&&j<i)
{
pt=pt->next;
j++;
}
if(!pt||j>i)
return error;
else
{
/*if(p==L.tail)
GetLast(L);
else
PriorPos(L,p->next);
return ok;*/
q=pt;
return ok;
}
}

Status compare(ElemType x,ElemType y)
{
if(x==y)
return ok;
else
return error;
}
Position ListOperation::LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType ,ElemType))
{
Link q=L.head->next;
while(q->next!=NULL)
{
if(compare(q->data,e))
return q;
q=q->next;
}
return NULL;
}

Status visit(ElemType x)
{
cout<<x<<" ";
return ok;
}
Status ListOperation::ListTraverse(LinkList L,Status(*visit)(ElemType))
{
Link q=L.head->next;
while(q)
{
if(visit(q->data))
q=q->next;
else
return error;
}
return ok;
}
void main()
{
ListOperation LOP;
LinkList L,L1;
Link p,s,q;
cout<<"***************构造一个线性链表L****************"<<endl;
LOP.InitList(L);
for(int j=1;j<5;j++)
{
LOP.MakeNode(p,j);
LOP.InsFirst(L,L.head,p);
}
if(LOP.ListEmpty(L))
cout<<"链表L构造不成功"<<endl;
cout<<"链表L中数据元素的个数num: "<<LOP.ListLength(L)<<endl;
Status (*vis)(ElemType);
vis=visit;
cout<<"依次输出链表L中的数据元素：";
LOP.ListTraverse(L,vis);
cout<<endl;
cout<<endl;

cout<<"****************将链表L1连接在链表L后****************"<<endl;
LOP.InitList(L1);
for(int j=5;j<10;j++)
{
LOP.MakeNode(p,j);
LOP.InsFirst(L1,L1.head,p);
}
if(LOP.ListEmpty(L1))
cout<<"链表L1构造不成功"<<endl;
LOP.Append(L,L1.head->next);
cout<<"新链表L中数据元素的个数num: "<<LOP.ListLength(L)<<endl;
cout<<"依次输出新链表L中的数据元素：";
LOP.ListTraverse(L,vis);
cout<<endl;
cout<<endl;

cout<<"*******************对链表L1进行各种基本操作********************"<<endl;
cout<<"依次输出链表L中的数据元素：";
LOP.ListTraverse(L1,vis);
cout<<endl;
cout<<"操作1：删除L1的第一个结点:"<<endl;
LOP.DelFirst(L1,L1.head,q);
cout<<"依次输出链表L1中的数据元素：";
LOP.ListTraverse(L1,vis);
cout<<endl;
cout<<"\n"<<"操作2：删除L1的尾结点："<<endl;
LOP.Remove(L1,q);
cout<<"依次输出链表L1中的数据元素：";
LOP.ListTraverse(L1,vis);
cout<<"\n"<<"tail->data:"<<L1.tail->data<<endl;
cout<<"]n"<<"操作3：在p所指链表L1中结点之前，插入结点s："<<endl;
LOP.MakeNode(s,20);
p=L1.head->next->next;
cout<<"插入之前p指向结点的数据元素："<<p->data<<endl;
LOP.InsBefore(L1,p,s);
cout<<"依次输出链表L1中的数据元素：";
LOP.ListTraverse(L1,vis);
cout<<"\n"<<"插入之后p指向结点的数据元素："<<p->data<<endl;
cout<<"\n"<<"操作4：在p所指链表L1中结点之后，插入结点s："<<endl;
LOP.MakeNode(s,30);
LOP.InsAfter(L1,p,s);
cout<<"依次输出链表L1中的数据元素：";
LOP.ListTraverse(L1,vis);
cout<<"\n"<<"插入之后p指向结点的数据元素："<<p->data<<endl;
cout<<"\n"<<"操作5：返回结点位置："<<endl;
cout<<"  链表L1头结点位置"<<LOP.GetHead(L1)<<endl;
cout<<"  链表L1尾结点位置"<<LOP.GetLast(L1)<<endl;
cout<<"  链表L1头结点的前驱"<<LOP.PriorPos(L1,L1.head)<<endl;
cout<<"  链表L1尾结点的后继"<<LOP.NextPos(L1,L1.tail)<<endl;
cout<<"  链表L1第2个结点的前驱位置"<<LOP.PriorPos(L1,L1.head->next->next)<<endl;
cout<<"  链表L1第2个结点的后继位置"<<LOP.NextPos(L1,L1.head->next->next)<<endl;
cout<<"  链表L1第1个结点的位置"<<LOP.LocatePos(L1,3,q)<<":"<<L1.head->next<<endl;
cout<<"\n"<<"操作6：返回链表L1中第一个与e满足compare（）关系的结点："<<endl;
Status (*comp)(ElemType,ElemType);
comp=compare;
cout<<LOP.LocateElem(L1,8,comp)<<endl;
cout<<"\n"<<"操作7：清空链表L1 清空/未清空（1/0）：";
cout<<LOP.ClearList(L1)<<endl;
cout<<"\n"<<"操作8：销毁链表L1 销毁/未销毁（1/0）：";
cout<<LOP.DestroyList(L1)<<endl;
}