数据结构线性表——链表实现

数据结构作业之二，保存代码模板

#include<string.h>
#include<ctype.h>
#include<malloc.h> // malloc()等
#include<limits.h> // INT_MAX等
#include<stdio.h> // EOF(=^Z或F6),NULL
#include<stdlib.h> // atoi()
#include<io.h> // eof()
#include<math.h> // floor(),ceil(),abs()
#include<process.h> // exit()
#include<iostream> // cout,cin
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE
typedef int ElemType;
// 线性表的单链表存储结构
struct LNode
{
    ElemType data;
    LNode *next;
};
typedef LNode *LinkList; // 另一种定义LinkList的方法

//单链表线性表的基本操作(12个)
Status InitList(LinkList &L)
{
    /// 操作结果：构造一个空的线性表L
    L=(LinkList)malloc(sizeof(LNode)); // 产生头结点,并使L指向此头结点
    if(!L) // 存储分配失败
        exit(OVERFLOW);
    L->next=NULL; // 指针域为空
    return OK;
}

Status DestroyList(LinkList &L)
{
    /// 初始条件：线性表L已存在。操作结果：销毁线性表L
    LinkList q;
    while(L)
    {
        q=L->next;
        free(L);
        L=q;
    }
    return OK;
}

Status ClearList(LinkList L) // 不改变L
{
    /// 初始条件：线性表L已存在。操作结果：将L重置为空表
    LinkList q=L->next;///注意：清空链表是将除头结点外的所有节点free，否则会占用不再使用的空间，而销毁是free包括头结点在内所有节点
    while(q)
    {
        free(q);
        q=q->next;
    }
    L->next=NULL;
    return OK;
}

Status ListEmpty(LinkList L)
{
    /// 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
    if(L->next) // 非空
        return FALSE;
    else
        return TRUE;
}

int ListLength(LinkList L)
{
    /// 初始条件：线性表L已存在。操作结果：返回L中数据元素个数
    LinkList p=L->next;
    if(ListEmpty(L))return 0;
    int length=0;
    while(p)
    {
        length++;
        p=p->next;
    }
    return length;
}

Status GetElem(LinkList L,int i,ElemType &e) 
{
    /// L为带头结点的单链表的头指针。当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR
    LinkList p=L->next;
    int j=1;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i)return ERROR;
    e=p->data;
    return OK;
}

int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{
    /// 初始条件: 线性表L已存在,compare()是数据元素判定函数(满足为1,否则为0)
    /// 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。
    ///           若这样的数据元素不存在,则返回值为0
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(compare(p->data,e)) // 找到这样的数据元素
            return i;
        p=p->next;
    }
    return 0;
}

Status PriorElem(LinkList L,ElemType cur_e,ElemType &pre_e)//前驱
{
    /// 初始条件: 线性表L已存在
    /// 操作结果: 若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱,
    ///           返回OK;否则操作失败,pre_e无定义,返回INFEASIBLE
    LinkList q,p=L->next; // p指向第一个结点
    while(p->next) // p所指结点有后继
    {
        q=p->next; // q为p的后继
        if(q->data==cur_e)
        {
            pre_e=p->data;
            return OK;
        }
        p=q; // p向后移
    }
    return INFEASIBLE;
}

Status NextElem(LinkList L,ElemType cur_e,ElemType &next_e)//后继
{
    /// 初始条件：线性表L已存在
    /// 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
    ///           返回OK;否则操作失败，next_e无定义，返回INFEASIBLE

    LinkList q,p=L->next; // p指向第一个结点
    while(p->next) // p所指结点有后继
    {
        q=p->next; // q为p的后继
        if(q->data==cur_e&&q->next)
        {
            LinkList k=q->next;
            next_e=k->data;
            return OK;
        }
        p=q; // p向后移
    }
    return INFEASIBLE;
}

Status ListInsert(LinkList L,int i,ElemType e) // 不改变L
{
    /// 在带头结点的单链线性表L中第i个位置之前插入元素e
    LinkList p=L;
    int j=0;
    while(p&&j<i-1)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i-1)return ERROR;
    LinkList s=(LinkList)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;
}

Status ListDelete(LinkList L,int i,ElemType &e) //不改变L
{
    /// 在带头结点的单链线性表L中，删除第i个元素,并由e返回其值
    LinkList p=L;
    int j=0;
    while(p->next&&j<i-1)
    {
        p=p->next;
        ++j;
    }
    if(!(p->next)||j>i-1)return ERROR;
    LinkList q=p->next;
    p->next=q->next;
    e=q->data;
    free(q);
    return OK;
}

