数据结构二——线性表

顺序表

Status ListInsert_Sq(SqList &L, int i, ElemType e) {
// 在顺序表L的第 i 个元素之前插入新的元素e,
// i 的合法范围为  1 ≤ i ≤ L.length+1
q = &(L.elem[i-1]);                 // q 指示插入位置
for (p = &(L.elem[L.length-1]); p >= q;  --p) //p地址 
     *(p+1) = *p;       // 插入位置及之后的元素右移
*q = e;       // 插入e
++L.length;   // 表长增1
return OK;
} // ListInsert_Sq                         
//算法时间复杂度：O(ListLength(L))

Status ListDelete_Sq(SqList &L, int i, ElemType &e) 
{
	if ((i < 1) || (i > L.length)) //删除位置不合法
		return ERROR;                           
	p = &(L.elem[i-1]);         // p 为被删除元素的位置
	e = *p;                    // 被删除元素的值赋给 e
	q = L.elem+L.length-1;    // 表尾元素的位置
	for (++p; p <= q; ++p)  
		*(p-1) = *p;        // 被删除元素之后的元素左移
	--L.length;            // 表长减1
	return OK;
} // ListDelete_Sq

习题1

void merge(int m, int n, int a[], int b[], 
                   int &s, int c[]){
    int p = 0, q = 0, s = 0;
    while (p < m && q < m){
	if (a[p] < b[q]) c[s++] = a[p++];
        else c[s++] = b[q++];
    }
    while (p < m) c[s++] = a[p++];
    while (q < n) c[s++] = b[q++];
}

更难的课后习题


这个之后假期有时间在更~~

链表

LNode * create_LinkList()//头插
{
	LNode * head, *p;
	head= (LNode  *) malloc( sizeof(LNode));
	head->next=NULL;   //  创建链表的表头结点
	for (int i = 0; i < n; i++){
    	int a;  
    	scanf(“%d”, &a) ;
		p= (LNode  *)malloc(sizeof(LNode));
		p–>data=a;     //  数据域赋值
		p–>next=head–>next ;  
		head–>next=p ;  // 钩链
	}
	return head;    // 返回head
}

LNode  * create_LinkList() //尾插
{
	LNode *head, *p, *q;
	head=p=(LNode  *)malloc(sizeof(LNode)); 
	p->next=NULL;     //  创建单链表的表头结点
	for (int i = 0; i < n; i++)
	{
    	int a;  
    	scanf(“%d”,& a);
		q= (LNode  *)malloc(sizeof(LNode)); 
		q–>data=a;     //  数据域赋值
		q–>next=NULL;  p–>next=q; //钩链
		p=q;
	}	
	return head;   // 返回head
} 

ElemType   Get_Elem(LNode *L ， int  i)//返回L的第i个元素值到e
{
    int j ;   
    LNode *p;
	p=L->next;  j=1;      /*  使p指向第一个结点  */
	while  (p!=NULL && j<i)
	{   
		p=p–>next;  
		j++;  
	}        /*  移动指针p , j计数  */
	if  (j!=i)  return fail;
	else    return(p->data);
}

LNode *LocateElem(LNode *L，int key)//查找值为key的第一个结点
{
    LNode *p=L–>next;
	while  ( p!=NULL&& p–>data!=key)    p=p–>next;
	if  (p==NULL) printf(“所查结点不存在!\n”); 
	return p;
} // 运行时间与key有关，平均时间复杂度为O(n)。

void  Insert_LNode(LNode *L，int i，ElemType e)
   /*  在以L为头结点的单链表的第i个位置插入值为e的结点 */ 
{   int  j=0;  
	LNode *p，*q;
	p=L;
	while  ( p!=NULL&& j<i-1) 
	{  
		p=p–>next; 
		j++;   
	}
	if  (j!=i-1)     printf(“i太大或i为0!!\n ”); 
	else
	{  
		q=(LNode *)malloc(sizeof(LNode));
		q–>data=e;   
		q–>next=p–>next;  
		p–>next=q;
	}
}

