链表

#include <stdio.h>
#include <malloc.h>

typedef struct node{
	int data;//数据域
	struct node * next;//指针域
}Node;

int main()
{
	Node *pLinkNode=NULL;

	pLinkNode = (Node*)malloc(sizeof(Node));  

    pLinkNode->data = 2;
    pLinkNode->next = NULL;

	printf("%d\n",pLinkNode->data);

	return 0;
}

一步一步写算法（之单向链表）

    有的时候，处于内存中的数据并不是连续的。那么这时候，我们就需要在数据结构中添加一个属性，这个属性会记录下面一个数据的地址。有了这个地址之后，所有的数据就像一条链子一样串起来了，那么这个地址属性就起到了穿线连结的作用。

    相比较普通的线性结构，链表结构的优势是什么呢？我们可以总结一下：

    （1）单个节点创建非常方便，普通的线性内存通常在创建的时候就需要设定数据的大小

    （2）节点的删除非常方便，不需要像线性结构那样移动剩下的数据

    （3）节点的访问方便，可以通过循环或者递归的方法访问到任意数据，但是平均的访问效率低于线性表

    那么在实际应用中，链表是怎么设计的呢？我们可以以int数据类型作为基础，设计一个简单的int链表：

    （1）设计链表的数据结构

[cpp] view
plaincopy

1. typedef struct _LINK_NODE  
2. {  
3.     int data;  
4.     struct _LINK_NODE* next;  
5. }LINK_NODE;  

    （2）创建链表

[cpp] view
plaincopy

1. LINK_NODE* alloca_node(int value)  
2. {  
3.     LINK_NODE* pLinkNode = NULL;  
4.     pLinkNode = (LINK_NODE*)malloc(sizeof(LINK_NODE));  
5.       
6.     pLinkNode->data = value;  
7.     pLinkNode->next = NULL;  
8.     return pLinkNode;  
9. }  

    （3）删除链表

[cpp] view
plaincopy

1. void delete_node(LINK_NODE** pNode)  
2. {  
3.     LINK_NODE** pNext;  
4.     if(NULL == pNode || NULL == *pNode)  
5.         return ;  
6.           
7.     pNext = &(*pNode)->next;  
8.     free(*pNode);  
9.     delete_node(pNext);   
10. }  

    （4）链表插入数据

[cpp] view
plaincopy

1. STATUS _add_data(LINK_NODE** pNode, LINK_NODE* pDataNode)  
2. {  
3.     if(NULL == *pNode){  
4.         *pNode = pDataNode;  
5.         return TRUE;  
6.     }  
7.       
8.     return _add_data(&(*pNode)->next, pDataNode);  
9. }  
10.   
11. STATUS add_data(const LINK_NODE** pNode, int value)  
12. {  
13.     LINK_NODE* pDataNode;  
14.     if(NULL == *pNode)  
15.         return FALSE;  
16.           
17.     pDataNode = alloca_node(value);  
18.     assert(NULL != pDataNode);  
19.     return _add_data((LINK_NODE**)pNode, pDataNode);  
20. }  

    （5）删除数据

[cpp] view
plaincopy

1. STATUS _delete_data(LINK_NODE** pNode, int value)  
2. {  
3.     LINK_NODE* pLinkNode;  
4.     if(NULL == (*pNode)->next)  
5.         return FALSE;  
6.       
7.     pLinkNode = (*pNode)->next;  
8.     if(value == pLinkNode->data){  
9.         (*pNode)->next = pLinkNode->next;  
10.         free(pLinkNode);  
11.         return TRUE;  
12.     }else{  
13.         return _delete_data(&(*pNode)->next, value);  
14.     }  
15. }  
16.   
17. STATUS delete_data(LINK_NODE** pNode, int value)  
18. {  
19.     LINK_NODE* pLinkNode;  
20.     if(NULL == pNode || NULL == *pNode)  
21.         return FALSE;  
22.   
23.     if(value == (*pNode)->data){  
24.         pLinkNode = *pNode;  
25.         *pNode = pLinkNode->next;  
26.         free(pLinkNode);  
27.         return TRUE;  
28.     }         
29.       
30.     return _delete_data(pNode, value);  
31. }  

    （6）查找数据

[cpp] view
plaincopy

1. LINK_NODE* find_data(const LINK_NODE* pLinkNode, int value)  
2. {  
3.     if(NULL == pLinkNode)  
4.         return NULL;  
5.       
6.     if(value == pLinkNode->data)  
7.         return (LINK_NODE*)pLinkNode;  
8.       
9.     return find_data(pLinkNode->next, value);  
10. }  

    （7）打印数据

[cpp] view
plaincopy

1. void print_node(const LINK_NODE* pLinkNode)  
2. {  
3.     if(pLinkNode){  
4.         printf("%d\n", pLinkNode->data);  
5.         print_node(pLinkNode->next);  
6.     }  
7. }  

    （8）统计数据

[cpp] view
plaincopy

1. int count_node(const LINK_NODE* pLinkNode)  
2. {  
3.     if(NULL == pLinkNode)  
4.         return 0;  
5.           
6.     return 1 + count_node(pLinkNode->next);  
7. }