线性表算法

1. 在一个递增的顺序表中插入一个元素，并保持有序.

     分析:  判断顺序表是否满, 满了则追加空间.   从表中的最后一个元素开始，寻找插入位置，找到则插入，表长增一

int ListInsert_sq(Sqlist *L, int ele)
{
   int k;
   if(L->listsize <=L->length)
   {
      L->slist=(int *)realloc(L->slist,(L->listsize+INCREM)*sizeof(int));
      if(!L->slist) return ERROR;
      L->listsize +=INCREM; 
   }
   for(k=L->length-1;k>=0&&L->slist[k]>e;k--)
   {

      L->slist[k+1] = L->slist[k];
   }
    
    L->slist[k+1] =e;
    L->length++;
    return OK;
}

2.  给一个带头节点的单链表，利用原有节点将单链表逆置

   分析: 将原链表断开成两个部分, 第一部分包含头节点，第二部分包含剩余节点，循环，将第二部分的每个节点逐个插入

             第一部分头节点的后面;

    

void  invert(LinkList H)
{

  LinkList q,r=H;
   q=H->next;
   H->next=NULL;
   while(q){
          r=q;   
          q=q->next;     
           
           r->next=H->next;      
           H->next=r;       

   }
  
}

  3.  将两个有序表合并. 设有两个递增排列的有序表,和并后， 仍递增有序.

分析: 可以通过依次取出两个表中的第一个元素进行比较，从中得到值较小的元素，放入结果有序表中的第一个位置；

  然后将上次比较大的元素与另一个表的第二个元素继续比较，得到值较小的元素，放入结果有序表中的第二个位置

... 以此类推，将两个表中的所有元素逐个放入结果有序表位置.

//顺序表
int merge(Sqlist *a,Sqlist *b, Sqlist *c)
{

  int i=0,j==0,k=0;
  if(c->listsize<(a->length+b->length))
  {

     c->slist=(int *)realloc(c->slist,(c->listsize+INCREM)*sizeof(int));
     if(!c->slist) return ERROR;
     c->listsize += INCREM ;
  }
  while(i < a->length &&j length)
  {  
     if(a->slist[k] = a->slist[i])
     {
       c->slist[k] = b->slist[j];
       i++;
       k++;
     }else{
         c->slist[k] = b->slist[j];   
         j++;
         k++;
     }

  }
  while(ilength)
  { 
     c->slist[k] = a->slist[i];
      i++;
     
  }
  while(jlength)
  {
    c->slist[k] = b->slist[j];
    j++;
    k++;
  }
  c->length=k;
  return OK;

}
//hc链表，不带头节点
LNode * Merge(LNode *ha, LNode *hb)
{
   LNode *hc,*p,*q,*r;
   p=ha->next;
   q=hb->next;
   if(p->datadata)
   {
        p =p->next;
        hc=ha;

   }else if(p->data>q->data){

     q= q->next;
     hc= hb;
   }
   if(p->data==q->data){
     p =p->next;
     q= q->next;
     hc=ha;

   }
   r = hc-> next;
    while(p&&q)
    {
       if(p->datadata){
           r->next=p;
           r=p;
           p=p->data;
       }else if(p->data>q->data){
             r->next = q;
             r= q;
              q=q->next;
       }else if(p->data==q->data){

              q=q->next;

       }
       

    }
  if(p) r->next=p;
  if(q) r->next=q;
   return hc;

}