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

     在上一篇文章中，我已经分析了单链表的结构及其建立。

      接下来，我将进一步分析单链表中的其他操作。

       首先，我们来看看如何实现查找现有链表中的某个元素或结点。很显然，我们可以遍历整个链表，并将遍历到的结点与要查找的结点进行比较，如果结果相同，表示查找成功。代码示例如下：

NameVal *FindSpecificItem( NameVal *SingleListPtr,  char *name )

 {

while( NULL != SingleListPtr )

{

if( 0 == strcmp( name, SingleListPtr->name ) )

{

return SingleListPtr;  //表示查找成功

}

SingleListPtr = SingleListPtr->next;//查找不成功，则继续遍历查找

}

return NULL; //查找失败

}

      算法时间复杂度为O(n). 有没有办法改进呢？ 答案是没有。即使链表已经排好序， 我们依然需要遍历才能查找到某个元素。在上篇文章，我们说过：二分查找对链表无效！

　　接下来，我们再分析下链表的其他操作。如：打印链表中的所有元素； 计算链表的长度等等。简单的办法是，我们可以逐一写函数实现之。经过分析，我们发现，这些操作都需要对链表进行遍历才能实现。有没有一种通用的办法来实现呢？ 答案是：ＹＥＳ！如何实现呢？

　　我们已经找到了共同点：遍历。遍历过程中具体要做什么，是千变万化的。可能是要查找某个元素，也可能是要打印元素，等等。我们可以提供一个通用的遍历操作，在操作中具体要做什么，由需求来决定。自然而然，我们想到了callback函数。

        什么是callback函数？遍历函数是用户（上层调用者）调用的，可实现为一个API接口。 在遍历过程中， 遍历函数需要回头调用具体用户（上层调用者）提供的函数来实现特定的需求或功能。这种回头调用调用者所提供的函数的方法，我们称之为回调函数或callback机制。

       实现回调函数，可分四步走：

      （1）定义要回调的函数指针类型

      （2）声明公用接口函数

      （3）实现上步中的接口函数

      （4）用户调用该callback函数

       有点难以理解，是不是？所谓实践出真知，下面我们通过具体的例子来深入理解上述四部曲的意义。

      第一步，定义要回调的函数指针类型： void ( *UserCallbackFunc ) ( void * , NameVal * );

      第二步， 声明公用接口函数：void CommonUtility( NameVal *SingleListPtr, UserCallbackFunc RequireFunc, void *ctx )//ctx 为回调函数的参数

      第三步，实现公用接口函数。代码如下：

void CommonUtility( NameVal *SingleListPtr, UserCallbackFunc RequireFunc, void *ctx )

{

       while( NULL != SingleListPtr )

       {

     RequireFunc( ctx, SingleListPtr );

    SingleListPtr = SingleListPtr->next; //则继续遍历查找 

}

}

          第四步，用户实现自己的需求函数并调用该callback函数。

         例如，我们要实现打印链表中的所有元素，我们可以实现一个自己的需求回调函数：

 void PrintAllElements( void *ctx, NameVal *SingleListPtr)

