链式存储结构的线性表基本实现

/// 
//--------------------------------------------------------- 
//            链式存储结构的线性表基本操作 
// 
//            a simple example of Link_List by C language 
// 
//                    by wilson Sep.4.2012 
//--------------------------------------------------------- 
/// 


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

//以下为函数运行结果状态代码 

#define TRUE 1
#define FALSE 0
#define OK 1 
#define ERROR 0 
#define INFEASIBLE -1 
#define OVERFLOW -2 

typedef int Status;         //函数类型，其值为为函数结果状态代码 

typedef int ElemType;      //假设数据元素为整型 

//实现线性表的顺序存储结构的类型定义

typedef struct LNode       //定义结点类型
{ 
    ElemType date;           //结点数据域 
 struct LNode *next;      //结点指针域

}LNode,*Linklist; 


///
//函数名：InitList()    {结构初始化}
//参数：
//初始条件：无
//功能：用尾部插入法插建立一个带有头结点和尾结点的链表,结点个数为n
//返回值：存储分配失败：ERROR
//        存储分配成功：返回头结点
///
Status InitList(void)
{
 Linklist head,tail,p;
 int e,len;
 len=0;
 head=(Linklist)malloc(sizeof(LNode));
 if(head==NULL) return ERROR;
 tail=head;
 tail->next=NULL;
 if(p!=NULL)
 {
  p=(Linklist)malloc(sizeof(LNode));
  scanf("%d",&e);
  p->date=e;
  p->next=tail->next;
  tail->next=p;
  tail=p;
  p=p->next;
  ++len;
 }
 return OK;
}

///
//函数名：DestroyList()    {结构初始化}
//参数：Linklist L
//初始条件：链表存在
//功能：销毁线性表
//返回值：存储分配失败：ERROR
//        存储分配成功：OK
///
Status DestroyList(Linklist head) 
{
 Linklist p=NULL;
 if(head==NULL) return ERROR;
 p->next=head->next;
 head->next=p;
 free(p);
 return OK;
}
///
//函数名：GetElemlist()    
//参数：Linklist L，int i,ElemType e
//初始条件：链表存在
//功能：当第i个元素存在时，其值赋给e
//返回值：失败：ERROR
//        成功：返回第i个位置元素指针
///
Linklist GetElemlist(Linklist L,int i)
{
 Linklist p;
 int j=1;
 while(p&&j<i)
 {
  p=p->next;
  j++;
 }
 if(!p||j>i) return ERROR;
 return p;
}
///
//函数名：ListLength()    
//参数：Linklist L，int i
//初始条件：链表存在
//功能：求链表的结点个数
//返回值：失败：ERROR
//        成功：返回结点个数
///
int ListLength(Linklist L)
{
 Linklist p;
 int i=0;
 if(L==NULL)return ERROR;
 p=L;
 while(p!=NULL)
 {
  p=p->next;
  i++;
 }
 return i;
}
///
//函数名：ListPrint()    
//参数：Linklist L
//初始条件：链表存在
//功能：打印链表
//返回值：失败：ERROR
//        成功：OK
///
Status ListPrint(Linklist L) 
{
 Linklist p;
 p=L;
 if(p=NULL) return ERROR;
 printf("输出结点数据%3d",p);
 p=p->next;
 return OK;
}
 
///
//函数名：ListInsert()    
//参数：Linklist L，int i,ElemType e
//初始条件：链表存在
//功能：在第i个结点前插入元素E
//返回值：插入失败：ERROR
//        出入成功：OK
///
Status ListInsert(Linklist &L,int i,ElemType e)
{
 Linklist s,p;
 p=GetElemlist(L,i-1);
 if(p)
 {
  s=(Linklist)malloc(sizeof(LNode));
  s->date=e;
  s->next=p->next;
  p->next=s;
 }
 return OK;
}

///
//函数名：ListDelete()    
//参数：Linklist L，int i,ElemType e
//初始条件：链表存在
//功能：删除链表中的第i个元素
//返回值：删除失败：ERROR
//        删除成功：删除元素
///
ElemType ListDelete(Linklist &L,int i,ElemType e)
{
 Linklist p,q;
 p=GetElemlist(L,i-1);           //找到第i个元素的位置,并令p指向其前驱
 if(!(p->next))
 {
  q=p->next;
  p->next=q->next;
  e=q->date;
  free(q);
  return e;
 }
 else return ERROR;
}
///
//函数名：ListMerge()    
//参数：Linklist La,Lb,Lc
//初始条件：链表La,Lb存在
//功能：La,Lb按从小到大的顺序排列，将La,Lb合并到Lc中按从小到大的顺序输出
//返回值：删除失败：ERROR
//        删除成功：OK
///

Status ListMerge(Linklist La,Linklist Lb,Linklist Lc)
{
 Linklist pa,pb,pc;
 pa=La; pb=Lb;
 Lc=pc=La;
 if(pa&&pb)return ERROR;
 while(pa&&pb)
 {
  if(pa->date<=pb->date)
  {
   pc->next=pa;
   pc=pa;
   pa=pa->next;
  }
  else
  {
   pc->next=pb;
   pc=pb;
   pb->next;
  }
 }
 pc->next=pa?pa:pb;
 ListPrint(Lc);
 return OK;
}

///
//函数名：ListReverse()    
//参数：Linklist L
//初始条件：链表L存在
//功能：将链表逆转
//返回值：删除失败：ERROR
//        删除成功：OK
///
Status ListReverse(Linklist L)
{
 Linklist p1,p2,p3;
 if(L&&L->next) return ERROR;
 p1=L->next;
 p2=p1->next;
 p1->next=NULL;
 if(p2!=NULL)
 {
  p3=p2->next;
  p2->next=p1->next;
  p1=p2;
  p2=p3;
 }
 L->next=p1;
 return OK;
}