第四周 项目3 - 单链表应用

1. /* 程序头部注释开始  
2. * 程序的版权和版本声明部分  
3. * Copyright (c) 2017, 烟台大学计算机学院学生  
4. * All rights reserved.  
5. * 文件名称：   danlianbao.cpp                            
6. * 作    者：   胡俊超                            
7. * 完成日期：   2017 年 9 月 28 日  
8. * 版 本 号：   v1.0        
9.    
10. * 对任务及求解方法的描述部分 
11. * 问题描述：实现单链表各种应用
12. */ 
13. 一.1、设计一个算法，将一个带头结点的数据域依次为a1，a2，…，an（n≥3）的单链表的所有结点逆置，即第一个结点的数据域变为an，…，最后一个结点的数据域为a1。实现这个算法，并完成测试。 
14. linklist.h
    

15. #ifndef LINKLIST_H_INCLUDED  
    #define LINKLIST_H_INCLUDED  
      
    typedef int ElemType;  
    typedef struct LNode        //定义单链表结点类型  
    {  
        ElemType data;  
        struct LNode *next;     //指向后继结点  
    }LinkList;  
    void CreateListF(LinkList *&L,ElemType a[],int n);//头插法建立单链表  
    void CreateListR(LinkList *&L,ElemType a[],int n);//尾插法建立单链表  
    void InitList(LinkList *&L);  //初始化线性表  
    void DestroyList(LinkList *&L);  //销毁线性表  
    bool ListEmpty(LinkList *L);  //判断线性表是否为空  
    int ListLength(LinkList *L);  //求线性表长度  
    void DispList(LinkList *L);  //输出线性表  
    bool GetElem(LinkList *L,int i,ElemType &e);  //求线性表某个数据元素值  
    int LocateElem(LinkList *L,ElemType e);  //按元素值查找  
    bool ListInsert(LinkList *&L,int i,ElemType e);  //插入数据元素  
    bool ListDelete(LinkList *&L,int i,ElemType &e);  //删除数据元素  
     
    #endif // LINKLIST_H_INCLUDED  

    
    
    

16. linklist.cpp  main.cpp

17. #include <stdio.h>
    #include <malloc.h>
    #include "linklist.h"
    
    
    void CreateListF(LinkList *&L,ElemType a[],int n)//头插法建立单链表
    {
        LinkList *s;
        int i;
        L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
        L->next=NULL;
        for (i=0; i<n; i++)
        {
            s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
            s->data=a[i];
            s->next=L->next;            //将*s插在原开始结点之前,头结点之后
            L->next=s;
        }
    }
    
    void CreateListR(LinkList *&L,ElemType a[],int n)//尾插法建立单链表
    {
        LinkList *s,*r;
        int i;
        L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
        L->next=NULL;
        r=L;                    //r始终指向终端结点,开始时指向头结点
        for (i=0; i<n; i++)
        {
            s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
            s->data=a[i];
            r->next=s;          //将*s插入*r之后
            r=s;
        }
        r->next=NULL;           //终端结点next域置为NULL
    }
    
    void InitList(LinkList *&L)
    {
        L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
        L->next=NULL;
    }
    void DestroyList(LinkList *&L)
    {
        LinkList *p=L,*q=p->next;
        while (q!=NULL)
        {
            free(p);
            p=q;
            q=p->next;
        }
        free(p);    //此时q为NULL,p指向尾结点,释放它
    }
    bool ListEmpty(LinkList *L)
    {
        return(L->next==NULL);
    }
    int ListLength(LinkList *L)
    {
        LinkList *p=L;
        int i=0;
        while (p->next!=NULL)
        {
            i++;
            p=p->next;
        }
        return(i);
    }
    void DispList(LinkList *L)
    {
        LinkList *p=L->next;
        while (p!=NULL)
        {
            printf("%d ",p->data);
            p=p->next;
        }
        printf("\n");
    }
    bool GetElem(LinkList *L,int i,ElemType &e)
    {
        int j=0;
        LinkList *p=L;
        while (j<i && p!=NULL)
        {
            j++;
            p=p->next;
        }
        if (p==NULL)            //不存在第i个数据结点
            return false;
        else                    //存在第i个数据结点
        {
            e=p->data;
            return true;
        }
    }
    int LocateElem(LinkList *L,ElemType e)
    {
        LinkList *p=L->next;
        int n=1;
        while (p!=NULL && p->data!=e)
        {
            p=p->next;
            n++;
        }
        if (p==NULL)
            return(0);
        else
            return(n);
    }
    bool ListInsert(LinkList *&L,int i,ElemType e)
    {
        int j=0;
        LinkList *p=L,*s;
        while (j<i-1 && p!=NULL) //查找第i-1个结点
        {
            j++;
            p=p->next;
        }
        if (p==NULL)    //未找到位序为i-1的结点
            return false;
        else            //找到位序为i-1的结点*p
        {
            s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
            s->data=e;
            s->next=p->next;                        //将*s插入到*p之后
            p->next=s;
            return true;
        }
    }
    bool ListDelete(LinkList *&L,int i,ElemType &e)
    {
        int j=0;
        LinkList *p=L,*q;
        while (j<i-1 && p!=NULL)    //查找第i-1个结点
        {
            j++;
            p=p->next;
        }
        if (p==NULL)                //未找到位序为i-1的结点
            return false;
        else                        //找到位序为i-1的结点*p
        {
            q=p->next;              //q指向要删除的结点
            if (q==NULL)
                return false;           //若不存在第i个结点,返回false
            e=q->data;
            p->next=q->next;        //从单链表中删除*q结点
            free(q);                //释放*q结点
            return true;
        }
    }
    #include <stdio.h>
    #include <malloc.h>
    #include "linklist.h"
    void Reverse(LinkList *&L)
    {
        LinkList *p=L->next,*q;
        L->next=NULL;
        while (p!=NULL)     //扫描所有的结点
        {
            q=p->next;      //让q指向*p结点的下一个结点
            p->next=L->next;    //总是将*p结点作为第一个数据结点
            L->next=p;
            p=q;            //让p指向下一个结点
        }
    }
    
    int main()
    {
        LinkList *L;
        ElemType a[]= {1,3,5,7, 2,4,8,10};
        CreateListR(L,a,8);
        printf("L:");
        DispList(L);
        Reverse(L);
        printf("逆置后L： ");
        DispList(L);
        DestroyList(L);
        return 0;
    }
    
    
    
    

