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

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

时间: 09-03

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

2-10-归并扩展的线性单链表-线性表-第2章-《数据结构》课本源码-严蔚敏吴伟民版

课本源码部分 第2章  线性表 - 归并扩展的线性链表 ——<数据结构>-严蔚敏.吴伟民版        源码使用说明  链接??? <数据结构-C语言版>(严蔚敏,吴伟民版)课本源码+习题集解析使用说明        课本源码合辑  链接??? <数据结构>课本源码合辑        习题集全解析  链接??? <数据结构题集>习题解析合辑        本源码引入的文件  链接? ExtenLinkedList.c        相关测试数据下载  链接

C#数据结构-单链表

理论基础: 链表是用一组任意的存储单元来存储线性表中的数据元素. 如果结点的引用域只存储该结点直接后继结点的存储地址,则该链表叫单链表(Singly Linked List). 单链表由头引用H唯一确定.头引用指向单链表的第一个结点,也就是把单链表第一个结点的地址放在H中. C#实现: 1接口 引用线性表的接口IListDS<T> 2实现 首先,必须定义一个单链表的节点类.  1 public class Node<T> 2    { 3        private T data

线性单链表

昨天提到了用线性单链表实现直接插入排序,所以准备借此复习一下线性单链表的内容......(很惭愧,两个学期没再摸数据结构,记不得了) 线性单链表是一种非随机存取的存储结构.因为与顺序表不同的是,链表结构中结点的位置不是连续的,需要通过链表中的结构指针来单向指引(如果是双向链表,则是双向指引.) 链表中的结点,由两个部分构成,一个是数据域,一个是指针域.指针域可以有一到两个,其中存储的指针,既有指向直接前驱的,也有指向直接后继的.在单链表中,只有指向直接后继的指针. 单链表由头指针开始,头指针指向

线性表的链式表示和实现----线性(单)链表

头文件 head.h #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 <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define INFEASIBLE -1 #define OVERFLOW -2 /* #define ElemType int #define Status int */ typedef int ElemType; typedef int Status; /* #define LNo

java数据结构:单链表常见操作代码实现

一.概述: 本文主要总结单链表常见操作的实现,包括链表结点添加.删除:链表正向遍历和反向遍历.链表排序.判断链表是否有环.是否相交.获取某一结点等. 二.概念: 链表: 一种重要的数据结构,HashMap等集合的底层结构都是链表结构.链表以结点作为存储单元,这些存储单元可以是不连续的.每个结点由两部分组成:存储的数值+前序结点和后序结点的指针.即有前序结点的指针又有后序结点的指针的链表称为双向链表,只包含后续指针的链表为单链表,本文总结的均为单链表的操作. 单链表结构: Java中单链表采用No

数据结构线性表链表的C语言实现

                                                                                      数据结构线性表链表的C语言实现      说明:线性表是一种最简单的线性结构,也是最基本的一种线性结构,所以它不仅是学习中的重点,也是应用开发非常常用的一种数据结构.它可以分为顺序表和链表.它的主要操作是数据元素的插入,删除,以及排序等.接下来,本篇文章将对线性表链表的基本操作和运用进行详细的说明(包含在源代码的注释中),并给

单链表的算法设计

当学习完单链表后,仔细回忆回忆,单链表还是很容易掌握的,但是还是要仔细认真的品味. 单链表可以看做是由若干个结点由指针指向后继结点一种表.结点是由数据域和指针域构成.真正有效的存储是数据域,指针域负责指向下一个结点存储的位置,所以它的存储密度都是小于1,而之前学习的顺序表存储密度都是1.那么如何定义结构体 12345 typedef struct { Eletype data; struct *next;//指针域}node,*Node; 那么单链表具体可以做些什么操作哪? 初始化操作,主要是对

数据结构之单链表(C++实现)

有一段时间没有写一些关于数据结构的程序了,正好算法导论这门课学到红黑树,感觉数据结构都忘得差不多了,而且考研还要考,故再拿来复习一下. 一.C++实现单链表 #include<iostream> using namespace std; typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList; void CreateList_L(LinkList &L, int n) { L = new LNode()