单链表的插入和删除_链表的insert函数-CSDN博客

本文链接：https://blog.csdn.net/m0_68169483/article/details/124462581

1.单链表的插入

ListInsert(&L,i,e):插入操作。在表L中的第 i 个位置上插入指定元素 e。（找到第 i-1个结点，将新结点插入其后）

1.1按位序插入（带头结点）

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList &L,int i,ElemType e){
    if(i<1)
        return false;
    LNode *p;            //指针p指向当前所扫描到的结点
    int j=0;            //当前p指向的是第几个结点
    p=L;            //L指向头结点，头结点是第0个结点
    while(p!=NULL && j<i-1){        //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL)        //i值不合法
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;            //将结点s连在p之后
    return true;            //插入成功
}

平均时间复杂度O(n)

1.2按位序插入（不带头结点）

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList &L,int i,ElemType e){
    if(i<1)
        return false;
    if(i==1){        //插入第1个结点的操作与其他结点的操作不同
        LNode *s=(LNode *)malloc(sizeof(LNode));
        s->data=e;
        s->next=L;
        L=s;            //头指针指向新结点
        return true;
    }
    LNode *p;            //指针p指向当前所扫描到的结点
    int j=1;            //当前p指向的是第几个结点
    p=L;            //L指向头结点，头结点是第0个结点
    while(p!=NULL && j<i-1){        //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL)        //i值不合法
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;            //将结点s连在p之后
    return true;            //插入成功
}

结论：不带头结点写代码更不方便，推荐用带头结点

1.3指定结点的后插操作

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//后插操作：在p结点之后插入数据元素e
bool InsertNextLNode(LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    if(s==NULL)            //内存分配失败
        return false;
    s->data=e;            //用结点s保存数据元素e
    s->next=p->next;
    p->next=s;            //将结点s接到p之后
    return true;
}

平均时间复杂度O(1)

1.4指定结点的前插操作

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//前插操作：在p结点之前插入数据元素e
bool InsertPriorLNode(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连到p之后
    s-data=p->data;        //将p中元素复杂到s中
    p->data=e;            //p中元素覆盖为e
    return true;
}

2.单链表的删除

ListDelete(&L,i,&e)：删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。（找到第i-1个结点，将其指针指向第i+1个结点，并释放第i个结点）

2.1按位序删除（带头结点）

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//在第i个位置插入元素e（带头结点）
bool ListDelete(LinkList &L,int i,ElemType &e){
    if(i<1)
        return false;
    LNode *p;            //指针p指向当前所扫描到的结点
    int j=0;            //当前p指向的是第几个结点
    p=L;            //L指向头结点，头结点是第0个结点
    while(p!=NULL && j<i-1){        //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL)        //i值不合法
        return false;
    if(p->next==NULL)        //第i-1个结点之后已无其他结点
        return false;
    LNode *q=p->next;        //令q指向被删除的结点
    e=q->data;                //用e返回元素的值
    p->next=q->next;        //将*q结点从链中断开
    free(q);                //释放结点的存储空间
    return true;            //删除成功
}

最坏、平均时间复杂度为O(n)

最好时间复杂度为O(1)

2.2指定结点的删除

//删除指定结点p
bool DeleteNode(LNode *p){
    if(p==NULL)
        return false;
    LNode *q=p->next;            //令q指向*p的后继结点
    p->data=p->next->data;        //和后继结点交换数据域
    p-next=q->next;            //将*q结点从链中断开
    free(q);                    //释放后继结点的存储空间
    return true;
}

单链表的局限性：无法逆向检索，有时候不太方便。

tips:

1.这些代码都要会写，都重要

2.打牢基础，慢慢加速

3.体会带头结点和不带头结点的区别

4.体会封装的好处