数据结构伪C代码:2.线性表

//算法2.1
void uniun(List &La,List Lb)
{
  La_len=ListLength(La);//线性表的长度
  Lb_len=ListLength(Lb);
  for(int i=1;i<La_len;i++)
  {
     GetElem(Lb,i,e);//取Lb中第i个元素，把值赋给e
     if(!LocateElem(La,e,equal))
     ListInsert(La,++La_len,e);//La中不存在和e相同的数据元素，则插入
  }
}
//算法2.2
void MergrList(List La,List Lb,List &c)
{
   //已知线性表La和Lb中的数据元素按值非递减排列
   //归并La和Lb得到新的线性表Lc,Lc的数据元素按值非递减排列
   InitList(Lc);
   int i=j=1;
   int k=0;
   La_len=ListLength(La);
   Lb_len=ListLength(Lb);
   while((i<La_len)&&(j<Lb_len))
     {
         GetElem(La,i,ai);
         GetElem(Lb,j,bj);
         if(ai<=bj)
           {
            ListInsert(Lc,++k,ai);
            i++;
           }
         else
           {
            ListInsert(Lc,++k,bj);
            j++;
           }  
     }
   while(i<=La_len)
   {
      GetElem(La,i++,ai);
      ListInsert(Lc,++k,ai);
   }
   while(j<=Lb_len)
   {
      GetElem(Lb,j++,bj);
      ListInsert(Lc,++k,bj);
   }  
}
//算法2.3
#define ListInitSize  100//线性表存储空间的初始分量
#define ListIncrement 10//线性表存储空间的分配增量
typedef int ElemType;
typedef int status;
typedef struct{
	  ElemType *elem;
	  int length;
	  int listsize;
	}Sqlist;
status InitList_Sq(Sqlist &L){
	 L.elem=(ElemType *)malloc(ListInitSize*sizeof(ElemType));
	 if(!L.elem)
	 	exit(OVERFLOW);
	 	L.length=;
	 	L.listsize=ListInitSize;
	 	return OK;
	}
