链表（Linked List）的C语言实现

链表中的各对象按线性顺序排列，而其顺序是由各个对象里的指针所决定的。

链表有多种形式，它可以是单链接的或者双链接的，可以是已排序的或未排序的，可以是循环的或非循环的。

定义的结构体以及函数如下：

typedef struct SINGLE_LINKED_LIST
{
Node * head;
Node * tail;
} SLL;
typedef struct CIRCULAR_SINGLE_LINKED_LIST
{
Node * head;
Node * tail;
} CSLL;
typedef struct DOUBLE_LINKED_LIST
{
Node * head;
Node * tail;
} DLL;
typedef struct CIRCULAR_DOUBLE_LINKED_LIST_WITH_SENTINEL
{
Node * nil;
} CDLLS;

void linked_list_traverse(Node * L);
void linked_list_free(Node* L);

Node* single_linked_list_insert(SLL * L, item_t item);
Node* single_linked_list_search(SLL * L, item_t item);
int single_linked_list_delete(SLL * L, Node * node);

Node* circular_single_linked_list_insert(CSLL * L, item_t item);
Node* circular_single_linked_list_search(CSLL * L, item_t item);
int circular_single_linked_list_delete(CSLL * L, Node * node);

Node* double_linked_list_insert(DLL * L, item_t  item);
Node* double_linked_list_search(DLL * L, item_t item);
int double_linked_list_delete(DLL * L, Node * node);

CDLLS* circular_double_linked_list_with_sentinel_init();
Node* circular_double_linked_list_with_sentinel_insert(CDLLS * L, item_t item);
Node* circular_double_linked_list_with_sentinel_search(CDLLS * L, item_t item);
int circular_double_linked_list_with_sentinel_delete(CDLLS * L, Node * node);

几个公共函数如下：

//functions for all kind of linked list
void linked_list_traverse(Node* L) {
if (L == NULL) {
printf("Empty Linked List.\n");
}
Node * pos = L;
while (pos != NULL) {
printf("%2d is in location:%9p. prev is %9p. next is %9p.\n", pos->item.key, \
pos, pos->prev, pos->next);
pos = pos->next;
if (pos == L) return;
}
}

void linked_list_free(Node* L) {
Node * pos = L;
Node * f = L;
while (pos != NULL && pos != L) {
f = pos;
pos = pos->next;
free(f);
}
}
//-----------------------------------------------------------------------

单链接的未排序非循环链表可以如如下实现：

//functions for single linked list
Node* single_linked_list_insert(SLL * L, item_t item) {
Node * node = (Node*)malloc(sizeof(Node));
node->item = item;
node->prev = NULL;
node->next = L->head;
if (L->tail == NULL)
L->tail = node;
L->head = node;
return node;
}
Node* single_linked_list_search(SLL * L, item_t item) {
if (L->head == NULL) {
fprintf(stderr, "The single linked list is empty.\n");
return NULL;
}
Node * pos = L->head;
while (pos != NULL) {
if (item.key == pos->item.key)
return pos;
pos = pos->next;
}
fprintf(stderr, "The item cannot be found.\n");
return NULL;
}
int single_linked_list_delete(SLL * L, Node * node) {
if (L->head == NULL) {
fprintf(stderr, "The single linked list is empty.\n");
return 0;
}
if (node == NULL) {
fprintf(stderr, "The node is NULL.\n");
return 0;
}
if (L->head == node) {
L->head = node->next;
if (L->head == NULL)
L->tail = NULL;
return 1;
}
Node * pos = L->head;
while (pos != NULL && pos->next != node) {
pos = pos->next;
}
if (pos->next = node) {
if (node == L->tail)
L->tail = pos;
pos->next = pos->next->next;
return 1;
}
fprintf(stderr, "No such node in linked list.\n");
return 0;
}
int single_linked_list_reverse(SLL * L) {
if (L->head == NULL) {
fprintf(stderr, "The single linked list is empty.\n");
return 0;
}
L->tail = L->head;
Node *pre, *current, *next;
pre = L->head;
current = L->head->next;
L->head->next = NULL;
next = NULL;
while (current != NULL) {
next = current->next;
current->next = pre;
pre = current;
current = next;
}
L->head = pre;
return 1;
}
//------------------------------------------------------------------------

各个函数的功能均可见其函数名与返回值。使用SLL时动态分配内存即可，如：

