数据结构学习笔记之链表分析与实现（三）

 

        在前面2篇文章，我们简单介绍了单链表的基本运算及其实现。同时，我们还介绍了回调函数。并将公共接口函数抽象出来，具体应用由用户提供回调函数来实现。此外，我们也注意到，采用上节提到的回调机制，当要释放链表所有元素的内存空间时，将带来些不方便或者无法直接使用。

       有没有办法让这种回调机制进行更大一步的改善呢？当然有。本文参考了李先静前辈的《系统程序员成长计划》一书，并加入些自己的见解。与该书一致，本文也以双向链表的实现为载体进行深入探讨和分析。

       本文引用的C语言代码采用了封装机制。为什么要封装？总体来说，封装主要有以下两大好处(具体影响后面再说):

       隔离变化。程序的隐私通常是程序最容易变化的部分，比如内部数据结构，内部使用的函数和全局变量等等，把这些代码封装起来，它们的变化不会影响系统的其它部分。

      降低复杂度。接口最小化是软件设计的基本原则之一，最小化接口容易被理解和使用。封装内部实现细节，只暴露最小的接口，会让系统变得简单明了，在一定程度上降低了系统的复杂度。

     如何封装？

隐藏数据结构

      暴露内部数据结构，会使头文件看起来杂乱无章，让调用者发蒙。其次是如果调用者图方便，直接访问这些数据结构的成员，会造成模块之间紧密耦合，给以后的修改带来困难。隐藏数据结构的方法很简单，如果是内部数据结构，外面完全不会引用，则直接放在C文件中就好了，千万不要放在头文件里。如果该数据结构在内外都要使用，则可以对外暴露结构的名字，而封装结构的实现细节，做法如下：

在头文件中声明该数据结构。

如：
struct _LrcPool;
typedef struct _LrcPool LrcPool;

在C文件中定义该数据结构。

      struct _LrcPool
      {
          size_t unit_size;
          size_t n_prealloc_units;
      };
      

提供操作该数据结构的函数，哪怕只是存取数据结构的成员，也要包装成相应的函数。

如：
void* lrc_pool_alloc(LrcPool* thiz);
void lrc_pool_free(LrcPool* thiz, void* p);

提供创建和销毁函数。因为只是暴露了结构的名字，编译器不知道它的大小(所占内存空间)，外部可以访问结构的指针(指针的大小的固定的)，但不能直接声明结构的变量，所以有必要提供创建和销毁函数。

如：
这样是非法的：LrcPool lrc_pool;
应该对外提供创建和销毁函数。
LrcPool* lrc_pool_new(size_t unit_size, size_t n_prealloc_units);
void lrc_pool_destroy(LrcPool* thiz);

任何规则都有例外。有些数据结构纯粹是社交型的，为了提高性能和方便起见，常常不需要对它们进行封装，比如点(Point)和矩形(Rect)等。当然封装也不是坏事，MFC就对它们作了封装，是否需要封装要根据具体情况而定。

隐藏内部函数

       内部函数通常实现一些特定的算法(如果具有通用性，应该放到一个公共函数库里)，对调用者没有多大用处，但它的暴露会干扰调用者的思路，让系统看起来比实际的复杂。函数名也会污染全局名字空间，造成重名问题。它还会诱导调用者绕过正规接口走捷径，造成不必要的耦合。隐藏内部函数的做法很简单：

在头文件中，只放最小接口函数的声明。

在C文件上，所有内部函数都加上static关键字。

禁止全局变量

      除了为使用单件模式(只允许一个实例存在)的情况外，任何时候都要禁止使用全局变量。这一点我反复的强调，但发现初学者还是屡禁不止，为了贪图方便而使用全局变量。请读者从现在开始就记住这一准则。

全局变量始终都会占用内存空间，共享库的全局变量是按页分配的，那怕只有一个字节的全局变量也占用一个page，所以这会造成不必要空间浪费。全局变量也会给程序并发造成困难，想把程序从单线程改为多线程将会遇到麻烦。重要的是，如果调用者直接访问这些全局变量，会造成调用者和实现者之间的耦合。