//算法2.4 时间复杂度O(n)
status ListInsert_Sq(SqList &L,int i,ElemType e){
   //在顺序线性表中第i个位置之前插入新的元素e
   //i的合法位置1<=i<=ListLength_Sq(L)+1
   if(i<1||i>L.lengrh+1)
   	return ERROR;
   if(L.length>=L.listsize){
   	  newbase=(ElemType *)realloc(L.elem,(L.listsize+ListIncrement)*sizeof(ElemType));
   	  if(!newbase)
   	  	 exit(OVERFLOW);
   	  L.elem=newbase;
   	  L.listsize+=ListIncrement;
   	}   	
   	q=&(L.elem[i-1]);//q为插入位置
   	for(p=&(L.elem[L.length-1];p>=q;--p)
   	  *(p+1)=*p;
   	  *q=e;
   	  L.length++;
   	  return ok;
}
//算法2.5 时间复杂度O(n)
status ListDelete_Sq(Sqlist &L,int i,ElemType &e){
	 //在顺序线性表L中删除第i个元素，并用e返回其值
	 //i的合法位置1<=i<=ListLength_Sq(L)
	 if(i<1||i>L.length)
	 	return error;
	 	p=&L.elem[i-1];
	 	e=*p;
	 	q=L.elem+L.length-1;//q=L.elem[L.length-1];
	 	for(;p<=q;p++)
	 	  *p=*(p+1);
	 	L.length--;
	 	return ok;
	}
//算法2.6 
int LocationElem_Sq(SqList &L,ElemType e,status (*compare)(ElemType,ElemType)){
    //在顺序线性表L中查找第一个值与e满足compare()的元素的位序
    //若找到返回其在L中的位序，否则返回0
    i=1;
    p=L.elem;
    while(i<=L.length&&!(*compare(*p++,e))
       i++;
    if(i<=L.length)
    	return i;
    else 
    	return 0;	
	}
//算法2.7
void MergeList_Sq(SqList La,SqList Lb,SqList &Lc){
	  //已知顺序线性表La和Lb的元素按值非递减排列
	  //归并La和Lb得到新的顺序线性表Lc,Lc的元素也按值的非递减顺序排列
	  pa=La.elem;
	  pb=Lb.elem;
	  Lc.listsize=Lc.length=La.length+Lb.length;
	  Lc=Lc.elem=(ElemType *)malloc(Lc.listsize*sizeof(ElemType));
	  if(!Lc.elem)
	  	exit(OVERFLOW);
	  pa_last=La.length-1;
	  pb_last=Lb.length-1;
	  while(pa<=pa_last&&pb<=pb_last){
	  	if(*pa<*pb)
	  		  *pc++=*pa++;	    	
	  	else
	  		  *pc++=*pb++	  
	  	}
	  while(pa<=pa_last)
	    *pc++=*pa++;
	  while(pb<pb_last)
	    *pc++=*pb++;
	}
//--------- 线性表的单链表存储结构
typedef struct LNode{
  ElemType data;
  struct LNode *next;
}LNode,*LinkList;
//算法2.8
status GetElem_L(LinkList L,int i,ElemType &e){
	  //L为带头结点的单链表的头指针
	  //当第i个元素存在时，其值赋给e并返回ok，否则返回ERROR
	  p=L->next;
	  int j=1;
	  while(p&&j<i){
	  	  p=p->next;
	  	  j++;
	  	}
	  if(!p||j>i)
	  	return ERROR;
	  e=p->data;
	  return ok;
	}
//算法2.9
status ListInsert_L(LinkList &L,int i,ElemType e){
	  //在带头结点的单链表L中第i个位置之前插入元素e
	  p=L;
	  int j=0;
	  while(p&&j<i-1){
	  	  p=p->next;
	  	  j++;
	  	}
	  if(!p||j>=i)
	  	return ERROR;
	  s=(LinkList)mallac(sizeof(LNode));
	  s->data=e
	  s->next=p->next;
	  p->next=s;
	  return ok;
	}
//算法2.10
status ListDelete_L(LinkList &L,int i,ElemType &e){
	  //在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
	  LNode * p=L;
	  int j=0;
	  while(p&&j<i-1){
	  	  p=p->next;
	  	  j++;
	  	}
	  if(!p||j>i-1)
	  	return ERROR;
	  q=p->next;
	  e=q->data;
	  p->next=q->next;//p->next=p->next->next;
	  free(q);
	  return ok;
	}
//算法2.11
void CreateList_L(LinkList &L,int n){
//逆位序输入n个元素的值，建立带表头结点的单链线性表L
//先插入的在表尾，后插入的在表头
	  L=(LinkList)malloc(sizeof(LNode));
	  L->next=NULL;
	  for(i=n;i>0;i--){
	  	  p=(LinkList)malloc(sizeof(LNode));
	  	  scanf("%ElemType",&p->data);
	  	  p->next=L->next;
	  	  L->next=p;
	  	}
	}
//算法2.12
void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc){
//已知单链线性表La和Lb的元素按值非递减排列
//归并La和Lb得到新的单链线性表Lc，Lc的元素也按非递减排列
    pa=La->next;
    pb=Lb->next;
    Lc=pc=La;
    while(pa&&pb){
    	  if(pa->data<=pb->data){
    	  	  pc->next=pa;
    	  	  pc=pa;
    	  	  pa=pa->next;
    	  	}
    	  else{
    	  	  pc->next=pc;
    	  	  pc=pb;
    	  	  pb=pb->next;
    	  	}
    	}
    pc->next=pa?pa:pb;
    	free(Lb);
	}
//--------线性表的静态单链表存储结构-----------
#define MAXSIZE 1000 //链表的最大长度
typedef struct {
	  ElemType data;
	  int cur;
	}component,SLinkList[MAXSIZE];
//算法2.13
int LocateElem_SL(SLinkList S,ElemType e){
	//在静态单链线性表S中查找第一个值为e的元素
	//若找到，则返回它在S中的位序，否则返回0
	  i=s[0].cur;
	  while(i&&S[i].data!=e)
	     i=S[i].cur;
	  return i;
	}
//算法2.14
void InitSpace_SL(SLinkList &space){
	//将一位数组space中各分量链成一个备用链表，space[0].cur为头指针
	//“0”表示空指针
	   for(i=0;i<MAXSIZE-1;i++)
	      space[i].cur=i+1;
	   space[MAXSIZE-1].cur=0;
	}
//算法2.15
int Malloc_SL(SLinkList &space){
	//若备用空间链表非空，则返回分配的结点下标，否则返回0
	i=space[0].cur;
	if(space[0].cur)
		 space[0].cur=space[i].cur;
	return i;
	}
//算法2.16
void Free_SL(SLinkList &space,int k){
	//将下标为k的空闲结点回收到备用链表 
	  space[k].cur=space[0].cur;
	  space[0].cur=k;
	}
//算法2.17
void difference(SLinkList &space,int &S){
	//依次输入集合A和B的元素，在一维数组space中建立表示集合（A-B)U(B-A)的静态链表，S为其头指针；
	//假设备用空间足够大，space[0].cur为其头指针
	    InitSpace_SL(space);
	    S=Malloc_SL(space);
	    r=s;                         //r指向S的当前最后结点
	    scanf(m,n);                  //输入A和B的元素个数
	    for(j=1;j<=m;j++){           //建立集合A的链表
	    	   i=Malloc_SL(space);
	    	   scanf(space[i].data);
	    	   space[r].cur=i;
	    	   r=i;                    //插入到表尾
	    	}    
	    space[r].cur=0;
	    for(j=1;j<=n;j++){
	    	   scanf(b);
	    	   p=S;
	    	   k=space[S].cur;         //k指向集合A中第一个结点
	    	   while(k!=space[r].cur&&space[k].data!=b){
	    	   	    p=k;
	    	   	    k=space[k].cur;
	    	   	}
	    	  if(k==space[r].cur){
	    	      i=Malloc_SL(space);
	    	      space[i].data=b;
	    	      space[i].cur=space[r].cur;
	    	      space[r].cur=i;	
	    	  	}
	    	  else{
	    	  	  space[p].cur=space[k].cur;
	    	  	  Free_SL(space,k);
	    	  	  if(r==k)
	    	  	  	r=p;               //删除的是r所指结点，则需修改尾指针
	    	  	}
	    	}
	}
//------------线性表的双向链表存储结构-----------------
typedef struct DuLNode{
	  ElemType data;
	  struct DuLNode *prior;
	  struct DuLNode *next;
	}DuLNode,*DuLinkList;
//算法2.18
status ListInsert_DuL(DuLinkList &L,int i,ElemType e){
	//在带头结点的双链循环线性表L中第i个位置之前插入元素e
	//i的合法范围为1<=i<=表长+1
	   if(!(p=GetElemP_DuL(L,i)))
	   	return ERROR;
	   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;
	}
//算法2.19
status ListDelete_DuL(DuLinkList &L,int i;ElemType &e){
	//删除带头结点的双链循环线性表L的第i个元素，
	//i的合法范围为1<=i<=表长
	   if(!(p=GetElemP_DuL(L,i)))
	   	 return ERROR;
	   e=p->data;
	   p->prior->next=p->next;
	   p->next->prior=p->prior;
	   free(p);
	   return ok;
	}
//-------------带头结点的线性链表类型定义----------------------
typedef struct LNode{     //节点类型
	   ElemType data;
	   struct LNode *next;
	}*Link,*Position;

typedef struct {         //链表类型
    Link  head,tail;     //分别指向线性链表中的头结点和最后一个节点
    int   len;	         //指示线性链表中数据元素的个数
	}LinkList;
//算法2.20
status ListInsert_L(LinkList &L,int i,ElemType e){
	//在带头结点的单链线性表L的第i个元素之前插入元素e
	   if(!LocatePos(L,i-1,h))
	   	  return ERROR;
	   if(!MakeNode(s,e))
	   	  return ERROR;
	   InsFirst(h,s);
	}
//算法2.21
status MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc,int (*compare)(ElemType,ElemType)){
	//已知单链线性表La和Lb的元素按值非递减排列
  //归并La和Lb得到新的单链线性表Lc，Lc的元素也按非递减排列
    if(!InitList(Lc))
  	    return ERROR;
  	ha=GetHead(La);
  	hb=GetHead(Lb);
  	pa=NextPos(La,ha);
  	pb=NextPos(Lb,hb);
  	while(pa&&pb){
  		   a=GetCurElem(pa);
  		   b=GetCurElem(pb);
  		   if((*compare)(a,b)<=0){
  		   	  DelFirst(ha,q);
  		   	  Append(Lc,q);
  		   	  pa=NextPos(La,ha);
  		   	}
  		   else{
  		   	  DelFirst(hb,q);
  		   	  Append(Lc,q);
  		   	  pb=NextPos(Lb,hb);
  		   	}  		   
  		}  
  	if(pa) Append(Lc,pa);
  		else Append(Lc,pb);
  	FreeNode(ha);
  	FreeNode(hb);
  	return ok;
	}	
