精简双向链表的插入代码

最新推荐文章于 2024-08-18 18:23:17 发布

原创最新推荐文章于 2024-08-18 18:23:17 发布 · 1.4k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#双向链表 #插入 #数据结构

数据结构专栏收录该内容

7 篇文章

订阅专栏

本文介绍了如何在双向链表中高效地插入节点，详细分析了四种不同情况下的插入过程，并逐步展示了如何通过代码优化减少冗余，提高代码简洁性。

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

在一个双向链表中，每个节点都包含两个指针—指向前一个节点的指针和指向后一个节点的指针。如下图所示：

其类型声明为：

typedef struct Node{

struct Node * fwd;

struct Node * bwd;

int value;

}Node;

同单向链表一样，我们同样需要一个root节点来遍历整个链表，其value字段不使用，当然你可以用它来保存其他一些关于链表的信息。根节点的fwd字段指向链表的第1个节点，根节点的bwd字段指向链表的最后一个节点。如果为空链表，这两个字段都为NULL。链表第1个节点的bwd字段和最后一个节点的fwd字段都为NULL。

介绍完基本结构后，下面说一下有序双向链表的插入过程。

当我们把一个节点插入到一个链表时，可能出现4中情况：

1.新值可能必须插入到链表的中间位置。

2新值可能必须插入到链表的起始位置。

3新值可能必须插入到链表的结束位置。

4链表为空。

在每种情况下，需要修改4个指针。

程序如下所示：

     1   int insert(Node *rootp,int value){
     2       Node *this;
     3       Node *next;
     4       Node *newNode;
     5
     6       /*check for if value is already in the list*/
     7       for(this = rootp;(next = this->fwd) != NULL; this = next){
     8          if(next->value == value)
     9              return 0;
    10          if(next->value > value)
    11              break;
    12       }
    13       newNode = (Node *)malloc(sizeof(Node));
    14       if(newNode == NULL)
    15           return -1;
    16       newNode->value = value;
    17       /*insert newNode into list*/
    18       if( next != NULL){ //for case 1 or 2
    19          if(this != rootp){ //for case 1
    20         newNode->fwd = next;
    21       this->fwd = newNode;
    22       newNode->bwd = this;
    23       next->bwd = newNode;
    24          }
    25          else{ //for case 2
    26         newNode->fwd = next;
    27       rootp->fwd = newNode;
    28       next->bwd = newNode;
    29       newNode->bwd = NULL:
    30          }
    31        }
    32        else{ //for case 3 or 4
    33           if(this != rootp){ //for case 3
    34          this->fwd = newNode;
    35          newNode->fwd = NULL;
    36          newNode->bwd = this;
    37          rootp->bwd = newNode;
    38           }
    39           else{ //for case 4
    40          rootp->fwd = newNode;
    41          newNode->fwd = NULL;
    42          rootp->bwd = newNode;
    43          newNode->bwd = NULL;
    44           }
    45        }
    46        return 1;
    47   }

这种想法是，开始时，函数使this指向根节点，next指针始终指向this之后的那个节点。这两个指针同步前进，直到新节点应该插入到这两者之间。上面的代码有很大的冗余，可以提炼成如下所示

    18       if( next != NULL){ //for case 1 or 2
    19          newNode->fwd = next;
    20          if(this != rootp){ //for case 1
    21       this->fwd = newNode;
    22       newNode->bwd = newNode;
    23          }
    24          else{ //for case 2
    25       rootp->fwd = newNode;
    26       newNode->bwd = NULL:
    27          }
    28          next->bwd = newNode;
    29        }
    30        else{ //for case 3 or 4
    31           newNode->fwd = NULL;
    32           if(this != rootp){ //for case 3
    33              this->fwd = newNode;
    34          newNode->bwd = this;
    35           }
    36           else{ //for case 4
    37          rootp->fwd = newNode;
    38          newNode->bwd = NULL;
    39           }
    40           rootp->bwd = newNode;
    41        }
代码是否就没有改变的余地了么？让我们看一下18，19，30，31

if( next != NULL)

newNode->fwd = next;

else

newNode->fwd = NULL;

这几句话就等价于newNode->fwd = next; 所以就可以把19，31变成newNode->fwd = next;放到最外面，现在你就会发现两个嵌套的if语句是相等的了，所以又可以提炼出来，这样代码就变成这样：

18    newNode->fwd = next;
19    if(this != rootp){ //for case 1
20       this->fwd = newNode;
21       newNode->bwd = this;
22    }
23    else{ //for case 2
24       rootp->fwd = newNode;
25       newNode->bwd = NULL:
26    }
27    if( next != NULL){ //for case 1 or 2
28       next->bwd = newNode;
29     }
30     else{ //for case 3 or 4
31        rootp->bwd = newNode;
32     }

经过观察，20，24同样可以合并成this->fwd = newNode; 所以最后代码应该为：

18    newNode->fwd = next;
19    this->fwd = newNode;
20    if(this != rootp){ //for case 1
21       newNode->bwd = this;
22    }
23    else{ //for case 2
24       newNode->bwd = NULL:
25    }
26    if( next != NULL){ //for case 1 or 2
27       next->bwd = newNode;
28     }
29     else{ //for case 3 or 4
30        rootp->bwd = newNode;
31     }

这就是经过提炼后的代码，较之第一个版本而言，体积上已经有大幅下降了。通过分析代码，找出逻辑上相同的代码，不断提炼，才能精简代码量。