带头结点的单链表——数据结构课堂作业

/**************************************/
/* 链表实现的头文件，文件名slnklist.h */
/**************************************/

#include <stdio.h>
#include <stdlib.h>
/**************************************/
/* 链表实现的头文件，文件名slnklist.h */
/**************************************/
typedef int datatype;
typedef struct link_node
{
    datatype info;
    struct link_node *next;
} node;
typedef node *linklist;
/******************************************/
/*函数名称：creatbystack()                      */
/*函数功能：头插法建立带头结点的单链表    */
/******************************************/
linklist creatbystack()
{

    linklist  head,s;
    datatype x;
    head=(linklist)malloc(sizeof(node));
    head->next=NULL;

    printf("请输入整数序列（空格分开，以0结束）:
");
    scanf("%d",&x);
    while (x!=0)
    {
        s=(linklist)malloc(sizeof(node));
        s->info=x;

        s->next=head->next;
        head->next=s;

        scanf("%d",&x);
    }
    return head;
}
/***************************************/
/*函数名称：creatbyqueue()                */
/*函数功能：尾插法建立带头结点的单链表 */
/***************************************/
linklist creatbyqueue()
{
    linklist head,r,s;
    datatype x;
    head=r=(linklist)malloc(sizeof(node));
    head->next=NULL;
    printf("请输入整数序列（空格分开，以0结束）:
");
    scanf("%d",&x);
    while (x!=0)
    {
        s=(linklist)malloc(sizeof(node));
        s->info=x;
        r->next=s;
        r=s;
        scanf("%d",&x);
    }
    r->next=NULL;
    return head;
}
/**********************************/
/*函数名称：print()                      */
/*函数功能：输出带头结点的单链表      */
/**********************************/
void print(linklist head)
{
    linklist p;
    int i=0;
    p=head->next;
    printf("List is:
");
    while(p)
    {
        printf("%7d",p->info);
        i++;
        if (i%10==0)    printf("
");
        p=p->next;
    }
    printf("
");

}

/******************************************/
/*函数名称：creatLink()                   */
/*函数功能：从文件中读入n个数据构成单链表 */
/******************************************/
linklist creatLink(char *f, int n)
{
    FILE *fp;
    int i;
    linklist s,head,r;
    head=r=(linklist)malloc(sizeof(node));
    head->next=NULL;
    fp=fopen(f,"r");
    if (fp==NULL)
        return head;
    else
    {
        for (i=0; i<n; i++)
        {
            s=(linklist)malloc(sizeof(node));
            fscanf(fp,"%d",&(s->info));
            r->next=s;
            r=s;
        }
        r->next=NULL;
        fclose(fp);
        return head;
    }
}

/*
    函数名称：writetofile
    函数功能：将链表内容存入文件f
*/
void writetofile(linklist head, char *f)
{
    FILE *fp;
    linklist p;
    int i=0;
    fp=fopen(f,"w");
    if (fp!=NULL)
    {
        p=head->next;
        fprintf(fp,"%s","List is:
");
        while(p)
        {
            fprintf(fp,"%7d",p->info);
            i++;
            if (i%10==0)    fprintf(fp,"%c",'
');
            p=p->next;
        }
        fprintf(fp,"%c",'
');
        fclose(fp);
    }
    else    printf("创建文件失败!");

}


/**********************************/
/*函数名称：delList()                  */
/*函数功能：释放带头结点的单链表      */
/**********************************/
void delList(linklist head)
{
    linklist p=head;
    while (p)
    {
        head=p->next;
        free(p);
        p=head;
    }
}

/*编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。
并构造测试用例进行测试。
*/
/**********************************/
/*文件名称：lab3_01.c                 */
/**********************************/

/*编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。
并构造测试用例进行测试。
*/
/**********************************/
/*文件名称：lab3_01.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist delx(linklist head,datatype x)
{
    if(head->next->info==x)
    {
        head = head->next;
        return head;
    }
    else
    {
        linklist p = head;
        linklist pre = head;
        p = p->next ->next;
        pre = pre->next;
        while()
        {
            if(p->info==x)
            {
                pre->next = p->next;
                return head;
            }
            else {
                pre = p;
                p = p->next;
            }
        }
    }
}

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

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

/**********************************/
/*文件名称：lab3_02.c                 */
/**********************************/
/*
假设线性表（a1,a2,a3,…an）采用带头结点的单链表存储，请设计算法函数linklist reverse(linklist  head)，
将带头结点的单链表head就地倒置，使表变成（an,an-1,…a3.a2,a1）。并构造测试用例进行测试。
*/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist reverse(linklist head)
{
    linklist p = head ->next;
    linklist thead,s;
    thead = (linklist)malloc(sizeof(node));
    thead ->next = NULL;
    while(p)
    {
        datatype x = p->info;
        s=(linklist)malloc(sizeof(node));
        s->info=x;
        s->next=thead->next;
        thead->next=s;
        p = p->next;
    }
    return head = thead;
}
int main()
{
    datatype x;
    linklist head;
    head=creatbystack();            /*头插入法建立带头结点的单链表*/
    print(head);                    /*输出原链表*/
    head= reverse(head);            /*倒置单链表*/
    print(head);                    /*输出倒置后的链表*/
    delList(head);
    return 0;
}

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

/*
假设带头结点的单链表head是升序排列的，设计算法函数linklist insert(linklist head,datatype x)，
将值为x的结点插入到链表head中，并保持链表有序性。
分别构造插入到表头、表中和表尾三种情况的测试用例进行测试。
*/
/**********************************/
/*文件名称：lab3_03.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist insert(linklist head,datatype x)
{
    linklist p = head->next;
    linklist pre = head;

    while(p) {
        if(p->info>x) {
            linklist s;
            s = (linklist)malloc(sizeof(node));
            s->info = x;
            pre->next = s;
            s->next = p;
            break;
        }
        else {
            pre = p;
            p = p->next;
        }
    }
    return head;

}
int main()
{
    datatype x;
    linklist head;
    printf("输入一组升序排列的整数：
");
    head=creatbyqueue();                /*尾插入法建立带头结点的单链表*/
    print(head);
    printf("请输入要插入的值：");
    scanf("%d",&x);
    head=insert(head,x);                /*将输入的值插入到带头结点的单链表适当位置*/
    print(head);
    delList(head);
    return 0;
}

/*
编写算法函数linklist delallx(linklist head, int x)，删除带头结点单链表head中所有值为x的结点。
*/
/**********************************/
/*文件名称：lab3_04.c                 */
/**********************************/

/*
编写算法函数linklist delallx(linklist head, int x)，删除带头结点单链表head中所有值为x的结点。
*/
/**********************************/
/*文件名称：lab3_04.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist delallx(linklist head,int x)
{
    linklist p = head->next;
    linklist pre = head;
    while(p)
    {
        if(p->info == x)
        {
            pre->next = p->next;
            p = p->next;
        }
        else
        {
            pre = p;
            p = p->next;
        }
    }

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

/*
已知线性表存储在带头结点的单链表head中，请设计算法函数void sort(linklist head)，将head中的结点按结点值升序排列。
*/
/**********************************/
/*文件名称：lab3_05.c                 */
/**********************************/

/*
已知线性表存储在带头结点的单链表head中，请设计算法函数void sort(linklist head)，将head中的结点按结点值升序排列。
*/
/**********************************/
/*文件名称：lab3_05.c                 */
/**********************************/
#include "slnklist.h"
#include <stdlib.h>

/*请将本函数补充完整，并进行测试*/
void  sort(linklist head)
{
    linklist i,j;
    for(i = head->next;i;) {
        for(j=i;j;) {
            if(i->info>j->info) {
                datatype temp = i->info;
                i->info = j->info;
                j->info = temp;
            }
            j = j->next;
        }
        i = i->next;
    }

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

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

/*
已知两个带头结点的单链表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 reverse(linklist head)
{
    linklist p = head ->next;
    linklist thead,s;
    thead = (linklist)malloc(sizeof(node));
    thead ->next = NULL;
    while(p)
    {
        datatype x = p->info;
        s=(linklist)malloc(sizeof(node));
        s->info=x;
        s->next=thead->next;
        thead->next=s;
        p = p->next;
    }
    return head = thead;
}

linklist mergeAscend(linklist L1,linklist L2)
{

    linklist head,r,s;
    datatype x;
    head=r=(linklist)malloc(sizeof(node));
    head->next=NULL;

    L1 = L1->next;
    L2 = L2->next;

    while(L1&&L2)
    {
        s = (linklist)malloc(sizeof(node));

        if(L1->info<L2->info)
        {
            s ->info = L1->info;
            r ->next = s;
            r = s;

            L1 = L1 ->next;
        }
        else if(L1->info>L2->info)
        {
            s->info =  L2->info;
            r->next = s;
            r = s;
            L2 = L2 ->next;
        }
        else
        {
            s->info = L1 ->info;
            r->next = s;
            r = s;
            L2 = L2->next;
            L1 = L1->next;
        }
    }

    if(L1)
    {
        s = (linklist)malloc(sizeof(node));
        s ->info = L1->info;
        r ->next = s;
        r = s;
        L1 = L1->next;
    }
    else if(L2)
    {
        s = (linklist)malloc(sizeof(node));
        r->next = s;
        r = s;
        L2 = L2->next;
    }
    r->next=NULL;
    return head;
}

linklist mergeDescend(linklist L1,linklist L2)
{
    linklist head = mergeAscend(L1,L2);
    head = reverse(head);
    return head;

}

int main()
{
    linklist h1,h2,h3;
    h1=creatbyqueue();     /*尾插法建立单链表,请输入升序序列*/
    h2=creatbyqueue();
    print(h1);
    print(h2);
    //h3=mergeAscend(h1,h2);/*升序合并到h3*/
    /*降序合并请调用h3=mergeDescend(h1,h2); */
    h3=mergeDescend(h1,h2);
    print(h3);
    delList(h3);
    return 0;
}

/*
设计一个算法linklist interSection(linklist L1,linklist L2)，
求两个单链表表示的集合L1和L2的交集，并将结果用一个新的带头
结点的单链表保存并返回表头地址。
*/
/**********************************/
/*文件名称：lab3_07.c                 */
/**********************************/

/*
设计一个算法linklist interSection(linklist L1,linklist L2)，
求两个单链表表示的集合L1和L2的交集，并将结果用一个新的带头
结点的单链表保存并返回表头地址。
*/
/**********************************/
/*文件名称：lab3_07.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist   interSection(linklist L1, linklist L2)
{

    linklist head,r,s;
    datatype x;
    head=r=(linklist)malloc(sizeof(node));
    head->next=NULL;

    linklist i,j;
    for(i=L1->next; i;)
    {
        for(j=L2->next; j;)
        {
            if(i->info==j->info)
            {
                s=(linklist)malloc(sizeof(node));
                s->info=i->info;
                r->next=s;
                r=s;
                break;
            }
            else j = j->next;
        }
        i = i->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;
}

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

/**********************************/
/*文件名称：lab3_08.c             */
/**********************************/

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

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

}

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

/*
编写一个程序，用尽可能快的方法返回带头结点单链表中倒数第k个结点的地址，如果不存在，则返回NULL。
*/
/**********************************/
/*文件名称：lab3_09.c             */
/**********************************/

/*
编写一个程序，用尽可能快的方法返回带头结点单链表中倒数第k个结点的地址，如果不存在，则返回NULL。
*/
/**********************************/
/*文件名称：lab3_09.c             */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist   search(linklist head,int k)
{
    linklist p = head;
    int cnt = 0;
    p =p->next;
    while(p) {
        cnt ++;
        p = p->next;
    }
    p = head;

    int ans = cnt - k + 1;
    while(ans--) {
        p = p->next;
    }

    return p;

}

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
",p->info);
     else
         printf("Not Found!
");
     delList(head);
     return 0;
}