数据结构-链表

链表

单向链表

有的时候，处于内存中的数据并不是连续的。那么这时候，我们就需要在数据结构中添加一个属性，这个属性会记录下面一个数据的地址。有了这个地址之后，所有的数据就像一条链子一样串起来了，那么这个地址属性就起到了穿线连结的作用。
相比较普通的线性结构，链表结构的优势：
（1）单个节点创建非常方便，普通的线性内存通常在创建的时候就需要设定数据的大小
（2）节点的删除非常方便，不需要像线性结构那样移动剩下的数据
（3）节点的访问方便，可以通过循环或者递归的方法访问到任意数据，但是平均的访问效率低于线性表

链表的数据结构

typedef struct _LINK_NODE
{
    int data;
	struct _LINK_NODE* next;
}LINK_NODE;

创建链表

LINK_NODE* alloca_node(int value)
{
    LINK_NODE* pLinkNode = NULL;
	pLinkNode = (LINK_NODE*)malloc(sizeof(LINK_NODE));
	
	pLinkNode->data = value;
	pLinkNode->next = NULL;
	return pLinkNode;
}

删除链表

void delete_node(LINK_NODE** pNode)
{
    LINK_NODE** pNext;
    if(NULL == pNode || NULL == *pNode)
	    return ;
		
	pNext = &(*pNode)->next;
	free(*pNode);
	delete_node(pNext);	
}    

链表插入数据

STATUS _add_data(LINK_NODE** pNode, LINK_NODE* pDataNode)
{
    if(NULL == *pNode){
	    *pNode = pDataNode;
		return TRUE;
	}
	
	return _add_data(&(*pNode)->next, pDataNode);
}

STATUS add_data(const LINK_NODE** pNode, int value)
{
    LINK_NODE* pDataNode;
    if(NULL == *pNode)
	    return FALSE;
		
	pDataNode = alloca_node(value);
	assert(NULL != pDataNode);
	return _add_data((LINK_NODE**)pNode, pDataNode);
}

删除数据

STATUS _delete_data(LINK_NODE** pNode, int value)
{
    LINK_NODE* pLinkNode;
    if(NULL == (*pNode)->next)
	    return FALSE;
	
	pLinkNode = (*pNode)->next;
	if(value == pLinkNode->data){
	    (*pNode)->next = pLinkNode->next;
		free(pLinkNode);
		return TRUE;
	}else{
	    return _delete_data(&(*pNode)->next, value);
	}
}

STATUS delete_data(LINK_NODE** pNode, int value)
{
    LINK_NODE* pLinkNode;
    if(NULL == pNode || NULL == *pNode)
	    return FALSE;

    if(value == (*pNode)->data){
	    pLinkNode = *pNode;
		*pNode = pLinkNode->next;
		free(pLinkNode);
		return TRUE;
	}		
	
	return _delete_data(pNode, value);
}

查找数据

LINK_NODE* find_data(const LINK_NODE* pLinkNode, int value)
{
    if(NULL == pLinkNode)
	    return NULL;
	
	if(value == pLinkNode->data)
	    return (LINK_NODE*)pLinkNode;
	
	return find_data(pLinkNode->next, value);
}

打印数据

void print_node(const LINK_NODE* pLinkNode)
{
    if(pLinkNode){
	    printf("%d\n", pLinkNode->data);
		print_node(pLinkNode->next);
	}
} 

统计数据

int count_node(const LINK_NODE* pLinkNode)
{
    if(NULL == pLinkNode)
	    return 0;
		
	return 1 + count_node(pLinkNode->next);
}

双向链表

（1）在数据结构中具有双向指针
（2）插入数据的时候需要考虑前后的方向的操作
（3）同样，删除数据的是有也需要考虑前后方向的操作

双向链表的基本结构

linux内核的耍功能双向链表
位置位于./usr/src/linux-2.6.32.9/include/linux/list.h

struct bothlist
{
	struct bothlist *next;
	struct bothlist *prev;
};

list_head结构体基本结构

//list_head结构体
struct list_head {
	struct list_head *next, *prev;
};
#define LIST_HEAD_INIT(name) { &(name), &(name) }

此结构体所构成的链表如上面的双向循环链表图示
此结构体在linux内核中被大量的引用，几乎所有内核当中需要构成链表结构的地方都用到了这个结构体。例如内核的总线设备就用到了这个结构体
需要注意的一点是，头结点head是不使用的，这点需要注意。

LIST_HEAD() – 生成一个名为name的双向链表头节点

list_head不是拿来单独用的，它一般被嵌到其它结构中

typedef struct {
    void *data;
    struct list_head list;
} my_list_t;

有了结构体就是成员构造,定义结构体
这里有两种不同的初始化方法
LIST_HEAD是直接定义并初始化
INIT_LIST_HEAD 是先定义然后初始化

struct list_head head_class;
INIT_LIST_HEAD(&head_class);

typedef struct usrList
{
	int index;
	int data;
    struct list_head list;
} USR_LIST_TYPE;

int test(void) {

	USR_LIST_TYPE msg, *pmsg;
	LIST_HEAD(msg_head);
	int *ptr = &msg.data;
	int i;

	/* insert the 10 msgs */
	for(i = 0; i < 10; i++){
		pmsg = (USR_LIST_TYPE *)malloc(sizeof(USR_LIST_TYPE));

		pmsg->index = i + 1;
		pmsg->data =  (i + 1)*10;
		list_add_tail(&pmsg->list, &msg_head);
	}
	/* 根据list 遍历 整个链表，并打印信息 */
	list_for_each_entry(pmsg, &msg_head, list){
		printf("msg index:%d  data:%d\n", pmsg->index, pmsg->data);
	}
}

链表初始化后,就可以把内容插入表中

头插法

	list_add(&my_list_1.list, &head_class);
    list_add(&my_list_2.list, &head_class);
    list_add(&my_list_3.list, &head_class);

尾插法

	list_add_tail(&my_list_4.list, &head_class);

元素遍历

    list_p = &my_list_1;
    list_for_each_entry(list_p, &(head_class), list){
		printf("data=:%s\n", list_p->data);
	}

更多用法参考工程代码

https://download.youkuaiyun.com/download/hushiganghu/19426365

参考网站:https://zhuge.blog.youkuaiyun.com/article/details/99193521
https://www.cnblogs.com/muahao/p/7509629.html