算法精解（一）：C语言描述（链表）

1.链表认知

一场病，断了好久。这几天算是基本没什么问题了。是时候继续了。

链表我想可以认为是，点到线的过程。

一个个点就是一个个链表的节点，以特定的顺序组合或链接后，行成了一条线，即链表。所以添加，删除一个点是相对较容易的（因为可以动态的追加，删除节点），但是查找某个点相对较麻烦（数组中只需要a[i]即可取得数据，链表则需要遍历）。所以，对于未知大小长度的数据来说，具有相当的优势。但已知数据量来说，数组可能更好一些。

单链表

单链表(通常简称为链表)由各个元素之间通过一个指针彼此链接起来而组成。每个元素包含两部分:数据成员和一个称为nexr的指针。通过采用这种二成员结构,将每个元素的next指针设置为指向其后面的元素。最后一个元素的next指针置为NUL,简单地表示链表的尾端。链表开始处的元素是“头”,链表末尾的元素称为“尾。

简单来说，火车是最好理解的链表了。车头就是“头”，每节车厢里面装的人救赎数据，车厢后面连接下一个车厢的铁栓就是next指针。

单链表代码实现

#include<stdio.h>
#include<stdlib.h>
#include<string.h>typedef struct ListElmt   //定义节点
{void *data;struct ListElmt  *next;
};typedef struct List  //定义链表
{int size;int(*match)(const void *key1, const void *key2); //构造函数void(*destroy)(void *data);  //析构函数ListElmt *head;ListElmt *tail;
};void list_init(List *list, void(*destroy)(void *data));     //新建链表
void list_destroy(List *list);                             //移除链表中的元素
void list_size(List *list, void (*destroy)(void *data));    //链表长度
int list_ins_next(List *list, ListElmt *element, const void *data);  //尾插
int list_rem_next(List *list, ListElmt *element, void **data);   //移除#define list_is_head(list,element) ((element) == (list)->head ? 1:0)
#define list_is_tail(element) ((element)->next == NULL ? 1:0)//新建链表
void list_init(List *list, void(*destroy)(void *data))
{list->size = 0;list->destroy = destroy;list->head = NULL;list->tail = NULL;return;
}//销毁链表
void list_destroy(List *list)
{void *data;while (list->size > 0){if (list_rem_next(list, NULL, (void **)&data) == 0 && list->destroy != NULL){list->destroy(data); //循环删除元素}}memset(list, 0, sizeof(List));return;
}int list_ins_next(List *list, ListElmt *element, const void *data)
{ListElmt *new_element;if ((new_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL)return -1;new_element->data = (void *)data;if (element == NULL){if (list->size == 0){list->tail = new_element;}new_element->next = list->head;list->head = new_element;}else{if (element->next == NULL){list->tail = new_element;}new_element->next = element->next;element->next = new_element;}list->size++;return 0;
}//删除element后的一个元素
int list_rem_next(List *list, ListElmt *element, void **data)
{ListElmt *old_element;if (list->size == 0)return -1;if (element == NULL){*data = list->head->data;old_element = list->head->next;list->head = list->head->next;if (list->size == 1)list->tail = NULL;}else{if (element->next == NULL)return-1;*data = element->next->data;old_element = element->next;element->next = element->next->next;if (element->next == NULL){list->tail = element;}}free(old_element);list->size--;return 0;
}

双链表

双向链表,如同其名字所暗示的那样,链表元秦之间由两个指针链接。双向链表中的每元素都由3部分组成:除了数据成员和nexr指针外,每个元素还包含一个指向共前驱元素的指针,称为prev指针。双向链表的组成是这样的:将一些元素链接在一起使得每个元素的 next指针都指向其后继的元素,而每个元素的rev指针都指向其前驱元素。为了标识链表的头和尾,将第一个元素的prev指针和最后一个元素的nexr指针设置为NULL。要反向遍历整个双向链表,使用prev指针以从尾到头的顺序连续访问各个元素。因此,为每个元素増加了一个指针的代价,换来的是双向链表比单锥表提供了更为灵活的访问方式。当我们知道某个元素存储在链表中的某处时,我们可以明智地途择按照何种方式访问到它,这会非常有帮助。例如,双向链表的一种灵活性在于它提供了一种比单链表更直观的方式以移除一个元素

具体代码实现

#include<stdlib.h>
#include<string.h>
typedef struct DListElmt    //节点属性
{void *data;struct DListElmt *prev;struct DListElmt *next;
}DListElmt;typedef struct DList
{int size;int(*match)(const void *key1, const void *key2);void(*destroy)(void *data);DListElmt *head;DListElmt *tail;
}DList;#define dlist_is_head(element) ((element)->perv == NULL ? 1:0)  //是否是头
#define dlist_is_tail(element) ((element)->next == NULL ? 1:0)  //是否是尾//创建链表
void dlist_init(DList *list, void(*destroy)(void *data))
{list->size = 0;list->destroy = destroy;list->head = NULL;list->tail = NULL;return;
}//删除节点
int dlist_remove(DList *list, DListElmt *element, void **data)
{if (element == NULL || list->size == 0)return 1;*data = element->data;if (element == list->head)       //如果是头节点，则判空。{if (list->head == NULL)    //为空则是最后一个节点，清空连接list->tail = NULL;elseelement->next->prev = NULL;  //非空，则摘除节点，准备删除}else   //如果不是头结点，摘除。删除{element->prev->next = element->next; //删除节点的前一个指向删除节点的后一个if (element->next == NULL)    //判断是否为最后一个节点list->tail = element->prev;elseelement->next->prev = element->prev; //删除节点的后一个指向删除节点的前一个}free(element);list->size--;return 0;
}//删除链表
void dlist_destroy(DList *list)
{void *data;while (list->size > 0){if (dlist_remove(list, list->tail, (void **)&data) == 0&& list->destroy != NULL)//如果节点删除成功，则删除节点对应存储的数据list->destroy(data);}
}//尾插法
int dlist_ins_next(DList *list, DListElmt *element, const void *data)
{DListElmt *new_element;if (element == NULL && list->size != 0)return -1;if ((new_element = (DListElmt*)malloc(sizeof(DListElmt))) == NULL)return -1;new_element->data = (void *)data;if (list->size == 0)    //如果为链表头{list->head = new_element;list->head->prev = NULL;list->head->next = NULL;list->tail = new_element;}else{new_element->next = element->next;new_element->prev = element;if (element->next == NULL)list->tail = new_element;elseelement->next->prev = new_element;element->next = new_element;}list->size++;return 0;
}//头插法
int dlist_ins_prev(DList *list, DListElmt *element, const void *data)
{DListElmt *new_element;if (element == NULL  && list->size != 0)return -1;if ((new_element = (DListElmt*)malloc(sizeof(DListElmt))) == NULL)return -1;new_element->data = (void *)data;if (list->size == 0){list->head = new_element;list->head->prev = NULL;list->head->next = NULL;list->tail = new_element;}else{new_element->next = element;new_element->prev = element->prev;if (element->prev == NULL)list->head = new_element;elseelement->prev->next = new_element;element->prev = new_element;}list->size++;return 0;
}