线性表及其基本操作

大佬菜菜带带

已于 2022-05-14 21:04:56 修改

阅读量1.9k

点赞数 2

分类专栏：数据结构文章标签：数据结构

于 2022-05-11 19:51:25 首次发布

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/m0_53921051/article/details/124705216

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

目录

线性表的实现

顺序表的实现

链表的实现

初始化表(InitList(&L))

销毁操作(DestroyList(&L))

插入操作(&L,i,e)

删除操作(ListDelete(&L,i,&e))

按值查找(LocateElem(L,e))

按位查找(GetElem(L,i))

求表长(Length(L))

输出操作(PrintList(L))

判空操作(Empty(L))

定义

线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长，当n=0时线性表时一个空表。若用l命名线性表，则其一般表示为 L=(a1,a2,a3,a4,...an)。

ai是线性表中第i个元素的位序（从1开始）。

a1是表头元素，an是表尾元素。

除第一个元素外，每一个元素都有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。

顺序表：用顺序存储的方式实现的线性表，把逻辑相邻的元素存储在物理相邻的空间中，元素之间的关系由存储单元的邻接关系来体现。

链表：用链式存储结构实现的线性表统称位链表。

线性表的实现

顺序表的实现

//静态分配
#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];
    int length;             //顺序表当前长度
}SqList;

//动态分配
#define InitSize 10
typedef struct{
    int *data;              //动态分配数组的指针
    int MaxSize;            //顺序表当前最大容量
    int length;             //顺序表当前长度
}SeqList;

链表的实现

//单链表的代码实现
struct LNode{
    Elemtype data;      //数据域
    struct LNode *next; //指针域
}
//增强版定义
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;


//双链表实现
typedef struct DNode{            //定义节点类型
    ElemType data;               //数据域
    struct DNode *prior,* next;  //定义prior、next两个指针
}DNode,*DLinkList;

基本操作

初始化表(InitList(&L))

//静态分配线性表的初始化
#define MaxSize 10
void InitSize(SqList &L){
    for(int i=0;i<MaxSize;i++)
        L.data[i]=0;
    L.length=0;
}

//动态分配顺序表的初始化
#define InitSize 10
void InitList(SeqList &L){
    L.data=(int *)malloc(InitSize*sizeof(int)); //malloc申请一片连续的内存空间
    L.length=0;
    L.MaxSize=InitSize;
}

//不带头节点的单链表的初始化
bool InitList(LinkList &L){
    L=NULL;                 //头指针L为空，即链表为空表
    return true;
}

//带头节点的单链表的初始化
bool InitList(LinkList &L){
    L=(LNode *)malloc(sizeof(LNode));   //分配头节点，头节点不存储数据
    if(L=NULL)                          //分配失败，返回false
        return false;
    L->next=NULL;
    return ture;
}


//初始化双链表
bool InitDLinkList(DLinkList &L){
    L=(DNode *)malloc(sizeof(DNode));   //分配头节点
    if(L==NULL)
        return false;
    L->prior=NULL;                      //初始化头节点prior指针
    L->next=NULL;                       //初始化头节点next指针
    return true;
}

销毁操作(DestroyList(&L))

插入操作(&L,i,e)

#define MaxSize 10
//顺序表的插入操作
void ListInsert(SqList &L,int i,int e){ //在第i个位置插入元素
    for(int j=L.length;j>=i;j--)
        L.data[j]=L.data[j-1];
    L.data[i-1]=e;
    L.length++;
}

//顺序表插入操作健壮版
bool ListInsert(SqList &L,int i,int e){
    if(i<1||i>L.length+1)                //判断插入位置i是否与之前数据连续
        return false;
    if(L.length>=MaxSize)                //判断表是否已满，若表满则不能插入
        return false;
    for(int j=L.length;j>=i;j--)         //在第i个位置插入元素
        L.data[j]=L.data[j-1];
    L.data[i-1]=e;
    L.length++;
    return true;
}
//最好时间复杂度O(1)
//最坏时间复杂度O(n)
//平均时间复杂度O(n/2)