void  Delete_LinkList(LNode *L， int i)
  /*  删除以L为头结点的单链表中的第i个结点  */ 
{  
	int  j=1;  
	LNode *p =L ，*q =L->next;
	while  ( p->next!=NULL&& j<i) 
	{  
		p=q;  
		q=q–>next;  
		j++;  
	}
	if  (j!=i)     printf(“i太大或i为0!!\n ”);  
	else    
	{  
		p–>next=q–>next;   
		free(q);    
	}
}

void  Delete_LinkList(LNode *L，int key)//按值删除第一个
{     
	LNode *p=L,  *q=L–>next;
	while  ( q!=NULL&& q–>data!=key)     
	{  
		p=q;  
		q=q–>next;   
	}
	if  (q–>data==key)   
	{  
		p->next=q->next;  
		free(q);   
	}
	else  
		printf(“所要删除的结点不存在!!\n”);
} 

void  Delete_Node_value(LNode *L)
/*  删除以L为头结点的单链表中所有值相同的结点  */ 
{     
	LNode *p=L->next, *q, *ptr; 
	while  ( p!=NULL)   /*  检查链表中所有结点  */ 
	{   
		*q=p, *ptr=p–>next;
	/*  检查结点p的所有后继结点ptr  */
		while (ptr!=NULL)
     	{  
     		if (ptr–>data==p->data) 
            {  	
            	q->next=ptr->next;  
            	free(ptr);  
                ptr=q->next;  
            }
        	else  
        	{  
        		q=ptr;  
        		ptr=ptr–>next;   
        	}
     }
	p=p->next ;
	}
} 


LNode  *Merge_LinkList(LNode *La， LNode *Lb)
{    
	LNode *Lc,  *p ,  *q ,  *s,*ptr;
	Lc=La ;  s=La  ;    p=La->next ;  q=Lb->next  ;
 	while (p!=NULL	&& q!=NULL)
  		if  (p->data < q->data)
    	{   s->next=p ;  s=p ;   p=p->next ;   }
		if  (p->data > q->data)
    	{   s->next=q ;  s=q ;   q=q->next;     }
		if  (p->data==q->data)
    	{   s->next=p ;  s=p ;   p=p->next  ; ptr=q ; q=q->next ; free(ptr); }
	/*  将pa所指的结点合并，pb所指结点删除  */
}
 	if  (p!=NULL)  s->next=p ; else s->next=q ;     
	free(Lb) ;
	return(Lc) ;
}  //    算法分析   O(m+n) 。


//双向链表
void ins_dulist(JD* p,int x)
{
	JD *s;
  	s=(JD*)malloc(sizeof(JD));
  	s->element=x;
  	s->prior=p->prior;
  	p->prior->next=s;
  	s->next=p;
  	p->prior=s;
}

void del_dulist(JD *p)
{
	p->prior->next=p->next;
  	p->next->prior=p->prior;
  	free(p);
}


//应用举例:一元多项式的表示及相加

void  add_poly(JD *pa,JD *pb)
{  JD *p,*q,*u,*pre;
   int x;
   p=pa->next;
   q=pb->next;
   pre=pa;
   while((p!=NULL) && (q!=NULL))
   {   if(p->exp<q->exp)
       {   pre=p;  p=p->next;}
       else if(p->exp==q->exp)
       {  
       		x=p->coef+q->coef;
          	if(x!=0){ p->coef=x;  pre=p;}
          	else{ pre->next=p->next;  free(p);}
            p=pre->next;
          	u=q;
          	q=q->next;
          	free(u);
       }
       else
       {   
       		u=q->next;q->next=p;
           	pre->next=q;
            pre=q;  q=u;
       }
    }
    if(q!=NULL)
        pre->next=q;
    free(pb);
}