数据结构线性单链表的算法实现和时间复杂度分析

Posted 2020-08-07 likewithyoiu

#include<stdio.h>
#include<stdlib.h>
//线性表的动态分配链式存储结构
#define LIST_INIT_SIZE 100//线性表存储空间的初始分配量
#define LISTINCREMENT 10//线性表存储空间的分配增量
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;//Status是函数的类型，其值是函数结果状态代码
typedef int ElemType;
typedef struct LNode{//节点类型
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
//O(1)
Status InitList_L(LinkList &L)
{
    //初始化一个有头节点的空的线性单链表L
    L=(LinkList)malloc(sizeof(LNode));
    if(!L) exit(OVERFLOW);
    L->next=NULL;
    return OK;
}//InitList_L
//O(n)
Status DestroyList_L(LinkList &L)
{
    // 初始条件：线性表L已存在。
    //操作结果：销毁线性表L为带头结点的链表，释放所有空间
    while(L)
    {
        LinkList p=L;
        L=L->next;
        free(p);
    }
    printf("线性单链表销毁成功\n");
    return OK;
}//DestroyList_L
//O(n)
Status ClearList_L(LinkList &L)
{
    //初始条件：线性表L已存在。
    //操作结果：将L重置为空表带头结点的链表，释放出头结点外的空间，保留头结点
    LinkList p=L;
    while(p->next)
    {
        LinkList q=p->next;
        p->next=q->next;
        free(q);
    }
    printf("线性单链表清空成功\n");
    return OK;
}//ClearList_L
//O(1)
Status ListEmpty_l(LinkList &L)
{
    //初始条件：线性表L已存在。
    //操作结果：若L为空表，则返回TRUE，否则返回FALSE
    LinkList p=L->next;
    if(p)return TRUE;
    return FALSE;
}//ListEmpty_l
//O(n)
Status LocateElem_L(LinkList L,ElemType e,Status (*compare)(ElemType,ElemType))
{
    //初始条件：线性表L已存在。
    //操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。若这样的数据元素不存在，则返回值为0
    LinkList p=L->next;
    int i=1;
    while(p)
    {    
        if((*compare)(p->data,e))
        return i;
        p=p->next;
        ++i;
    }
    return i;
}//LocateElem_L
Status compare(ElemType e1,ElemType e2)
{
    if(e1==e2)
        return OK;
    else
        return ERROR;
}
//O(n)
Status PriorElem_L(LinkList L,ElemType cur_e,ElemType &pre_e)
{
    //初始条件：线性表L已存在。
    //操作结果：若cue_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义
    LinkList p=L->next;
    while(p&&p->next)
    {
        if(p->next->data==cur_e)
        {
            pre_e=p->data;
            return OK;
        }    
        p=p->next;
    }
    return ERROR;
}//PriorElem_L
//O(n)
Status NextElem_L(LinkList L,ElemType cur_e,ElemType &next_e)
{
    
    //初始条件：线性表L已存在。
    //操作结果：若cue_e是L的数据元素，且不是最后一个，则用next_e返回它的后驱，否则操作失败，next_e无定义
    LinkList p=L->next;
    while(p&&p->next)
    {
        if(p->data==cur_e)
        {
            next_e=p->next->data;
            return OK;
        }
        p=p->next;
    }
    return ERROR;
}//PriorElem_L
//O(n)
Status GetElem_L(LinkList L,int i,ElemType &e)
{
    //L为带头节点的单链表的头指针
    //当第i个元素存在时，其值赋给e并返回OK,否则返回ERROR      
    LinkList p=L->next; int j=1;//初始化，p指向第一个节点，j为计数器
    while(p&&j<i)//顺指针向后查找，直到p指向第1个元素或p为空
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i)return ERROR;//第i个元素不存在
    e=p->data;//取第i个元素
    return OK;
}//DestroyList_L
//O(n)
Status ListInsert_L(LinkList &L,int i,ElemType e)
{
    //在带头结点的单链线性表中第i个位置之前插入元素e
    LinkList p=L;int j=0;
    while(p&&j<i-1)//寻找第i-1个节点
    {
        p->next;++j;
    }
    if(!p||j>i-1)return ERROR;//i小于1或者大于表长加1
    LinkList s=(LinkList)malloc(sizeof(LNode));//生成新节点
    s->data=e;//插入到L中
    s->next=p->next;
    p->next=s;
    return OK;
}//ListInsert_L
//O(n)
Status ListDelete_L(LinkList &L,int i,ElemType &e)
{
    //在带头节点的单链表L中，删除第i个元素，并由e返回其值
    LinkList p=L;int j=0;
    while(p->next&&j<i-1)//寻找第i个结点，并令p指向其前驱
    {
        p=p->next;
        ++j;
    }
    if(!p->next||j>i-1)return ERROR;//删除位置不合理
    LinkList q=p->next;//删除并释放结点
    e=q->data;
    p->next=q->next;
    free(q);
    return OK;
}//ListDelete_L
//O(n)
void CreateList_L(LinkList &L,int n)
{
    //逆位序输入n个元素的值，建立带表结点的单链线性表L
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;//先建立一个带头节点的单链表
    for(int i=n;i>0;--i)
    {
        LinkList p=(LinkList)malloc(sizeof(LNode));//生成新结点
        //scanf("%d",&p->data);//输入元素值
        p->data=i;
        p->next=L->next;//插入到表头
        L->next=p;
    }
}
//O(n)
Status ListTraverse_L(LinkList &L,Status (*visit)(ElemType))
{
    //初始条件：线性表L已存在
    //操作结果:依次对L的每个元素调用，visit().一旦visit()失败，则操作失败。
    LinkList p=L->next;
    printf("单链线性表中的元素依次为:");
    while(p)
    {
        
        if((*visit)(p->data))
            printf("%d,",p->data);
        else
            return ERROR;
        p=p->next;
    }
}//ListTraverse_L
Status visit(ElemType e)
{
    return OK;
}
//O(La.length+Lb.length)
void mergelist_L(LinkList &La,LinkList &Lb,LinkList &Lc)
{
    //已知单链线性表La和Lb的元素按值非递减排列
    //归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列
    LinkList pa=La->next,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:pc->next=pb;
    free(Lb);
}//mergelist_L
int main()
{
    LinkList La,Lb,Lc;
    int n=4,i=1;
    ElemType pre_e,next_e;
    CreateList_L(La,n);
    CreateList_L(Lb,n);
    ListTraverse_L(La,visit);
    printf("\n");
    ListTraverse_L(Lb,visit);
    printf("\n");
    mergelist_L(La,Lb,Lc);
    ListInsert_L(Lc,2,1);
    ListDelete_L(Lc,2,i);
    ListTraverse_L(Lc,visit);
    printf("线性单链表中2的元素位序为:%d\n",LocateElem_L(Lc,2,compare));
    PriorElem_L(Lc,2,pre_e);
    printf("线性单链表中2的元素前驱为:%d\n",pre_e);
    NextElem_L(Lc,2,next_e);
    printf("线性单链表中2的元素后继为:%d\n",next_e);
    ClearList_L(Lc);
    ListTraverse_L(Lc,visit);
    printf("\n");
    DestroyList_L(La);
    getchar();
    getchar();
    return 0;
}