//-------------------抽象数据类型Polynomial的实现——————————————————
typedef struct {   //项的表示，多项式的项作为LinkList的数据元素
	  float coef;    //系数
	  int   expn;    //指数
	}term,ElemType;
typedef LinkList polynomial;
//算法2.22
void CreatePolyn(polynomial &p,int m){
	//输入m项的系数和指数，建立表示一元多项式的有序链表P
	   InitList(P);
	   h=GetHead(p);
	   e.coef=0.0;
	   e.expn=-1;
	   SetCurElem(h,e)     //设置头结点的数据元素
	   for(i=1;i<=m;i++){
	   	   scanf(e.coef,e.expn);
	   	   if(!LocateElem(P,e,q,(*cmp)())){
	   	   	   if(MakeNode(s,e))
	   	   	   	 InsFirst(q,s);
	   	   	}
	   	}
	}
//算法2.23
void AddPloyn(polynomial &pa,polynomial &pb){
	//多项式的加法：pa=pa+pb,利用两个多项式的结点构成“和多项式"
	    ha=GetHead(pa);
	    hb=GetHead(pb);
	    qa=NextPos(pa,ha);
	    qb=NextPos(pb,hb);
	    while(qa&&qb){
	    	    a=GetCurElem(qa);
	    	    b=GetCurElem(qb);
	    	    switch((*cmp)(a,b)){
	    	    	   case -1:
	    	    	   	 ha=qa;
	    	    	   	 qa=NextPos(pa,ha);
	    	    	   	 break;
	    	    	   case 0:
	    	    	   	sum=a.coef+b.coef;
	    	    	   	if(sum!=0){
	    	    	   		  SetCurElem(qa,sum);
	    	    	   		  ha=qa;
	    	    	   		}
	    	    	    else{
	    	    	    	  DelFirst(ha,pa);
	    	    	    	  FreeNode(qa);
	    	    	    	}
	    	    	    DelFirst(hb,qb);
	    	    	    FreeNode(qb);
	    	    	    qb=NextPos(pb,hb);
	    	    	    qa=NextPos(pa,ha);
	    	    	    break;
	    	    	  case 1:
	    	    	  	DelFirst(hb,qb);
	    	    	  	InsFirst(ha,qb);
	    	    	  	qb=NextPos(pb,hb);
	    	    	  	ha=NextPos(pa,ha);
	    	    	  	break;
	    	    	}
	    	}
	    if(!ListEmpty(pb))
	    	  Append(pa,qb);
	    FreeNode(hb);
	}