数据结构_2：链表：C语言练习

• 带头结点的单链表中，删除所有值为x的节点，释放其空间

//用p从头到尾扫描单链表，pre指向*p节点的前驱。若p的节点是x则删除，并让p后移，否则，pre和p同时移动
void Del_x_1(LinkList &L,ElemType x)
{
   LNode *p=L->next,*pre=L,*q;
   while(p!=NULL)
   {
      if(p->data=x)
      {
          q=p;
          p=p->next;
          pre->next=p;
          free(q);
      }
      else
      {
          pre=p;
          p=p->next;
      }
   }
}

//尾插法：值不为x则接入L，否则释放

void Del_x_2(LinkList &L,ElemType x)
{
    LNode *p=L->next,*r=L,*q;
    while(p!=NULL)
    {
        if(p->data!=x)
        { 
            r->next=p;
            r=p;
            p=p->next;
        }
        else
        {
            q=p;
            p=p->next;
            free(q);
        }
    }
}

• 链表反向输出(不是反转)

void R_print(LinKList L)
{
    if(L->next!=NULL)
       R_print(L->next);
    printf(L->data);
}

• 删除带头结点的单链表L中最小值

//p扫描单链表，pre指向*p节点的前驱，minp保存最小节点指针(初值是p)，minpre是指向minp的前驱(初值是pre)
//若p->data小于minp-》data，则将p,pre,分布赋予minp和minpre

LinkList Del_Min(LinkList &L)
{
    LNode *pre=L,*p=pre->next;
    LNode *minpre=pre, *min=p;
    while(p!=NULL)
    {
       if(p->data<minp->data)
       {
           minp=p;
           minpre=pre;
       }
       pre=p;
       p=p->next;
    }
    minpre->next=minp->next; //删除最小值
   free(minp);
   return L;

}

• 链表反转

//将头结点摘下，然后从第一节点开始，一次前插入到头结点后面

LinkList R_1(LinkList &L)
{
    p=L->next;
    L->next=NULL;

    while(p!=NULL)
      {
         r=p->next;
         p->next=L->next;
         L->next=p;
         p=r;
      }
    return L;
}


//pre,p,r

LinkList R_2(LinkList &L)
{
    LinkList *pre,*p=L->next;*r=p->next;
    p->next=NULL; //处理第一个节点

    while(r!=NULL)
    {
        pre=p;
        p=r;
        r=r->next;
        p->next=pre;
    }

    L->next=p;
    return L;
}

• 链表增序

void Sort(LinkList &L)
{
   LNode *p=L->next;*pre;
   Lnode *r=p->next;

   p->next=NULL;
   p=r;
   while(p!=NULL)
   {
       r=p->next;
       pre=L;
       while(pre->next!=NULL && pre->next->data<p->data)
          pre=pre->next;
       p->next=pre->next;
       pre->next=p;
       p=r;
   }
}

• 寻找两个单链表的公共节点

//计算长度差，在长单链表上先遍历长度长度之差，，在遍历两个链表
LinkList Search_List_Common(LinkList L1,LinkList L2)
{
    int len1=Length(L1),len2=Length(L2);
    LiNKList longlist,shortlist;
    if(len1>len2)
     {
          longlist=L1->next;
          shortlist=L2->next;
          dist=len1-len2
     }
     else
     {
           longlist=L2->next;
           shortlist=L1->next;
           dist=len2-len1;
     }

     while(dist--)
        longlist=longlist->next;

     while(longlist!=NULL)
     {
         if(longlist=shortlist)
            return longlist;
         else
         {
            longlist=longlist->next;
            shortlist=shortlist->next;
         }
     }

     return NULL;
}

• 两个有序表，依次增序，合并成一个递减序列

//头插法

void MergeList(LinkList &La,LinkList &Lb)
{
     LNode *r,*pa=La->next,*pb=Lb->next;
     La->next=NULL;

     while(pa&&pb)
     {
         if(pa->data<=pb->data)
          {
              r=pa->next;
              pa->next=La->next;
              La->next=pa;
              pa=r;
          }
          else
          {
               r=pa->next;
               pb->next=La->next;
               La->next=pn;
               pb=r;
          }
     }
    if(pa)
       pa=pb;

    while(pb)
    {
        r=pb->next;
        pb->next=La->next;
        La->next=pb;
        pb=r;
    }

    free(Lb);
}

• 判断是否是自序列

int Pattern(LinkList A,LinkList B)
{
   LNode *p=A;
   LNode *pre=p;
   LNode *q=B;

   while(p&&q)
     if(p->data==q->data)
        {
             p=p->next;
             q=q->next;
        }
     else
     {   
             pre=pre->next;
             p=pre;
             q=B;
     }

    if(q==NULL)
       return 1;
    else
       return 0;
}