编程中常用的重要的数据结构实现（二）之链表

typedef struct clist_cell_s {

 void* data;

struct clist_cell_s* prev;

struct clist_cell_s* next;

}clist_cell;

 

struct clist_s{

 clist_cell* first;

 clist_cell* last;

 int count;

};

typedef struct clist_s clist;

typedef clist_cell clistiter;

 

clist* clist_new(void)

{

      clist* lst = (clist*) malloc (sizeof(clist));

     if (NULL == lst)

         return NULL;

    lst->count = 0;

   lst->first = lst->last = NULL;

  return lst;

}

void clist_free(clist* lst)

{

      clistiter* iter = lst->first;

      clistiter* next;

      while(iter)

     {

          next = iter->next;

          free(iter);

          iter = next;

     }

   free(lst);

}

int clist_empty(clist* lst)

{

        return ((lst->first == lst->last) && (lst->last == NULL));

} 

int clist_count(clist* lst)

{

    return lst->count;

}

clistiter* clist_begin(clist* lst)

{

     return lst->first;

}

clistiter* clist_end(clist* lst)

{

      return lst->last;

}

clistiter* clist_next(clistiter* iter)

{ 

       if(iter)

           return iter->next;

      else

          return NULL;

}

clistiter* clist_previous(clistiter* iter)

{

      if (iter)

            return iter->prev;

      else

          return NULL;

}

void* clist_content(clistiter* iter)

{

     if (iter)

        return iter->data;

     else

         return NULL;

}

int clist_prepend(clist* lst,  void* data)

{

      clistiter* cell = (clistiter*)malloc(sizeof(clistiter));

      if (NULL == cell)

          return -1;

      cell->data = data;

      cell->next = cell->prev = NULL;

      if (clist_empty(lst) )

      {

              lst->first = lst->last = cell;

             lst->count++;

      }

     else

     {

            lst->first->prev = cell;

           cell->next = lst->first;

            lst->first = cell;

           lst->count ++;

      }

      return 0;

}

 

int clist_append(clist* lst,  void* data)

{

        clistiter* cell = (clistiter*)malloc(sizeof(clistiter));

        if (NULL == cell)

             return -1;

       cell->data = data;

       cell->next = NULL;

       cell->prev = NULL;

       if (clist_empty(lst))

      {

              lst->first = lst->last = cell;

              lst->count ++;

      }

     else

      {

             lst->last->next = cell;

             cell->prev = lst->last;

              lst->last = cell;

             lst->count++;

      }

     return 0;

}     

clistiter* clist_delete(clist* lst,  clistiter* iter)

{

         clistiter*  ret;

         if (NULL == iter)

              return NULL;

        if (lst->prev == NULL)

       {

              lst->fist = iter->next;

       }

      else

      {

            iter->prev->next = iter->next;

      }

      if (iter->next == NULL)

      {

              lst->last = iter->prev;

              ret = NULL;

      }

      else

      {

              ret = iter->next;

              iter->next->prev = iter->prev;

      }

    free(iter);

    lst->count--;

    return ret;

}

typedef void* (*clist_func) (void* ,  void*);

void clist_foreach(clist* lst,  clist_func func,   void* data)   /*有助于释放节点的data数据*/

{

        clistiter* iter;

       for ( iter = clist_begin(lst);  iter != NULL;     iter = clist_next(iter) )

      {

                   func(iter->data, data);

      }

}

如： clist_foreach(lst,   (clist_func)free,  NULL)  /*清除每个节点的data所指内存*/

          clist_free(lst);   /*清除每个节点及全局节点*/

 

一般的链表机构的实现都包括： 申请， 释放， 添加，删除， 返回指定节点的前一个，下一个节点以及节点的data， 链表的节点个数， 链表是否为空。链表的起始及结束位置等。 还可以根据以上的实现视具体情况扩展。