链表

简介:
 
#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 plain copy
  1. typedef struct _LINK_NODE  
  2. {  
  3.     int data;  
  4.     struct _LINK_NODE* next;  
  5. }LINK_NODE;  

     (2)创建链表

[cpp]  view plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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. }

相关文章
|
6月前
|
存储 Python
什么是链表
什么是链表
59 0
|
6月前
|
存储 Java
链表的认识
链表的认识
|
存储
07 链表
07 链表
33 0
|
存储 索引
关于链表我所知道的
关于链表我所知道的
77 0
|
存储 算法 Java
【JavaOj】链表十连问
【JavaOj】链表十连问
106 0
|
存储 算法 Java
一文带你深入了解链表(C)
📖作者介绍:22级树莓人(计算机专业),热爱编程<目前在c阶段>——目标C++、Windows,MySQL,Qt,数据结构与算法,Linux,多线程,会持续分享学习成果和小项目的 📖作者主页:热爱编程的小K 📖专栏链接:C 🎉欢迎各位→点赞👏 + 收藏💞 + 留言🔔​ 💬总结:希望你看完之后,能对你有所帮助,不足请指正!共同学习交流 🐾 ———————————————— 版权声明:本文为CSDN博主「热爱编程的小K」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。 原文链接:https://blog.csdn.net/qq_7215744
|
存储 索引
变幻莫测的链表
双链表 单链表中的指针域只能指向节点的下一个节点。 双链表:每一个节点有两个指针域,一个指向下一个节点,一个指向上一个节点。 双链表 既可以向前查询也可以向后查询。
75 0
|
存储 API
链表——初识链表
链表是一种物理存储单元上非连续、非顺序的存储结构,其物理结构不能只管的表示数据元素的逻辑顺序,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
110 0
链表——初识链表