數據結構線性單鏈表的算法實現和時間復雜度分析

#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;
}