//单链表按位序插入（带头节点）
bool ListInsert(LinkList &l,int i,ElemType e){
    if(i<1)
        return false;
    LNode *p;
    int j=0;
    p=L;
    while(p!=NULL&&j<i-1){                    //循环找到第i减一个节点
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;                                 //放入数据
    s->next=p->next;                           //连接节点
    p->next=s;
    return true;
}

//单链表按位序插入（不带头节点）
bool ListInsert(LinkList &L,int i,Elemtype e){
    if(i<1)
        return false;
    if(i==1){                                  //头指针插入
        LNode *s=(Lnode *)malloc(sizeof(LNode));
        s->data=e;
        s->next=L;
        L=s;
        return true;
    }
    LNode *p;                                   //正常插入
    int j=1;
    p=L;
    while(p!=NULL&&j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}
//后插操作：在指定节点p后插入元素e
bool InsertNextNode(LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}
//前插操作：数据换位
bool InsertPriorNode(LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    if(s==NULL)
        return false;
    s->next=p->next;                         //指针连接
    p->next=s;
    s->data=p->data;                         //数据换位
    p->data=e;
    return true;
}

//双链表的后插操作
bool InsertNextDNode(DNode *p,DNOde *s){
    if(p==NULL||s==NULL)                     //防止非法参数传入
        return false;
    s->next=p->next;
    if(p->next!=NULL)                        //如果p节点有后继节点
        p->next->prior=s;
    s->prior=p;
    p->next=s;
    reutrn ture;
}
//双链表的前插操作可以转化为指定节点前一个节点的后插操作，按位序插入同样可以转化为后插操作

删除操作(ListDelete(&L,i,&e))

//顺序表的删除操作
bool ListDelete(SqList &L,int i,int &e){
    if(i<1||i>L.length)                  //判断删除是否有效
        return false;
    e=L.data[i-1];                       //将删除的元素复赋值给e
    for(int j=i;j<L.length;j++) 
        L.data[j-1]=L.data[j];           //将第i个位置后的元素前移
    L.length--;                          //线性表的长度减1
    return true;
}
//时间复杂度同插入


//单链表按位序删除（带头节点）
bool ListDelete(LinkList &L,int i,Elemtype &e){
    if(i<1)
        return false;
    LNode *p;
    int j=0;
    p=L;
    while(p!=NULL&&j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)
        reurn false;
    if(p->next==NULL)
        return false;
    LNode *q=p->next;
    p->next=q->next;
    free(p);
    return true;
}
//删除指定节点p
bool DeleteNode(LNode *p){
    if(p==NULL)
        return false;
    LNode *q=p->next;
    p->data=p->next->data;
    p->next=q->next;
    free(p);
    return true;
}

//删除双链表p节点的后继节点
bool DeleteNextDNode(DNode *p){
    if(p==NULL)
        return false;
    DNode *q=p->next;            //找到要删除的节点q
    if(q=NULL)
        reutrn false;
    p->next=q->next;
    if(q->next!=NULL)            //判断要删除的节点q是否为最后一个节点
        q->next->prior=p;
    free(q);
    reurn ture;
}

按值查找(LocateElem(L,e))

//顺序表的按值查找
int LocateElem(SeqList L,ElemType e){
    for(int i=0;i<L.length;i++)
        if(L.data[i]==e)
            return i+1;               //返回位序
    return 0;                         //推出循环，查找失败
}
//时间复杂度同插入


//单链表的按值查找
LNode * LocateElem(LinkList L,ElemType e){  //查找数据域为e的节点
    LNode *p=L->next;
    while(p!=NULL&&p->data!=e)
        p=p->next;
    return p;
}

按位查找(GetElem(L,i))

//顺序表按位查找
ElemType GetElem(SqList L,int i){
    if(i<1||i>L.length)           //判断位置是否合法
        return false;
    return L.data[i-1];

}
//时间复杂度O(1)


//单链表的按位查找
LNode *GetElem(LinkList L,int i){
    if(i<0)
        return NULL;
    LNode *p;
    int j=0;
    p=L;
    while(p!=NULL&&j<i){          //循环找到第i个节点
        p=p->next;
        j++;
    }
    return p;
}

求表长(Length(L))

输出操作(PrintList(L))

判空操作(Empty(L))

//顺序表的判空操作
bool Empty(SqList L){
    if(L.length==0)
        return true;
    else
        return false;
}

//单链表、双链表的判空操作
bool Empty(LinkList L){
    if(L->next==NULL)
        return true;
    else
        return false;
}

//循环链表的判空操作
bool Empty(LinkList L){
    if(L->next==L)
        return true;
    else
        return false;
}

大佬菜菜带带

关注

2
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
线性表及其基本操作

定义线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长，当n=0时线性表时一个空表。若用l命名线性表，则其一般表示为 L=(a1,a2,a3,a4,...an)。ai是线性表中第i个元素的位序（从1开始）。a1是表头元素，an是表尾元素。除第一个元素外，每一个元素都有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。顺序表：用顺序存储的方式实现的线性表，把逻辑相邻的元素存储在物理相邻的空间中，元素之间的关系由存储单元的邻接关系来体现。链表：用链式存储结构
复制链接

扫一扫

专栏目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。