数据结构C语言版（李云清）实验3 带头结点的单链表

实验3 带头结点的单链表

---

1、编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。 并构造测试用例进行测试。

/**********************************/
/*文件名称：lab3_01.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void delx(linklist head,datatype x)
{
     
    linklist pre,p;
    pre=head;
    p=head->next;
    while (p && p->info!=x)         //查找
    {
     
        pre=p;
        p=p->next;
    }
    if (p)                                          //删除
    {
     
        pre->next=p->next;
        free(p);
    }

}

int main()
{
        datatype x;
    linklist head;
    head=creatbyqueue();		/*尾插入法建立带头结点的单链表*/
    print(head);
    printf("请输入要删除的值：");
    scanf("%d",&x);
    delx(head,x);			/*删除单链表的第一个值为x的结点*/
    print(head);
    delList(head);				/*释放单链表空间*/
    return 0;
}

2、假设线性表（a1,a2,a3,…an）采用带头结点的单链表存储，请设计算法函数void reverse(linklist head)， 将带头结点的单链表head就地倒置，使表变成（an,an-1,…a3.a2,a1）。并构造测试用例进行测试。

/**********************************/
/*文件名称：lab3_02.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void reverse(linklist head)
{
     
        linklist p,s;
        p=head->next;
        head->next=NULL;
        while (p)
        {
     
            s=p;
            p=p->next;
            s->next=head->next;
            head->next=s;
        }
}
int main()
{
        datatype x;
    linklist head;
    head=creatbystack();			/*头插入法建立带头结点的单链表*/
    print(head);					/*输出原链表*/
    reverse(head);			/*倒置单链表*/
    print(head);					/*输出倒置后的链表*/
    delList(head);
    return 0;
}

3、假设带头结点的单链表head是升序排列的，设计算法函数linklist insert(linklist head,datatype x)，将值为x的结点插入到链表head中，并保持链表有序性。分别构造插入到表头、表中和表尾三种情况的测试用例进行测试。

/**********************************/
/*文件名称：lab3_03.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void  insert(linklist head ,datatype x)
{
     
    linklist pre,p,s;
    pre=head;
    p=head->next;
    while (p && p->info<x)
    {
     
        pre=p;
        p=p->next;
    }
    s=(linklist)malloc(sizeof(node));
    s->info=x;
    s->next=p;
    pre->next=s;
}
int main()
{
        datatype x;
    linklist head;
    printf("输入一组升序排列的整数：\n");
    head=creatbyqueue();				/*尾插入法建立带头结点的单链表*/
    print(head);
    printf("请输入要插入的值：");
    scanf("%d",&x);
    insert(head,x);				    /*将输入的值插入到带头结点的单链表适当位置*/
    print(head);
    delList(head);
    return 0;
}

4、编写算法函数void delallx(linklist head, int x)，删除带头结点单链表head中所有值为x的结点。

/**********************************/
/*文件名称：lab3_04.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void  delallx(linklist head,int x)
{
     
    linklist pre,p;
    pre=head;
    p=head->next;
    while(p)
    {
     
        while (p &&p->info!=x)      //查找
        {
     
            pre=p;
            p=p->next;
        }
        if (p)                                      //找到了
        {
     
            pre->next=p->next;
            free(p);
            p=pre->next;                    //删除后p回到pre的后继结点
        }

    }
}
int main()
{
        datatype x;
    linklist head;
    head=creatbyqueue();				/*尾插入法建立带头结点的单链表*/
    print(head);
    printf("请输入要删除的值：");
    scanf("%d",&x);
    delallx(head,x);
    print(head);
    delList(head);
    return 0;
}

5、已知线性表存储在带头结点的单链表head中，请设计算法函数void sort(linklist head)，将head中的结点按结点值升序排列。

/**********************************/
/*文件名称：lab3_05.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void  sort(linklist head)
{
     
        linklist pre,q,p,s;
        p=head->next;
        head->next=NULL;
        while (p)
        {
     
            s=p;
            p=p->next;          //取结点

            pre=head;
            q=head->next;
            while (q && q->info<s->info)            //找位置
            {
     
                pre=q;
                q=q->next;
            }
            s->next=q;                  //将s指示的结点插入到pre与q指示的结点中间
            pre->next=s;
        }
}
int main()
{
             linklist head;
         head=creatbyqueue();   		/*尾插法建立带头结点的单链表*/
         print(head);    			    /*输出单链表head*/
         sort(head);     				/*排序*/
         print(head);
         delList(head);
         return 0;
}

6、已知两个带头结点的单链表L1和L2中的结点值均已按升序排序，设计算法函数linklist mergeAscend (linklist L1,linklist L2)将L1和L2合并成一个升序的带头结单链表作为函数的返回结果；设计算法函数linklist mergeDescend (linklist L1,linklist L2)将L1和L2合并成一个降序的带头结单链表作为函数的返回结果；并设计main()函数进行测试。