{

       char *format;

       format = (char * ctx;

       printf( format, SingleListPtr->name, SingleListPtr->value );

}

      之后，我们就可以在公用接口中回头调用该callback 函数。如下所示：

        CommonUtility( SingleListPtr, PrintAllElements,“%s: %x.\n”);

      用类似的办法，我们可以实现计算链表长度的callback函数。

 void CountLength( void *ctx, NameVal *SingleListPtr)

{

       int *ListLength;

       ListLength = (int * )ctx;

      (*ListLength)++;

}

调用方法：

int LengthOfList;

LengthOfList = 0;

 CommonUtility( SingleListPtr, CountLength, &LengthOfList);

             需要注意的是，这种采用一个公用接口函数的方法，虽然巧妙，但并不适用于所有情况。例如，如果需要销毁一个链表，如果继续采用以下方式代码就会出问题： 

void CommonUtility( SingleListPtr, FreeMemory, ctx )

{

       while( NULL != SingleListPtr )

       {

     FreeMemory( ctx, SingleListPtr );//假设这里把该结点释放了，并且它的后继结点在链表中存在

    SingleListPtr = SingleListPtr->next;//由于它的上一个结点内存已经释放了，就无法再指向下一个结点了，Memory can not be used after it has been freed.

}

}

        由此可见，这个公用接口函数已经失效了，或者说是有缺陷的。要修正这个缺陷，我们必须在释放结点内存前，用一个临时变量Buffer保存该结点的后继结点。然后在free内存之后再进行赋值.伪代码示例如下：

      

void CommonUtilityCorrect( SingleListPtr, FreeMemory, ctx )

{

      NameVal *Buffer;

       while( NULL != SingleListPtr )

       {

     Buffer = SingleListPtr->next;

    FreeMemory( ctx, SingleListPtr );//假设这里把该结点释放了，并且它的后继结点在链表中存在

    SingleListPtr = Buffer;//由于它的上一个结点内存已经释放了，就无法再指向下一个结点了，Memory can not be used after it has been freed.

}

}

 

        至此为止，我们已经分析了链表的建立（头插法、尾插法）、查找链表中某个元素、计算链表长度、销毁链表等操作;接下来，我们接着简单的介绍下链表中某个元素的插入、删除操作。

        首先，我们分析下删除操作。要删除链表中某个指定的结点，需要以下几个步骤：

（1）查找到待删除结点的前驱结点（prev）。伪代码示意如下：

                      prev = head;//prev初值设置为头指针

                      while( prev->next != SpecificNotePtr ) prev = prev->next; //查找*SpecificNotePtr 的前驱结点

（2）让前驱结点的后继指向待删除结点（SpecificNotePtr）的后继。这样，待删除结点就从链表中删除了。最后释放删除结点所占内存。

                       prev->next = SpecificNotePtr->next;

                       free(SpecificNotePtr);

         有时候，我们还需要删除指定结点的后继结点。同样可分为2步走：

（1）查找到后继结点（Successor）。实际上不需要查找，根据链表的特性，只需指向下一个就OK了：

                      Successor = SpecificNotePtr ->next

（2）让指定结点（SpecificNotePtr）的后继指向后继结点的后继。这样，待删除结点就从链表中删除了。最后释放删除结点所占内存。

                      SpecificNotePtr->next = Successor ->next;

                       free( Successor );

                  我们看一个实际使用的例子，根据某个指定的元素名称，删除该指定结点。完全依照上述规则，代码如下：       

NameVal *DelSpecificItem( NameVal *SingleListPtr,  char *name )

 {

       Nameval  *prev,*SpecificNotePtr ;

      prev = SingleListPtr;//初始值为链表头结点指针

     SpecificNotePtr = FindSpecificItem( &SingleListPtr,  &name );

    while( 0 != strcmp( name, prev ->next->name ) )

    {

            prev = prev ->next; //寻找“name" 对应结点的前驱结点

    }

      prev ->next = SpecificNotePtr ->next;

      free(SpecificNotePtr );//释放指定结点的空间

}

上述代码需要2个循环才能实现。可不可以一个循环就实现呢？可以的。只需要在FindSpecificItem地循环中保存下前驱结点指针就可实现。：       

      

 

NameVal *DelSpecificItem( NameVal *SingleListPtr,  char *name )

 {

       Nameval  *pBuf, *prev;

      pBuf = SingleListPtr;//初始值为链表头结点指针
      prev = NULL;
      if( NULL == pBuf )
      {
         printf("Error.Null List.\n");
         return;
      }

     while( NULL != pBuf) )

    {
           if( 0 == strcmp(name, pBuf->name ) )
           {
                    break;//找到结点，跳出循环
           }

          prev =  pBuf; //寻找“name" 对应结点的前驱结点
          pBuf=pBuf->next;

      }
   
     if ( prev != NULL )
            prev ->next = pBuf ->next;
     else
              pBuf = SingleListPtr;
      free( pBuf );//释放指定结点的空间

}

 

       我们再来分析下插入操作。在分析插入运算前，我们回顾下查找操作。前面我们分析的查找都是按值查找，实际上也可以进行按序号查找。各自的伪代码简单示例重写如下：

     ListNode *FindNodeByIndex(ListNode *head, int Index)

    {

           ListNode *p = head;//从头指针开始查找

           int j = 0;

          while( p ->next !=NULL &&  j <index)

           {

                      p=p->next;

                      j++;

            }

           if( j == index ) return p;

           else  return NULL;

    }

//按值查找,读者可与前面的实现作一番对比，差别较小

  ListNode *FindNodeByValue(ListNode *head, ElemType x)

    {

           ListNode *p = head->next;//从头指针开始查找

           while( p != NULL && p->data != x)

           {

                      p=p->next;

             }

         return p;

      }

      

                我们回到插入运算这个话题。插入运算可以分为后插和前插。后插，在指定结点和指定结点的后继结点之间插入；前插， 则是在指定结点和指定结点的前驱结点之间插入。插入操作使得链表长度增加了。后插可以按2步走：

（1）待插入的结点的后继指向已经知道的指定结点的后继。

（2）指定结点的后继修改为待插入结点。

           前插操作可用后插实现。即先实行后插，然后交换插入结点的数据与指定结点的数据。

           前插操作也可用以下步骤实现：

（1）先找到指定结点的前驱结点。

（2）然后再前驱结点和指定结点之间进行插入。

           例如，我们按index来进行插入，可用如下示例伪代码实现：（前插）

    ReturnType InsertNodeAfterIndex(ListNode *head, int Index, ElemType UserData)

    {

           ListNode *pSpecificNode, *NodeToInsert;//定义前驱结点和待插入结点

           int j = 0;

          pSpecificNode = FindNodeByIndex(head, Index); //查找第index-1个结点,即前驱结点

          if ( NULL == pSpecificNode  )

          {

                return ERROR;

          }

else

{

          NodeToInsert = ( ListNode * )malloc( sizeof(ListNode ) );

          NodeToInsert  ->data = UserData;

          NodeToInsert->next = pSpecificNode->next;

          pSpecificNode ->next = NodeToInsert;

          return OK;

}

    }

      至此，单链表的基本运算介绍完毕。