在整个系统程序员成长计划中，我们都是以面向对象的方式来设计和实现的(封装就是面向对象的主要特点之一。

 

     下面，我们具体进行双向链表的实现进行分析.在头文件中，李先静老师是这么做的：

#include

#ifndef DLIST_H
#define DLIST_H

#ifdef __cplusplus
extern "C" {
#endif/*__cplusplus*/

typedef enum _DListRet
{
 DLIST_RET_OK,
 DLIST_RET_OOM,
 DLIST_RET_STOP,
 DLIST_RET_PARAMS,
 DLIST_RET_FAIL
}DListRet;

struct _DList;
typedef struct _DList DList;

typedef void (*DListDataDestroyFunc)(void* ctx, void* data);

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifdef __cplusplus
}
#endif/*__cplusplus*/

#endif/*DLIST*/

          可见，在头文件中定义了双向链表的基本操作。包括链表结点的创建、链表结点的插入、删除、查找以及链表的建立和销毁。

          我们先看下双向链表的结构：  

typedef struct _DListNode
{
    struct _DListNode* prev;
    struct _DListNode* next;

    void* data;
}DListNode;

 

struct _DList
{
    DListNode* first;
    DListDataDestroyFunc data_destroy;
    void* data_destroy_ctx;
};

1. 双向链表中结点的插入

            设P指向双向链表中某结点， s指向待插入的值为X的新结点，将*s插入到*p的前面：

步骤如下：

（1）s->prev = p->prev

（2）p->prev->next =s

（3）s->next = p

（4）p->prev = s

指针操作的顺序不是唯一的。但是第一步必须放到第四部前完成，否者p的前驱结点的指针就丢掉了。

下面我们按照上述原理分析李先静前辈的代码：

DListRet dlist_insert(DList* thiz, size_t index, void* data)
{
          DListNode* NodeToInsert = NULL;  //定义待插入结点
         DListNode* NodeToInsertBefore= NULL;  //在该指定结点之前插入,也就是待插入结点的后继结点

          if( ( NodeToInsert= dlist_create_node(thiz, data ) ) == NULL ) //根据传入数据，创建待插入结点
         {
               return DLIST_RET_OOM;   //创建待插入结点失败！

        }

        if(thiz->first == NULL)  

        {
             thiz->first = NodeToInsert; //如果第一个结点为空，把该结点插入到第一个结点

             return DLIST_RET_OK;
        }

        NodeToInsertBefore= dlist_get_node(thiz, index, 1);  //查找要插入的结点的指针位置，也就是说在该结点指针之前插入

        if(index < dlist_length(thiz))  //如果索引序号值小于链表长度，则是在链表中插入

       {
              if(thiz->first == NodeToInsertBefore) //如果第一个结点就是插入位置
             {
                    thiz->first = NodeToInsert;  //则把第一个结点替换为待插入结点            

             }
            else
            {
                   NodeToInsertBefore->prev->next = NodeToInsert; //前面讲述规则的第二步，使得指定结点的前驱的后继指向待插入结点
                   NodeToInsert->prev = NodeToInsertBefore->prev; //前面讲述规则的第一步，使得待插入结点的前驱指向指定结点的前驱
            }
           NodeToInsert->next = NodeToInsertBefore;  //前面讲述规则的第三步，使得待插入结点的后继指向指定结点

          NodeToInsertBefore->prev = NodeToInsert;  //前面讲述规则的第四步，使得指定结点的前驱指向待插入结点
      }
     else  //如果索引序号值大于或等于链表长度，说明是在链表末尾插入
    {
         NodeToInsertBefore->next = NodeToInsert;
         NodeToInsert->prev = cursor;
     }

    return DLIST_RET_OK;
}

 

1. 双向链表中结点的删除

            设P指向双向链表中某结点， 将P从链表从删除：

步骤如下：

（1）p->prev->next = p->next， 修改前驱结点的后继结点

（2）p->next->prev =p->prev，修改后继结点的前驱结点

   （3） free(P) 释放内存空间

下面我们按照上述原理分析李先静前辈的代码：

 

DListRet dlist_delete(DList* thiz, size_t index)
{
         DListNode* NodeToDel= dlist_get_node(thiz, index, 0); //查找待删除结点

        if(  NodeToDel!= NULL )
       {
               if( NodeToDel == thiz->first ) //如果待删除结点是第一个结点
              {
                     thiz->first = NodeToDel->next; //那么直接使得第一个结点指针指向待删除结点
              }

              if( NodeToDel->next != NULL ) //如果待删除结点有后继结点

              {
                    NodeToDel->next->prev = NodeToDel->prev;  //前面所述规则的第二步，修改后继结点的前驱结点
              }

              if( NodeToDel->prev != NULL )  //如果待删除结点有前驱结点
              {
                       cursor->prev->next = cursor->next; //前面所述规则的第一步，修改前驱结点的后继结点
               }

                dlist_destroy_node(thiz, cursor);   //释放内存空间， 前面所述规则的第三步
         }

         return DLIST_RET_OK;
}