void test_for_single_linked_list() {
SLL * L = (SLL*)malloc(sizeof(SLL));
printf("%p\n", L->head);
item_t item = {10, NULL};
Node * node;
for (int i = 0; i < 10; i++) {
item.key = i + 10;
single_linked_list_insert(L, item);
}
printf("SLL head is in location:%p\n", L->head);
linked_list_traverse(L->head);
single_linked_list_reverse(L);
linked_list_traverse(L->head);
for (int i = -1; i <= 10; i++) {
item.key = i + 10;
node = single_linked_list_search(L, item);
if (node != NULL)
printf("Node %d in location %p delete :%d\n", node->item.key, node, \
single_linked_list_delete(L, node));
//printf("SLL tail is in location:%p\n", L->tail);
}
printf("---------------------------------------------\n");
for (int i = 0; i < 10; i++) {
item.key = i + 10;
single_linked_list_insert(L, item);
}
printf("SLL head is in location:%p\n", L->head);
linked_list_traverse(L->head);
for (int i = 11; i >= -1; i--) {
item.key = i + 10;
node = single_linked_list_search(L, item);
if (node != NULL)
printf("Node %d in location %p delete :%d\n", node->item.key, node, \
single_linked_list_delete(L, node));
//printf("SLL tail is in location:%p\n", L->tail);
}
linked_list_free(L->head);
free(L);
}

双链接的未排序非循环链表可如如下实现：

//functions for double linked list
Node* double_linked_list_insert(DLL * L, item_t item) {
Node * node = (Node*)malloc(sizeof(Node));
node->prev = NULL;
node->item = item;
node->next = L->head;
if (L->head != NULL)
L->head->prev = node;
else
L->tail = node;
L->head = node;
return node;
}
Node* double_linked_list_search(DLL * L, item_t item) {
if (L->head == NULL) {
fprintf(stderr, "The double linked list is empty.\n");
return NULL;
}
Node * pos = L->head;
while (pos != NULL) {
if (pos->item.key == item.key)
return pos;
pos = pos->next;
}
fprintf(stderr, "The item cannot be found.\n");
return NULL;
}
int double_linked_list_delete(DLL * L, Node * node) {
if (L->head == NULL) {
fprintf(stderr, "The double linked list is empty.\n");
return 0;
}
if (node == NULL) {
fprintf(stderr, "The node is NULL.\n");
return 0;
}
if (node == L->tail)
L->tail = node->prev;
if (node->prev != NULL) {
node->prev->next = node->next;
} else {
L->head = node->next;
}
if (node->next != NULL) {
node->next->prev = node->prev;
}
return 1;
}
//----------------------------------------------------------------------------

注意要点与单链接的未排序非循环链表相同。测试可如下：

void test_for_double_linked_list() {
DLL * L = (DLL*)malloc(sizeof(DLL));
printf("%p\n", L->head);
item_t item = {10, NULL};
Node * node;
for (int i = 0; i < 10; i++) {
item.key = i + 10;
double_linked_list_insert(L, item);
}
printf("DLL head is in location:%p\n", L->head);
linked_list_traverse(L->head);
for (int i = -1; i <= 10; i++) {
item.key = i + 10;
node = double_linked_list_search(L, item);
if (node != NULL)
printf("Node %d in location %p delete :%d\n", node->item.key, node, \
double_linked_list_delete(L, node));
//printf("DLL tail is in location:%p\n", L->tail);
}
printf("---------------------------------------------\n");
for (int i = 0; i < 10; i++) {
item.key = i + 10;
double_linked_list_insert(L, item);
}
printf("DLL head is in location:%p\n", L->head);
linked_list_traverse(L->head);
for (int i = 11; i >= -1; i--) {
item.key = i + 10;
node = double_linked_list_search(L, item);
if (node != NULL)
printf("Node %d in location %p delete :%d\n", node->item.key, node, \
double_linked_list_delete(L, node));
//printf("DLL tail is in location:%p\n", L->tail);
}
linked_list_free(L->head);
free(L);
}

单链接未排序的循环链表可如如下实现：

//functinos for circular single linked list
Node* circular_single_linked_list_insert(CSLL * L, item_t item) {
Node * node = (Node*)malloc(sizeof(Node));
node->item = item;
node->prev = NULL;
if (L->head == NULL) {
L->head = node;
L->tail = node;
node->next = node;
} else {
node->next = L->head;
L->head = node;
L->tail->next = node;
}
return node;
}
Node* circular_single_linked_list_search(CSLL * L, item_t item) {
if (L->head == NULL) {
fprintf(stderr, "The circular single linked list is empty.\n");
return NULL;
}
Node * pos = L->head;
if (pos->item.key == item.key)
return pos;
else
pos = pos->next;
while (pos->item.key != item.key && pos != L->head) {
pos = pos->next;
}
if (pos != L->head)
return pos;
fprintf(stderr, "The item cannot be found.\n");
return NULL;
}
int circular_single_linked_list_delete(CSLL * L, Node * node) {
if (L->head == NULL) {
fprintf(stderr, "The circular single linked list is empty.\n");
return 0;
}
if (node == NULL) {
fprintf(stderr, "The node is NULL.\n");
return 0;
}
if (node == L->head && node == L->tail) {
L->head = NULL;
L->tail = NULL;
return 1;
} else if (node == L->head) {
L->head = node->next;
L->tail->next = L->head;
return 1;
}
Node * pos = L->head;
while (pos->next != node && pos != L->tail) {
pos = pos->next;
}
if (pos->next == node) {
if (node == L->tail) {
L->tail = pos;
}
pos->next = node->next;
return 1;
}
fprintf(stderr, "No such node in linked list.\n");
return 0;
}
//------------------------------------------------------------------------

