C语言实现双向链表操作

双向链表操作的主要实现在头文件里

list.h 头文件

#ifndef _LIST_H
#define _LIST_H

/* Basic type for the double-link list. */
struct list_head {
        struct list_head *next, *prev;
};

/* Define a variable with the head and tail of the list. */
#define LIST_HEAD(name) \
        struct list_head name = { &(name), &(name) }

/* Add new element at the head of the list. */
static inline
void list_add_entry(struct list_head *newp, struct list_head *head)
{
	newp->next = head->next;
	newp->prev = head;
	head->next->prev = newp;
	head->next = newp;
}

/* Add new element at the tail of the list. */
static inline
void list_add_tail_entry(struct list_head *newp, struct list_head *head)
{
	newp->next = head;
	newp->prev = head->prev;
	head->prev->next = newp;
	head->prev = newp;
}

/*
 * Replace an old entry with new entry.
 */
static inline
void list_replace_entry(struct list_head *old, struct list_head *_new)
{
	_new->next = old->next;
	_new->prev = old->prev;
	_new->prev->next = _new;
	_new->next->prev = _new;
}

/* Remove element from list. */
static inline
void list_del_entry(struct list_head *elem)
{
	elem->next->prev = elem->prev;
	elem->prev->next = elem->next;
}

/*
 * Iteration through all elements of the list must be done while list_read_lock()
 * is held.
 */

/* Get typed element from list at a given position. */
#define list_entry(ptr, type, member) \
        ((type *) ((char *) (ptr) - (unsigned long) (&((type *) 0)->member)))

/* Iterate forward over the elements of the list. */
#define list_for_each(pos, head) \
        for (pos = (head)->next; pos != (head); pos = pos->next)

/*
 * Iterate forward over the elements list. The list elements can be
 * removed from the list while doing this.
 */
#define list_for_each_safe(pos, p, head) \
        for (pos = (head)->next, p = pos->next; \
                pos != (head); \
                pos = p, p = pos->next)

/* Iterate backward over the elements of the list. */
#define list_for_each_prev(pos, head) \
        for (pos = (head)->prev; pos != (head); pos = pos->prev)

/*
 * Iterate backwards over the elements list. The list elements can be
 * removed from the list while doing this.
 */
#define list_for_each_prev_safe(pos, p, head) \
        for (pos = (head)->prev, p = pos->prev; \
                pos != (head); \
                pos = p, p = pos->prev)

#define list_for_each_entry(pos, head, member) \
        for (pos = list_entry((head)->next, __typeof__(*pos), member); \
                &pos->member != (head); \
                pos = list_entry(pos->member.next, __typeof__(*pos), member))

#endif /* _LIST_H */

test.c 测试程序源代码

#include <stdio.h>
#include <stdlib.h>

#include "list.h"

struct test_node
{
	int value;
	struct list_head node;
};

int main()
{
	int ret;
	int values[] ={1,2,3,4,5};
	struct test_node *test_entry, *query_entry;

	/* Initialize */
	LIST_HEAD(mylist);

	/* Add entries */
        for (int i = 0; i < 5; i++)
	{
         test_entry = (struct test_node *)malloc(sizeof(struct test_node));
         test_entry->value = values[i];
         list_add_tail_entry(&test_entry->node, &mylist);
    }

    printf("Check the List after adding:");
    list_for_each_entry(query_entry, &mylist, node)
	{
         printf(" %d", query_entry->value);
    }
    printf("\n");

	/* Replace entry */
	struct test_node *test_new = (struct test_node *)malloc(sizeof(struct test_node));
	test_new->value = 6;
	list_replace_entry(&test_entry->node, &test_new->node);

	free(test_entry);
	test_entry = NULL;

	printf("Check the List after replacing:");
    list_for_each_entry(query_entry, &mylist, node) {
        printf(" %d", query_entry->value);
    }
    printf("\n");

	/* Delete entry */
	list_del_entry(&test_new->node);
	printf("Check the List after deleting:");
    list_for_each_entry(query_entry, &mylist, node) {
        printf(" %d", query_entry->value);
    }
    printf("\n");

	return 0;
}

 

编译链接生成可执行文件：

gcc -g test.c -o test

输出结果：

Check the List after adding: 1 2 3 4 5
Check the List after replacing: 1 2 3 4 6
Check the List after deleting: 1 2 3 4