链表（2）----双链表基本操作

最新推荐文章于 2023-01-07 10:32:41 发布
原创 最新推荐文章于 2023-01-07 10:32:41 发布 · 1.7k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了双链表的基本操作，包括定义、初始化、插入、删除及销毁等关键步骤，并针对各种异常情况提供了处理方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、双链表定义

typedef struct DListElement_t_{
    void  *data;
    struct DListElement_t  *prev;
    struct DListElement_t *next;
} DListElement_t

typedef struct DList_t_{
    int size;
    int (*match)( const void *key1, const void *key2);
    int (*destroy)(void *data);
    DListElement_t *head;
    DListElement_t *tail;
} DList_t;


typedef struct DListElement_t_{

    void  *data;

    struct DListElement_t  *prev;

    struct DListElement_t *next;

} DListElement_t


typedef struct DList_t_{

    int size;

    int (*match)( const void *key1, const void *key2);

    int (*destroy)(void *data);

    DListElement_t *head;

    DListElement_t *tail;

} DList_t;


2、初始化

int  dlist_init( DList_t *dlist, int (*match)( const void *key1, const void *key2), int (*destroy)(void *data ))
{
    dlist->size = 0;
    dlist->match = match;
    dlist->destory = destory;
    dlist->head = NULL;
    dlist->tail = NULL;
    return 0;
}


int  dlist_init( DList_t *dlist, int (*match)( const void *key1, const void *key2), int (*destroy)(void *data ))

{

    dlist->size = 0;

    dlist->match = match;

    dlist->destory = destory;

    dlist->head = NULL;

    dlist->tail = NULL;

    return 0;

}


3、插入---在给定节点后面插入：

给定元素element，在其后插入数据data；

异常情况考虑：

（1）超过链表容量：

if( dlist_is_full( dlist))

      return OVERFLOW;

（2）节点空间申请不成功

if( new_element = (DListElement_t *)malloc( DListElement))) == NULL )

      return  ALLOCA_ERROR;


需要考虑的情况为：

（1）如果element为NULL，则在头结点插入：

         链表为空时：

         if( dlist_is_empty( dlist) )

                  dlist->head = dlist->tail = new_element;

        链表不为空：

       new_element->prev = dlist->head->prev;

       new_element->next = dlist->head;

       dlist->head->prev = new_element;

       dlist->head = new_element;


（2）如果element不为NULL，则在element之后插入：

       首先是将待插入节点的前后指针分别指向对应位置：

       new_element->prev = element;

       new_element->next = element->next;

       下面就是考虑element的后指针和它下一个节点的前指针

       需要考虑element是否为尾节点：

       if( dlist_is_tail(element)

               dlist->tail = new_element;

       else 

              element->next->prev = new_element;

        

       element->next = new_element;

       

int dlist_insert_next( DList_t *dlist, DListElement_t *element, const void *data){
    DListElement_t *new_element = NULL;
    if( (new_element = ( DListElement_t *)malloc( sizeof( DListElement_t ))) == NULL )
        return ALLOCA_ERROR;

    new_element->data = data;
    new_element->prev = NULL;
    new_element->next = NULL;

    if( element == NULL ){
        if ( dlist_is_empty(dlist)){
            dlist->head = new_element;
            dlist->tail = new_element;
        } else {
            new_element->next = dlist->head;
            dlist->head->prev = new_element;
            dlist->head = new_element;
       }
    }else{
        new_element->prev = element;
        new_element->next = element->next;

        if( dlist_is_tail ( element ) )
            dlist->tail = new_element;
        else
            element->next->prev = new_element;

        element->next = new_element;
    }

    dlist->size++;
    return 0;
}

      


int dlist_insert_next( DList_t *dlist, DListElement_t *element, const void *data){

    DListElement_t *new_element = NULL;

    if( (new_element = ( DListElement_t *)malloc( sizeof( DListElement_t ))) == NULL )

        return ALLOCA_ERROR;


    new_element->data = data;

    new_element->prev = NULL;

    new_element->next = NULL;


    if( element == NULL ){

        if ( dlist_is_empty(dlist)){

            dlist->head = new_element;

            dlist->tail = new_element;

        } else {

            new_element->next = dlist->head;

            dlist->head->prev = new_element;

            dlist->head = new_element;

       }

    }else{

        new_element->prev = element;

        new_element->next = element->next;


        if( dlist_is_tail ( element ) )

            dlist->tail = new_element;

        else

            element->next->prev = new_element;


        element->next = new_element;

    }


    dlist->size++;

    return 0;

}


4、插入----在给定节点之前插入

异常情况考虑：

（1）是否溢出，超出链表容量

       if（ dlist_is_full( dlist))

              return OVERFLOW;

（2）节点空间申请是否成功

      if(（ new_element = (DListElement_t *)malloc( sizeof( DListElement_t ) )) == NULL )

              return -1;

需要考虑的情况包括：