Status ListTraverse(LinkList L,void(*vi)(ElemType))
{
    /// 初始条件：线性表L已存在
    /// 操作结果:依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败
    LinkList p=L->next;
    while(p)
    {
        vi(p->data);
        p=p->next;
    }
    printf("
");
    return OK;
}

void CreateList_L(LinkList &L,int n)
{
    ///逆位序(插在表头)输入n个元素的值，建立带表头结构的单链线性表L
    LinkList p;
    L=(LinkList)malloc(sizeof(LNode));///头结点
    L->next=NULL;
    for(int i=n; i>0; i--)
    {
        p=(LinkList)malloc(sizeof(LNode));///新元素节点
        scanf("%d",&p->data);///新元素赋值
        p->next=L->next;///新节点接在首地址后面
        L->next=p;///首地址连接新节点
    }
}
void CreateList_R(LinkList &L,int n)
{
    ///正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表L
    LinkList p;
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    LinkList q=L;
    for(int i=n; i>0; i--)
    {
        p=(LinkList)malloc(sizeof(LNode));
        scanf("%d",&p->data);
        q->next=p;
        q=p;
    }
    q->next=NULL;
}
void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc)
{
    LinkList pa=La->next;
    LinkList pb=Lb->next;
    LinkList pc;
    Lc=pc=La;
    while(pa&&pb)
    {
        if(pa->data<=pb->data)
        {
            pc->next=pa;
            pc=pa;
            pa=pa->next;
        }
        else
        {
            pc->next=pb;
            pc=pb;
            pb=pb->next;
        }
    }
    pc->next=pa?pa:pb;
    free(Lb);
}
Status comp(ElemType c1,ElemType c2)
{
    /// 数据元素判定函数(相等为TRUE,否则为FALSE)
    if(c1==c2)
        return TRUE;
    else
        return FALSE;
}

void visit(ElemType c)
{
    printf("%d ",c);
}

int main()
{
    LinkList La,Lb,Lc;
    ElemType e,e0;
    int n;
    LinkList L;
    Status i;
    int j,k;
    i=InitList(L);
    for(j=1; j<=5; j++)
        i=ListInsert(L,1,j);
    printf("在L的表头依次插入1～5后：L=");
    ListTraverse(L,visit); // 依次对元素调用visit()，输出元素的值
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)
",i);
    i=ClearList(L);
    printf("清空L后：L=%u
",L);
    ListTraverse(L,visit);
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)
",i);
    for(j=1; j<=10; j++)
        ListInsert(L,j,j);
    printf("在L的表尾依次插入1～10后：L=");
    ListTraverse(L,visit);
    GetElem(L,5,e);
    printf("第5个元素的值为：%d
",e);
    for(j=0; j<=1; j++)
    {
        k=LocateElem(L,j,comp);
        if(k)
            printf("第%d个元素的值为%d
",k,j);
        else
            printf("没有值为%d的元素
",j);
    }
    for(j=1; j<=2; j++) // 测试头两个数据
    {
        GetElem(L,j,e0); // 把第j个数据赋给e0
        i=PriorElem(L,e0,e); // 求e0的前驱
        if(i==INFEASIBLE)
            printf("元素%d无前驱
",e0);
        else
            printf("元素%d的前驱为：%d
",e0,e);
    }
    for(j=ListLength(L)-1; j<=ListLength(L); j++) //最后两个数据
    {
        GetElem(L,j,e0); // 把第j个数据赋给e0
        i=NextElem(L,e0,e); // 求e0的后继
        if(i==INFEASIBLE)
            printf("元素%d无后继
",e0);
        else
            printf("元素%d的后继为：%d
",e0,e);
    }
    k=ListLength(L); // k为表长
    for(j=k+1; j>=k; j--)
    {
        i=ListDelete(L,j,e); // 删除第j个数据
        if(i==ERROR)
            printf("删除第%d个数据失败
",j);
        else
            printf("删除的元素为：%d
",e);
    }
    printf("依次输出L的元素：");
    ListTraverse(L,visit);
    DestroyList(L);
    printf("销毁L后：L=%u
",L);
    system("pause");
///=================================================================
    while(scanf("%d",&n)!=EOF)
    {
        InitList(La);
        InitList(Lb);
        InitList(Lc);
        CreateList_L(La,n);
        printf("逆位序插入n个元素的值:");
        ListTraverse(La,visit);
        CreateList_R(Lb,n);
        printf("正位序插入n个元素的值:");
        ListTraverse(Lb,visit);
        MergeList_L(La,Lb,Lc);
        printf("数组非递减排列合并的值:");
        ListTraverse(Lc,visit);
    }
}