18. 2、已知L1和L2分别指向两个单链表的头结点，且已知其长度分别为m、n，请设计算法将L2连接到L1的后面。实现这个算法，完成测试，并分析这个算法的复杂度。

19.  
    #include <stdio.h>
    #include <malloc.h>
    #include "linklist.h"
    
    void Link(LinkList *&L1, LinkList *&L2)
    {
        LinkList *p = L1;
        while(p->next != NULL)   //找到L1的尾节点
            p = p->next;
        p->next = L2->next;  //将L2的首个数据节点连接到L1的尾节点后
        free(L2);   //释放掉已经无用的L2的头节点
    }
    
    int main()
    {
        LinkList *A, *B;
        int i;
        ElemType a[]= {1,3,2,9};
        ElemType b[]= {0,4,7,6,5,8};
        InitList(A);
        for(i=3; i>=0; i--)
            ListInsert(A, 1, a[i]);
        InitList(B);
        for(i=5; i>=0; i--)
            ListInsert(B, 1, b[i]);
        Link(A, B);
        printf("A:");
        DispList(A);
        DestroyList(A);
        return 0;
    }
    
    
    
    

20. 3、设计一个算法，判断单链表L是否是递增的。实现这个算法，并完成测试。 
    

21. #include <stdio.h>
    #include <malloc.h>
    #include "linklist.h"
    
    bool increase(LinkList *L)
    {
        LinkList *p = L->next, *q;  //p指向第1个数据节点
        if(p != NULL)
        {
            while(p->next != NULL)
            {
                q = p->next;   //q是p的后继
                if (q->data > p->data)   //只要是递增的，就继续考察其后继
                    p = q;
                else
                    return false;    //只要有一个不是后继大于前驱，便不是递增
            }
        }
        return true;
    }
    
    int main()
    {
        LinkList *A, *B;
        int i;
        ElemType a[]= {1, 3, 2, 9};
        ElemType b[]= {0, 4, 5 ,6, 7, 8};
        InitList(A);
        for(i=3; i>=0; i--)
            ListInsert(A, 1, a[i]);
        InitList(B);
        for(i=5; i>=0; i--)
            ListInsert(B, 1, b[i]);
        printf("A: %c\n", increase(A)?'Y':'N');
        printf("B: %c\n", increase(B)?'Y':'N');
        DestroyList(A);
        DestroyList(B);
        return 0;
    }