（1）如果element为NULL，或者element为头节点，则在头结点之前插入，需要维护头指针：

            如果此时链表为空，则需要同时维护头指针和尾指针：

            if( dlist_size (dlist) == 0 )

            {

                     dlist->head = new_element;

                     dlist->tail = new_element;

            }else{

                     new_element->next = dlist->head;

                     dlist->head->prev = new_element;

                     dlist->head = new_element;

            }


（2）如果element不为NULL， 则在element之前插入

                new_element->next = element;

                new_element->prev = element->prev;

                element->prev->next = new_element;

                element->next = new_element;


int dlist_insert_prev( DList_t *dlist, DListElement_t *element, const void *data){
    DListElement_t *new_element = NULL;
    if( ( new_element = ( DListElement_t *)malloc( sizeof( DListElement_t ))) == NULL )
        return ALLOCA_ERROR;

    new_element->data = data;
    new_element->prev = NULL;
    new_element->next = NULL;
    if( (element == NULL) || (dlist_is_head(element)){
        if( dlist_is_empty( dlist)){
            dlist->head = new_element;
            dlist->tail = new_element;
        } else {
            new_element->next = dlist->head;
            dlist->head->prev = new_element;
            dlist->head = new_element;
        }
     } else {
        new_element->next = element;
        new_element->prev = element->prev;
        element->prev->next = new_element;
        element->next = new_element;
    }

    dlist->size++;
    return 0;
}


int dlist_insert_prev( DList_t *dlist, DListElement_t *element, const void *data){

    DListElement_t *new_element = NULL;

    if( ( new_element = ( DListElement_t *)malloc( sizeof( DListElement_t ))) == NULL )

        return ALLOCA_ERROR;


    new_element->data = data;

    new_element->prev = NULL;

    new_element->next = NULL;

    if( (element == NULL) || (dlist_is_head(element)){

        if( dlist_is_empty( dlist)){

            dlist->head = new_element;

            dlist->tail = new_element;

        } else {

            new_element->next = dlist->head;

            dlist->head->prev = new_element;

            dlist->head = new_element;

        }

     } else {

        new_element->next = element;

        new_element->prev = element->prev;

        element->prev->next = new_element;

        element->next = new_element;

    }


    dlist->size++;

    return 0;

}



5、删除

删除指定元素element

异常情况：

链表为空，无法删除

if（dlist_is_empty( dlist) )

    return -1;


常规情况：

（1）若是element为NULL或者element为头结点，则删除头结点

        需要考虑链表长度为1时，需要维护头尾指针;否则需要维护第二个节点的前指针

        if( (element == NULL ) || ( dlist_is_head(element)){

            *data = dlist->head->data;

            del_element = dlist->head;

            if( dlist_size(dlist) == 1 ){

                dlist->head = NULL;

                dlist->tail = NULL;

            } else {

                dlist->head = dlist->head->next;

                dlist->head->prev = NULL;

            }

        }

（2）如果element为其他节点

        需要考虑删除尾节点时，维护尾指针

        *data = element->data;

        del_element = element;

        if ( dlist_is_tail( element)){

            dlist->tail = element->prev;

            dlist->tail->next = NULL;

        } else {

            element->prev->next = element->next;

            element->next->prev = element->prev;

        }

int  dlist_remove( DList_t *dlist, DListElement_t *element, void **data){
    if( dlist_is_empty( dlist) )
        return -1;

    DListElement_t *del_element = NULL;
    if( (element == NULL) || (dlist_is_head( element )){
        *data = dlist->head->data;
        del_element = dlist->head;
        
        if( dlist_size(dlist) == 1 )
        {
            dlist->head = NULL;
            dlist->tail = NULL;
        } else {
            dlist->head = dlist->head->next;
            dlist->head->prev = NULL;
        }
    } else {
        *data = element->data;
        del_element = element;

        if ( dlist_is_tail ( del_element) )
        {
            dlist->tail = element->prev;
            dlist->tail->next = NULL;
        } else {
            element->prev->next = element->next;
            element->next->prev = element->prev;
        }
    }
<p>    free( del_element);</p><p>    del_element = NULL;</p><p>    dlist->size--;
</p><p>    return 0;
</p><p>}</p><p>
</p>
    dlist->size--;
    return 0;
}



int  dlist_remove( DList_t *dlist, DListElement_t *element, void **data){

    if( dlist_is_empty( dlist) )

        return -1;


    DListElement_t *del_element = NULL;

    if( (element == NULL) || (dlist_is_head( element )){

        *data = dlist->head->data;

        del_element = dlist->head;

        

        if( dlist_size(dlist) == 1 )

        {

            dlist->head = NULL;

            dlist->tail = NULL;

        } else {

            dlist->head = dlist->head->next;

            dlist->head->prev = NULL;

        }

    } else {

        *data = element->data;

        del_element = element;


        if ( dlist_is_tail ( del_element) )

        {

            dlist->tail = element->prev;

            dlist->tail->next = NULL;

        } else {

            element->prev->next = element->next;

            element->next->prev = element->prev;

        }

    }


    dlist->size--;

    return 0;

}


6、销毁列表

int dlist_destroy( DList_t *dlist)
{
    void *data;
    while( dlist_size( dlist) > 0 ){
        if ( dlist_remove( dlist, NULL, (void **)&data) == 0  && dlist->destory != NULL )
            dlist->destory( data );
    }
    return 0;
}


int dlist_destroy( DList_t *dlist)

{

    void *data;

    while( dlist_size( dlist) > 0 ){

        if ( dlist_remove( dlist, NULL, (void **)&data) == 0  && dlist->destory != NULL )

            dlist->destory( data );

    }

    return 0;

}



其他相关题目下面以超链接形式给出：

链表面试题合集


1、单链表基本操作

2、双链表基本操作

3、循环单链表基本操作

4、反转单链表

5、查找单链表倒数第K个节点

6、倒序打印链表

7、查找链表中间节点

8、删除链表第K个节点，平均时间复杂度为O(1)

9、判断链表是否有环

10、判断两个单链表是否相交

11、求相交链表的第一个相交节点

12、判断是否有环，并判定是6型环还是0型环

13、判断链表是否有环，并求环入口节点

14、合并两个有序单链表

15、给定链表中间某节点，不遍历链表，将带插入节点插入给定节点之前

16、删除链表重复元素



双向链表的基本操作
Kuches的博客
03-08 520
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、初始化双线性链表二、双向链表的节点插入二、双向链表的节点删除三、双向链表的节点修改四、双向链表的打印总结 前言 对双线性链表进行一些基础操作 一、初始化双线性链表 利用尾插法建立一个双向链表 代码示例 void InitDList(DLinkList*L) { (*L)=(DLNode*)malloc(sizeof(DLNode)); (*L)->pre=NULL; (*L)->next=NULL;
双向链表-C语言实现代码
最新发布
08-03
在该实现中，包含了双向链表的基本操作，如初始化和销毁，这些操作是管理链表生命周期的必要环节。初始化操作主要是为链表分配内存并设置初始状态，而销毁操作则是释放链表占用的内存资源，以防止内存泄漏。 增删查...
双链表的基本操作
qq_44631587的博客
03-03 2864
带头结点的双向循环链表 链表结构如下： 每个节点都有一个数据域和两个指针域，这两个指针分别指向链表的前驱节点和后继节点，头节点的前驱节点是链表的最后一个节点，链表最后一个节点的后继节点是头节点。 正因为如此，带头结点的双向循环链表没有空节点，在进行遍历时，循环条件也与单链表不同： 单链表用cur->next为空判断当前节点是否为最后一个节点，带头的双向循环链表则需判断cur->next是否等于头节点。 定义： typedef int DataType; typedef struct ListN
循环单链表-双链表_循环单链表-双链表_throat6v2_
09-30
双链表的插入和删除操作通常比单链表更复杂，因为需要更新更多的指针，但它们提供了更多的灵活性。 双链表的主要操作包括： 1. 插入节点：在双链表中插入节点，需要同时更新前后两个相邻节点的指针。 2. 删除节点：...
双链表-循环链表-静态链表.pdf
04-14
接下来，我们将深入了解这三种链表的定义、特点和基本操作。 双链表是链表的一种形式，每个节点除了包含数据字段外，还拥有两个链接字段，分别指向前一个节点和后一个节点。这种结构使得双链表可以在两个方向上进行...
链表code-algorithm-linked-list-master
12-18
链表的基本操作包括创建节点、插入节点、删除节点和遍历链表。创建节点通常需要分配内存，并初始化节点数据和指针。插入节点可能发生在链表的头部、尾部或是链表中间的任意位置，其关键在于正确处理相邻节点的指针。...
链表----链表构造
01-17
#### 一、链表基本概念 链表是一种常见的线性数据结构，它通过节点之间的连接来表示数据项。与数组不同，链表中的元素不必存储在连续的内存空间中。每个节点包含两部分：数据部分（用于存储实际的数据）和指针部分...
双链表的基本操作（创建，插入，删除，读取等）
10-29
双链表基本操作的程序，（先在主程序内定义一个数组，再把数组内的元素作为结点一个个插入到链表内，显示链表内所有结点及链表长度，删除某一个结点，再次显示链表内所有结点以及链表长度）。
双链表基本操作
weixin_65259109的博客
01-07 272
双链表是在单链表的操作的基础上形成的，除了头插法、尾插法、插入、删除四个基本操作的代码略有不同外，其他的代码与单链表基本相同。以下展示双链表结点类构建、双链表类构建、头插法、尾插法、插入、删除的操作。
双向链表-非循环链表基本操作
03-24
基本的操作包括插入、删除和遍历。插入可以分为在表头插入和在表尾插入。删除可以根据节点值或节点位置进行。遍历可以从表头遍历到表尾，也可以从表尾遍历到表头。在编程语言中，可以用指针来实现双向链表的操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值