/**********************************/
/*文件名称：lab3_06.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist mergeAscend(linklist L1,linklist L2)
{
     
        linklist L3,r3,p,q;
        L3=r3=(linklist)malloc(sizeof(node));
        p=L1->next;
        q=L2->next;
        while (p && q)
        {
     
            if (p->info<q->info)
            {
     
                L1->next=p->next;
                r3->next=p;
                r3=p;
                p=L1->next;
            }
            else
            {
     
                L2->next=q->next;
                r3->next=q;
                r3=q;
                q=L2->next;
            }
        }
        if (p)  r3->next=p;
        if (q) r3->next=q;
        free(L1);
        free(L2);
        return L3;
}
linklist mergeDescend(linklist L1,linklist L2)
{
     
        linklist L3,r3,p,q;
        L3=(linklist)malloc(sizeof(node));
        L3->next=NULL;

        p=L1->next;
        q=L2->next;
        while (p && q)
        {
     
            if (p->info<q->info)
            {
     
                L1->next=p->next;
                p->next=L3->next;
                L3->next=p;
                p=L1->next;
            }
            else
            {
     
                L2->next=q->next;
                q->next=L3->next;
                L3->next=q;
                q=L2->next;
            }
        }
        while (p)
        {
     
                L1->next=p->next;
                p->next=L3->next;
                L3->next=p;
                p=L1->next;
        }
        while (q)
        {
     
                L2->next=q->next;
                q->next=L3->next;
                L3->next=q;
                q=L2->next;
        }
        free(L1);
        free(L2);
        return L3;
}
int main()
{
            linklist h1,h2,h3;
         h1=creatbyqueue();     /*尾插法建立单链表,请输入升序序列*/
         h2=creatbyqueue();
         print(h1);
         print(h2);

         //h3=mergeAscend(h1,h2);/*升序合并到h3*/
         h3=mergeDescend(h1,h2);
         print(h3);
         delList(h3);
         return 0;
}

7、设计一个算法linklist interSection(linklist L1,linklist L2)，求两个单链表表示的集合L1和L2的交集，并将结果用一个新的带头结点的单链表保存并返回表头地址。

/**********************************/
/*文件名称：lab3_07.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist   interSection(linklist L1, linklist L2)
{
     
    linklist head,r,p,q,s;
    head=r=(linklist)malloc(sizeof(node));
    p=L1->next;

    while (p)
    {
     
        q=L2->next;
        while (q && q->info!=p->info)
                q=q->next;
        if (q)//查找成功
        {
     
            s=(linklist)malloc(sizeof(node));
            s->info=p->info;
            r->next=s;
            r=s;
        }
        p=p->next;
    }
    r->next=NULL;
    return head;
}
int main()
{
     
         linklist h1,h2,h3;
         h1=creatbyqueue();           /*尾插法建立单链表,输入时请勿输入重复数据*/
         h2=creatbyqueue();
         print(h1);                   /*输出单链表h1*/
         print(h2);
         h3=interSection(h1,h2);      /* 求h1和h2的交集*/
         print(h3);
         delList(h1);
         delList(h2);
         delList(h3);
         return 0;
}

8、请编写一个算法函数void partion(linklist head)，将带头结点的单链表head中的所有值为奇数的结点调整到链表的前面，所有值为偶数的结点调整到链表的后面。

/**********************************/
/*文件名称：lab3_08.c                           */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void partion(linklist head)
{
     
        linklist pre,p;
        pre=head;
        p=head->next;
        while (p &&p->info%2==1)
            {
     
                pre=p;
                p=p->next;
            }
        while (p)
        {
     
            while (p &&p->info%2==0)
            {
     
                pre=p;
                p=p->next;
            }
            if (p)
            {
     
                pre->next=p->next;
                p->next=head->next;
                head->next=p;
                p=pre->next;
            }
        }

}
int main()
{
             linklist head;
         head=creatbyqueue();           /*尾插法建立带头结点的单链表*/
         print(head);                   /*输出单链表head*/
         partion(head);
         print(head);
         delList(head);
         return 0;
}

9、编写一个程序，用尽可能快的方法返回带头结点单链表中倒数第k个结点的地址，如果不存在，则返回NULL。

/**********************************/
/*文件名称：lab3_09.c             */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist   search(linklist head,int k)
{
     
    linklist pre,p;
    int count=0;
    p=head->next;
    while (p && count<k)
    {
     
        p=p->next;
        count++;
    }
    if (count<k) return NULL;
    pre=head->next;
    while (p)
    {
     
        pre=pre->next;
        p=p->next;
    }
    return pre;
}
int main()
{
     
     int k;
     linklist head,p;
     head=creatbyqueue();      /*尾插法建立带头结点的单链表*/
     print(head);                       /*输出单链表head*/
     printf("k=");
     scanf("%d",&k);
     p=search(head,k);
     if (p) printf("%d\n",p->info);
     else
         printf("Not Found!\n");
     delList(head);
     return 0;
}