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

//算法2.1
void uniun(List &La,List Lb)
{
  La_len=ListLength(La);//线性表的长度
  Lb_len=ListLength(Lb);
  for(int i=1;iL.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(pbnext;
	  int j=1;
	  while(p&&jnext;
	  	  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&&jnext;
	  	  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&&jnext;
	  	  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;idata=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);
	}