测试可如下：

void test_for_circular_single_linked_list() {
CSLL * L = (CSLL*)malloc(sizeof(CSLL));
printf("%p\n", L->head);
item_t item = {10, NULL};
Node * node;
for (int i = 0; i < 10; i++) {
item.key = i + 10;
circular_single_linked_list_insert(L, item);
}
printf("CSLL head is in location:%p\n", L->head);
linked_list_traverse(L->head);
for (int i = -1; i <= 10; i++) {
item.key = i + 10;
node = circular_single_linked_list_search(L, item);
if (node != NULL)
printf("Node %d in location %p delete :%d\n", node->item.key, node, \
circular_single_linked_list_delete(L, node));
//linked_list_traverse(L->head);
}
printf("---------------------------------------------\n");
for (int i = 0; i < 10; i++) {
item.key = i + 10;
circular_single_linked_list_insert(L, item);
}
printf("CSLL head is in location:%p\n", L->head);
linked_list_traverse(L->head);
for (int i = 11; i >= -1; i--) {
item.key = i + 10;
node = circular_single_linked_list_search(L, item);
if (node != NULL)
printf("Node %d in location %p delete :%d\n", node->item.key, node, \
circular_single_linked_list_delete(L, node));
}
linked_list_free(L->head);
free(L);
}

有哨兵的双链接未排序循环链表可如如下实现：

//functions for cicular double linked list with sentinel
CDLLS* circular_double_linked_list_with_sentinel_init() {
CDLLS * L = (CDLLS*)malloc(sizeof(CDLLS));
L->nil = (Node*)malloc(sizeof(Node));
L->nil->next = L->nil;
L->nil->prev = L->nil;
return L;
}
Node* circular_double_linked_list_with_sentinel_insert(CDLLS * L, item_t item) {
Node * node = (Node*)malloc(sizeof(Node));
node->item = item;
node->next = L->nil->next;
L->nil->next->prev = node;
node->prev = L->nil;
L->nil->next = node;
return node;
}
Node* circular_double_linked_list_with_sentinel_search(CDLLS * L, item_t item) {
if (L->nil->next == L->nil) {
fprintf(stderr, "The circular double linked list is empty.\n");
return NULL;
}
Node* pos = L->nil->next;
while (pos != L->nil && pos->item.key != item.key) {
pos = pos->next;
}
if (pos == L->nil) {
fprintf(stderr, "The item cannot be found.\n");
return NULL;
} else {
return pos;
}
}
int circular_double_linked_list_with_sentinel_delete(CDLLS * L, Node * node) {
if (L->nil->next == L->nil) {
fprintf(stderr, "The circular double linked list is empty.\n");
return 0;
}
if (node == NULL) {
fprintf(stderr, "The node is NULL.\n");
return 0;
}
node->prev->next = node->next;
node->next->prev = node->prev;
return 1;
}
//--------------------------------------------------------------------------

测试可如下：

void test_for_circular_double_linked_list() {
CDLLS * L = circular_double_linked_list_with_sentinel_init();
printf("%p %p %p %p\n", L, L->nil, L->nil->prev, L->nil->prev);
item_t item = {10, NULL};
Node * node;
for (int i = 0; i < 10; i++) {
item.key = i + 10;
circular_double_linked_list_with_sentinel_insert(L, item);
}
printf("CDLLS nil is in location:%p\n", L->nil);
linked_list_traverse(L->nil);
for (int i = -1; i <= 10; i++) {
item.key = i + 10;
node = circular_double_linked_list_with_sentinel_search(L, item);
if (node != NULL)
printf("Node %d in location %p delete :%d\n", node->item.key, node, \
circular_double_linked_list_with_sentinel_delete(L, node));
}
printf("---------------------------------------------\n");
for (int i = 0; i < 10; i++) {
item.key = i + 10;
circular_double_linked_list_with_sentinel_insert(L, item);
}
printf("CDLLS nil is in location:%p\n", L->nil);
linked_list_traverse(L->nil);
for (int i = 11; i >= -1; i--) {
item.key = i + 10;
node = circular_double_linked_list_with_sentinel_search(L, item);
if (node != NULL)
printf("Node %d in location %p delete :%d\n", node->item.key, node, \
circular_double_linked_list_with_sentinel_delete(L, node));
}
linked_list_free(L->nil);
free(L);
}

可以将其看为含有哨兵的一个循环的圆圈，这样理解比较方便。