双向链接表 linux

#ifndef __LIST_H__
#define __LIST_H__

typedef struct LIST LIST;
struct LIST
{
  LIST *next;
  LIST *prev;
};

typedef struct LIST_HEAD
{
  int count;
  LIST first;
} LIST_HEAD;

#define DO_LIST_INIT(name)     \
  { &(name),  &(name)}

#define LIST_INIT(head)        \
  LIST head = DO_LIST_INIT(head)

#define INIT_LIST(head)        \
  do { (head)->next = (head); (head)->prev = (head); } while (0)

// list is first member of struct
#define LIST_ITEM_PTR_CAST(list_ptr, item_type) ((item_type *)(list_ptr) )

// list is not first member of struct
#define LIST_ITEM_PTR(list_ptr, item_type, list_member) \
    ((item_type *)((char *)(list_ptr)-(unsigned int)(&((item_type *)0)->list_member)))

LIST * list_get_prev(LIST *entry);
LIST * list_get_next(LIST *entry);

unsigned int list_is_empty(LIST *head);
unsigned int list_is_empty_careful(LIST *head);
unsigned int list_is_last(LIST *entry, LIST *head);

void list_item_add(LIST_HEAD * head, LIST * item);
void list_item_del(LIST_HEAD * head, LIST * item);

void list_add_after_head(LIST *entry, LIST *head); // head entry ... tail
void list_add_before_head(LIST *entry, LIST *head); // entry head ... tail

void list_add_after(LIST *entry, LIST * where);
void list_add_before(LIST *entry, LIST * where);

void list_del_after_head(LIST *head);
void list_del_before_head(LIST *head);
void list_del(LIST *entry);

void list_splice_after_head(LIST * list, LIST * head);
void list_splice_before_head(LIST * list, LIST * head);

void list_replace(LIST *old, LIST *new);

void list_move_after_head(LIST *entry, LIST *head);
void list_move_before_head(LIST *entry, LIST *head);

void list_init(LIST *list); // INIT_LIST(list)

#endif /* __LIST_H__ */

 

 

#include "list.h"

unsigned int list_is_empty(LIST *head)
{
  return head->next == head;
}

unsigned int list_is_empty_careful(LIST *head)
{
  LIST *next = head->next;
  return ( next == head ) && ( next == head->prev );
}

unsigned int list_is_last(LIST *entry, LIST *head)
{
  return entry->next == head;
}

LIST * list_get_prev(LIST *entry)
{
  return entry->prev;
}

LIST * list_get_next(LIST *entry)
{
  return entry->next;
}

void __list_add(LIST *entry, LIST *prev, LIST *next)
{
  next->prev = entry;
  entry->next = next;
  entry->prev = prev;
  prev->next = entry;
}

// head entry ... tail
void list_add_after_head(LIST *entry, LIST *head)
{
  __list_add( entry, head, head->next );
}

// entry head ... tail
void list_add_before_head(LIST *entry, LIST *head)
{
  __list_add( entry, head->prev, head );
}

// ... where entry ...
void list_add_after(LIST *entry, LIST * where)
{
  list_add_after_head( entry, where );
}

// ... entry where ...
void list_add_before(LIST *entry, LIST * where)
{
  list_add_before_head( entry, where );
}

void __list_del(LIST *prev, LIST *next)
{
  next->prev = prev;
  prev->next = next;
}

// head [ **entry** ] ... tail
void list_del_after_head(LIST *head)
{
  __list_del( head, head->next );
}

// [ **entry** ] head ... tail
void list_del_before_head(LIST *head)
{
  __list_del( head->prev, head );
}

// ... [ **entry** ] ...
void list_del(LIST *entry)
{
  __list_del( entry->prev, entry->next );
  INIT_LIST( entry );
}

// prev : list->next list->prev : next
void __list_splice(const LIST *list, LIST *prev, LIST *next)
{
  LIST *first = list->next;
  LIST *last = list->prev;

  first->prev = prev;
  prev->next = first;

  last->next = next;
  next->prev = last;

}

// head list_tail ... list_head ... tail
void list_splice_after_head(LIST * list, LIST * head)
{
  if (!list_is_empty( list ))
  {
    __list_splice( list, head, head->next );
    INIT_LIST( list );
  }
}

// list_tail ... list_head --- head ... tail
void list_splice_before_head(LIST * list, LIST * head)
{
  if (!list_is_empty( list ))
  {
    __list_splice( list, head->prev, head );
    INIT_LIST( list );
  }
}

void list_replace(LIST *old, LIST *new)
{
  new->next = old->next;
  new->next->prev = new;
  new->prev = old->prev;
  new->prev->next = new;
  INIT_LIST( old );
}

// head --- entry --- ... --- tail
void list_move_after_head(LIST *entry, LIST *head)
{
  __list_del( entry, head );
  list_add_after_head( entry, head );
}

// head --- ... --- tail --- entry
void list_move_before_head(LIST *entry, LIST *head)
{
  __list_del( entry, head );
  list_add_before_head( entry, head );
}

void list_init(LIST *list)
{
  list->next = list;
  list->prev = list;
}

void list_item_add(LIST_HEAD * head, LIST * item)
{
  // head --> 0 --> 1 --> 2 --> 3 --> head
  list_add_before_head( item, & ( head->first ) );
  head->count++;
}

void list_item_del(LIST_HEAD * head, LIST * item)
{
  list_del( item );
  head->count--;
}

#define LIST_ITEM_COUNT ( 3 )
void list_demo(void)
{
  typedef struct ITEM
  {
    LIST list;
    int a;
  } ITEM;

  LIST_HEAD head;
  ITEM items [ LIST_ITEM_COUNT ];

  head.count = 0;
  INIT_LIST( &head.first );

  // head --> 0 --> 1 --> 2 --> 3 --> head
  for (unsigned int i = 0; i < LIST_ITEM_COUNT; i++)
  {
    list_item_add( &head, &items [ i ].list );
  }

  unsigned int i = 0;
  for (LIST * entry = head.first.next; entry != &head.first; entry =
    entry->next)
  {
    LIST_ITEM_PTR(entry, ITEM, list) ->a = i++;
    //LIST_ITEM_PTR_CAST(entry, ITEM) ->a = i++;
  }

  list_item_del( &head, &items [ LIST_ITEM_COUNT - 2 ].list );
  list_item_del( &head, &items [ LIST_ITEM_COUNT - 1 ].list );
  list_item_del( &head, &items [ 0 ].list );
}