数据结构模版----单链表SimpleLinkList[带头结点&&面向对象设计思想](C语言实现)

简介:

链表中的数据是以节点来表示的,每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置),元素就是存储数据的存储单元,指针就是连接每个结点的地址数据。以“结点的序列”表示线性表称作线性链表(单链表)

单链表是链式存取的结构,为找第 i 个数据元素,必须先找到第 i-1 个数据元素。

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <stdbool.h>  
  4. #include <assert.h>  
  5.   
  6.   
  7.   
  8. //#define DEBUG             // 调试插桩信息宏  
  9.   
  10. /// 版本V0.0.2更新  
  11. /// ①将InsertNode重新实现为两个函数  
  12. //  将数据data插入链表的第position个位置  
  13. //  LinkListNode* InsertNode(LinkList *list, int position, ElemType data)  
  14. //  将数据data插入链表的pNode结点的下一个位置个位置  
  15. //  LinkListNode* AddNode(LinkList *list, LinkListNode *prevNode, ElemType data)  
  16.   
  17. /// ②将DelNode重新实现为三个函数  
  18. //  删除链表list中第position个指针  
  19. //  ElemType DeleteNode(LinkList *list, int position)  
  20. //  删除链表list中prevNode结点之后的指针个指针  
  21. //  ElemType SubNode(LinkListNode *prevNode)  
  22. //  删除链表list中currNode指针所指向的那个结点  
  23. //  ElemType DeleteCurrNode(LinkList *list, LinkListNode *currNode)  
  24.   
  25. /// ③将FindNode重新实现为三个函数  
  26. //  查找到链表list中第position个结点  
  27. //  LinkListNode* FindPosNode(LinkList *list, int position);  
  28. //  在链表list中找到currNode的前一个结点  
  29. //  LinkListNode *FindPrevNode(LinkList *list, LinkListNode *currNode);  
  30. //  判断结点node指向的区域是不是链表中的结点  
  31. //  int IsNodeInList(LinkList *list, LinkListNode *node);  
  32.   
  33.   
  34.   
  35. ///*////////////////////////////////////////////////////////////////////////////  
  36. ///  
  37. /// 带头结点的单链表结构体  
  38. ///  
  39. ///*////////////////////////////////////////////////////////////////////////////  
  40. typedef int ElemType;       // 自定义数据类型  
  41.   
  42. //typedef struct LinkListNode*  PLinkListNode;          // 链表结点指针域  
  43.   
  44. // 链表结点数据域  
  45. typedef struct LinkListNode  
  46. {  
  47.     ElemType            m_data;         // 数据域  
  48.     struct LinkListNode *m_next;            // 指针域  
  49. }LinkListNode;  
  50.   
  51. // 带头结点的单项链表  
  52. typedef struct LinkList  
  53. {  
  54.     LinkListNode    *m_head;                // 链表头结点  
  55.     int             m_length;           // 单链表数据结点个数指针域  
  56. }LinkList;  
  57.   
  58.   
  59.   
  60. ///*////////////////////////////////////////////////////////////////////////////  
  61. ///  
  62. /// 创建和初始化单链表  
  63. ///  
  64. /// 创建      LinkList* CreatLinkList(void)  
  65. /// 初始化 void InitLinkList(LinkList *list)  
  66. ///*////////////////////////////////////////////////////////////////////////////  
  67. /** 
  68. LinkList* CreatLinkList(void) 
  69. 参数 
  70.     list    :   指向一个链表指针,此处传入表头地址 
  71. 返回值 
  72.     若成功返回创建好的单链表的指针 
  73. 功能 
  74.     开辟一个单链表数据结构,并初始化头结点,然后将创建好的单链表指针返回 
  75. 注意 
  76.     使用CreateLinkList创建的单链表,需要用DestroyLinkList来销毁 
  77.     以免发生内存泄漏 
  78. */  
  79. LinkList* CreateLinkList(void)  
  80. {  
  81.     LinkList *list = NULL;  
  82.     if((list = (LinkList *)malloc(sizeof(LinkList))) == NULL)       // 开辟单链表的空间  
  83.     {   // 开辟失败  
  84.         fprintf(stderr, "not enough memory when CREATE LIST...\n");  
  85.         exit(EXIT_FAILURE);  
  86.     }  
  87.   
  88.     InitLinkList(list);             // 初始化单链表  
  89.   
  90.     return list;  
  91. }  
  92.   
  93. /** 
  94. void InitLinkList(LinkList *list) 
  95. 参数 
  96.     list    :   指向一个链表指针,此处传入表头地址 
  97. 返回值 
  98.     无 
  99. 功能 
  100.     初始化单链表, 执行以下操作 
  101.     ①开辟头结点的空间 ②进行必要的初始化[头结点的初始化和单链表结点数目的初始化] 
  102. 注意 
  103.     使用InitLinkList初始化的单链表(初始化时malloc了头结点m_head的空间) 
  104.     而使用用FinitLinkList来进行后处理(后处理时free了头结点的m_head空间) 
  105.     以免发生内存泄漏 
  106. */  
  107. void InitLinkList(LinkList *list)  
  108. {  
  109.     if((list->m_head = malloc(sizeof(LinkListNode))) == NULL)        // 为头结点开辟空间  
  110.     {   // 开辟失败  
  111.         fprintf(stderr, "not enough memory when MALLOC HEAD...");  
  112.         exit(EXIT_FAILURE);  
  113.     }  
  114.     list->m_head->m_next = NULL;          // 初始化只有头结点  
  115.     list->m_head->m_data = 0;             // 数据元素个数为0  
  116.     list->m_length = 0;                      // 数据元素个数为0  
  117. }  
  118.   
  119.   
  120. ///*////////////////////////////////////////////////////////////////////////////  
  121. ///  
  122. /// 销毁以及后处理单链表  
  123. ///  
  124. /// 销毁用CreateLinkList创建的单链表  
  125. /// void DestroyLinkList(LinkList *list)  
  126. ///  
  127. /// 后处理单链表,  
  128. /// void FinitLinkList(LinkList *list)  
  129. ///  
  130. /// 清空单链表中的所有元素  
  131. /// void ClearLinkList(LinkList *list)  
  132. ///*////////////////////////////////////////////////////////////////////////////  
  133. /** 
  134. void DestroyLinkList(LinkList *list) 
  135. 参数 
  136.     list    :   指向一个链表指针,此处传入表头地址 
  137. 返回值 
  138.     无 
  139. 功能 
  140.     销毁用CreateLinkList创建的单链表,执行以下操作 
  141.     ①清空单链表  ②释放头结点  ③释放单链表 
  142. 注意 
  143.     使用CreateLinkList创建的单链表,需要用DestroyLinkList来销毁 
  144.     以免发生内存泄漏 
  145. */  
  146. LinkList* DestroyLinkList(LinkList *list)  
  147. {  
  148.     ClearLinkList(list);            // 清空链表  
  149.     FinitLinkList(list);            // 销毁头结点  
  150.     if(list != NULL)                // 销毁链表的空间  
  151.     {  
  152.         free(list);  
  153.         list = NULL;  
  154.     }  
  155. }  
  156.   
  157.   
  158. /** 
  159. void FinitLinkList(LinkList *list) 
  160. 参数 
  161.     list    :   指向一个链表指针,此处传入表头地址 
  162. 返回值 
  163.     无 
  164. 功能 
  165.     后处理单链表, 执行以下操作 
  166.     ①开辟头结点的空间 ②进行必要的初始化[头结点的初始化和单链表结点数目的初始化] 
  167. 注意 
  168.     使用InitLinkList初始化的单链表(初始化时malloc了头结点m_head的空间) 
  169.     而使用用FinitLinkList来进行后处理(后处理时free了头结点的m_head空间) 
  170.     以免发生内存泄漏 
  171. */  
  172. void FinitLinkList(LinkList *list)  
  173. {  
  174.     assert(list->m_head->m_next == NULL);     // 后处理指针针对空链表  
  175.     // assert(list->m_length == 0);  
  176.     if(list->m_head != NULL)         // 如果此时头结点空间未被销毁  
  177.     {  
  178.         free(list->m_head);  
  179.   
  180.         list->m_head = NULL;  
  181.         list->m_length = -1;         // 未经初始化的单链表元素个数记为-1  
  182.     }  
  183. }  
  184.   
  185.   
  186.   
  187. /** 
  188. void ClearLinkList(LinkList *list) 
  189. 参数 
  190.     list    :   指向一个链表指针,此处传入表头地址 
  191. 返回值 
  192.     无 
  193. 功能 
  194.     清空单链表中的所有元素 
  195. */  
  196. void ClearLinkList(LinkList *list)  
  197. {  
  198.     while(list->m_head->m_next != NULL)  
  199.     {  
  200.         DeleteNode(list, 0);  
  201.     }  
  202. }  
  203.   
  204.   
  205. ///*////////////////////////////////////////////////////////////////////////////  
  206. ///  
  207. /// 查找函数  
  208. ///  
  209. /// 查找到链表list中第position个结点  
  210. /// LinkListNode* FindPosNode(LinkList *list, int position)  
  211. ///  
  212. /// 在链表list中找到currNode的前一个结点  
  213. /// LinkListNode *FindPrevNode(LinkList *list, LinkListNode *currNode)  
  214. ///  
  215. /// 判断结点node指向的区域是不是链表中的结点  
  216. /// int IsNodeInList(LinkList *list, LinkListNode *node)  
  217. ///  
  218. /// 找到数据域为data的结点首次出现的位置并返回结点信息  
  219. /// LinkListNode* FindNodeData(LinkList *list, ElemType data, int *position)  
  220. ///*////////////////////////////////////////////////////////////////////////////  
  221. /** 
  222. LinkListNode* FindPosNode(LinkList *list, int position) 
  223.  
  224. 参数 
  225.     list    :   指向一个链表指针,此处传入表头地址 
  226.     positon :   带查找的链表指针的位置 
  227. 返回值 
  228.     若成功返回指向待查找结点的指针 
  229.     若失败返回NULL 
  230. 功能 
  231.     查找到链表list中第position个结点 
  232. */  
  233. LinkListNode* FindPosNode(LinkList *list, int position)  
  234. {  
  235.     assert(list != NULL);                                   // 链表不能为空  
  236.     assert(position >= -1 && position < list->m_length);   // 插入的w位置只能在[-1~length]  
  237.   
  238.     LinkListNode    *pNode  = list->m_head;  
  239.     int             pos     = -1;  
  240.   
  241.     while(pNode != NULL && pos < position)       // 遍历单链表,找到第position个结点的位置  
  242.     {  
  243.         pNode = pNode->m_next;  
  244.         pos++;  
  245.     }  
  246.   
  247.     if(pNode == NULL || pos < position)  
  248.     {  
  249.         return NULL;  
  250.     }  
  251.     else  
  252.     {  
  253. #ifdef DEBUG  
  254.         printf("Find the %d point SUCCESS...[%p]\n", position, pNode);  
  255. #endif // DEBUG  
  256.         return pNode;  
  257.     }  
  258. }  
  259.   
  260.   
  261. /** 
  262. LinkListNode *FindPrevNode(LinkList *list, LinkListNode *currNode); 
  263.  
  264. 参数 
  265.     list        :   指向一个链表指针,此处传入表头地址 
  266.     currNode    :   待查找的链表指针的位置 
  267. 返回值 
  268.     若成功返回指向待查找结点的指针 
  269.     若失败返回NULL 
  270. 功能 
  271.     在链表list中找到currNode的前一个结点 
  272. */  
  273.   
  274. LinkListNode *FindPrevNode(LinkList *list, LinkListNode *currNode)  
  275. {  
  276.     assert(list !=  NULL);  
  277.     assert(currNode != NULL);  
  278.   
  279.     LinkListNode *pNode = list->m_head;  
  280.   
  281.     while(pNode->m_next != NULL && pNode->m_next != currNode)  
  282.     {  
  283.         pNode = pNode->m_next;  
  284.     }  
  285.   
  286.     if(pNode->m_next == currNode)                // 查找成功  
  287.     {  
  288.         return pNode;  
  289.     }  
  290.     else                                        // 查找失败  
  291.     {  
  292.         return NULL;  
  293.     }  
  294. }  
  295.   
  296. /** 
  297. int IsNodeInList(LinkList *list, LinkListNode *node) 
  298.  
  299. 参数 
  300.     list    :   指向一个链表指针,此处传入表头地址 
  301.     node    :   指向待查找的结点的指针 
  302. 返回值 
  303.     若成功 返回结点node在链表中的位置 
  304.     若失败 返回-1 
  305. 功能 
  306.     判断结点node指向的区域是不是链表中的结点 
  307. */  
  308. int IsNodeInList(LinkList *list, LinkListNode *node)  
  309. {  
  310.     assert(list != NULL);                                   // 链表不能为空   assert(Node != NULL);                                   // 待查找的指针不能为空  
  311.   
  312.     LinkListNode    *pNode  = list->m_head;  
  313.     int             pos     = -1;  
  314.   
  315.     while(pNode != NULL && pNode != node)       // 遍历单链表,找到第position个结点的位置  
  316.     {  
  317.         pNode = pNode->m_next;  
  318.         pos++;  
  319.     }  
  320.   
  321.     if(pNode == NULL)  
  322.     {   // 查找成功  
  323.         return -1;  
  324.     }  
  325.     else  
  326.     {   // 查找失败  
  327. #ifdef DEBUG  
  328.         printf("Find the [%p] point in the first %d pointer of the list...\n", fNode, pos);  
  329. #endif // DEBUG  
  330.         return pos;  
  331.     }  
  332. }  
  333.   
  334. /** 
  335. LinkListNode* FindData(LinkList *list, ElemType data, , int *position) 
  336.  
  337. 参数 
  338.     list    :   指向一个链表指针,此处传入表头地址 
  339.     data    :   待查找的结点的数据信息 
  340. 返回值 
  341.     若成功 返回结点node在链表中的位置 
  342.     若失败 返回-1 
  343. 功能 
  344.     找到数据域为data的结点首次出现的位置并返回结点信息 
  345. */  
  346. LinkListNode* FindNodeData(LinkList *list, ElemType data, int *position)  
  347. {  
  348.     LinkListNode *node = list->m_head->m_next;  
  349.     int pos = 0;  
  350.     while(node != NULL && node->m_data != data)  
  351.     {  
  352.         node = node->m_next;  
  353.         pos++;  
  354.     }  
  355.     *position = pos;                // 将出现的位置传递回去  
  356.   
  357.     return node;                    // 返回结点的信息  
  358. }  
  359.   
  360.   
  361.   
  362. ///*////////////////////////////////////////////////////////////////////////////  
  363. ///  
  364. /// 插入函数  
  365. ///  
  366. /// 将数据data插入链表的prevNode结点的下一个位置个位置  
  367. /// LinkListNode *AddNode(LinkList *list, LinkListNode *prevNode, ElemType data)  
  368. ///  
  369. /// 将数据data插入链表的第position个位置  
  370. /// LinkListNode *InsertNode(LinkList *list, int position, ElemType data)  
  371. ///*////////////////////////////////////////////////////////////////////////////  
  372. /** 
  373. LinkListNode* AddNode(LinkList *list, LinkListNode *prevNode, ElemType data); 
  374. 参数 
  375.     list        :   指向一个链表指针,此处传入表头地址 
  376.     prevNode    :   待插入位置的前一个结点 
  377.     data        :   待插入结点的数据 
  378. 返回值 
  379.     无 
  380. 功能 
  381.     将数据data插入链表的prevNode结点的下一个位置个位置 
  382. */  
  383. LinkListNode *AddNode(LinkList *list, LinkListNode *prevNode, ElemType data)  
  384. {  
  385.     assert(prevNode != NULL);                       // 插入点不能是空指针  
  386.   
  387.     LinkListNode *newNode = NULL;  
  388.     if((newNode = (LinkListNode *)malloc(sizeof(LinkListNode))) == NULL)    // 为新结点开辟空间  
  389.     {   // 开辟新结点失败  
  390.         fprintf(stderr, "not enough memeory\n");  
  391.         exit(EXIT_FAILURE);  
  392.     }  
  393.     //else  
  394.     //{  
  395.     // 开辟新结点成功  
  396.     newNode->m_data = data;  
  397.     newNode->m_next = NULL;  
  398.   
  399.     // 将指针newNode连接在pNode的后面  
  400.     newNode->m_next = prevNode->m_next;  
  401.     prevNode->m_next = newNode;  
  402.   
  403.     list->m_length++;                // 结点数目增加一个  
  404.     list->m_head->m_data++;           // 头结点的数据域同样存储着结点总数  
  405.     //}  
  406. #ifdef DEBUG  
  407.     printf("The new node is inserted after point pointer[%p]\n", pNode);  
  408. #endif // DEBUG  
  409.     return newNode;  
  410. }  
  411.   
  412. /** 
  413. void InsertNode(LinkList *list, int position, ElemType data) 
  414. 参数 
  415.     list    :   指向一个链表指针,此处传入表头地址 
  416.     positon :   待插入结点的位置 
  417.     data    :   待插入结点的数据 
  418. 返回值 
  419.     无 
  420. 功能 
  421.     将数据data插入链表的第position个位置 
  422. */  
  423. LinkListNode *InsertNode(LinkList *list, int position, ElemType data)  
  424. {  
  425.     assert(list != NULL);  
  426.     assert(position >=0 && position < list->m_length + 1);  
  427.   
  428.     LinkListNode *prevNode = FindPosNode(list, position - 1);           // 找到待插入位置的前一个结点  
  429.     LinkListNode *newNode = NULL;  
  430.   
  431.     // 下面调用InsertPointNode直接将结点插入到pNode结点后面  
  432.     if((newNode = AddNode(list, prevNode, data)) != NULL)   // 将新的结点插入到待插入前一个指针的后面  
  433.     {   // 插入成功  
  434.         return newNode;                             // 返回新插入的结点  
  435. #ifdef DEBUG  
  436.         printf("Insert the value %d into list at position %d...\n", data, position);  
  437. #endif // DEBUG  
  438.     }  
  439.     else  
  440.     {  
  441.         return NULL;                                // 插入失败返回NULL  
  442.     }  
  443.   
  444. //  //  以可以使用下面的代码  
  445. //  if((newNode = (LinkListNode *)malloc(sizeof(LinkListNode))) == NULL)    // 为新结点开辟空间  
  446. //  {   // 开辟新结点失败  
  447. //      fprintf(stderr, "not enough memeory\n");  
  448. //        exit(EXIT_FAILURE);  
  449. //  }  
  450. //  else  
  451. //  {   // 开辟新结点成功  
  452. //  newNode->m_data = data;  
  453. //  newNode->m_next = NULL;  
  454. //  
  455. //  // 将指针newNode连接在pNode的后面  
  456. //  newNode->m_next = prevNode->m_next;  
  457. //  prevNode->m_next = newNode;  
  458. //  
  459. //  list->m_length++;                // 结点数目增加一个  
  460. //  list->m_head->m_data++;           // 头结点的数据域同样存储着结点总数  
  461. //  }  
  462. }  
  463.   
  464.   
  465. ///*////////////////////////////////////////////////////////////////////////////  
  466. ///  
  467. /// 删除函数  
  468. ///  
  469. /// 删除链表list中prevNode结点之后的指针个指针  
  470. /// void DeleteNode(LinkList *list, int position)  
  471. ///  
  472. /// 删除链表list中prevNode结点之后的指针个指针  
  473. /// ElemType SubNode(LinkList *list, LinkListNode *prevNode)  
  474. ///  
  475. /// 删除链表list中prevNode结点之后的指针个指针  
  476. /// ElemType DeleteCurrNode(LinkList *list, LinkListNode *currNode)  
  477. ///*////////////////////////////////////////////////////////////////////////////  
  478. /** 
  479. void DeleteNode(LinkList *list, int position) 
  480. 参数 
  481.     list    :   指向一个链表指针,此处传入表头地址 
  482.     positon :   待删除结点的位置 
  483. 返回值 
  484.     返回待删除结点的数据域 
  485. 功能 
  486.     删除链表list中prevNode结点之后的指针个指针 
  487. */  
  488. ElemType DeleteNode(LinkList *list, int position)  
  489. {  
  490.     assert(list != NULL);  
  491.     assert(position >=0 && position < list->m_length);  
  492.     LinkListNode *prevNode = FindPosNode(list, position - 1);           // 找到第position - 1个结点  
  493.   
  494.     // 删除pNode的后一个结点  
  495.     LinkListNode *delNode = prevNode->m_next;  
  496.     ElemType delElem = delNode->m_data;  
  497.     prevNode->m_next = delNode->m_next;  
  498.     free(delNode);  
  499.   
  500.     list->m_length--;                // 结点数目减少一个  
  501.     list->m_head->m_data--;           // 头结点的数据域同样存储着结点总数  
  502.   
  503.     return delNode;  
  504. }  
  505.   
  506. /** 
  507. ElemType DeleteCurrNode(LinkList *list, LinkListNode *currNode); 
  508. 参数 
  509.     list    :   指向一个链表指针,此处传入表头地址 
  510.     positon :   待删除结点的位置 
  511. 返回值 
  512.     返回待删除结点的数据域 
  513. 功能 
  514.     删除链表list中prevNode结点之后的指针个指针 
  515. */  
  516. ElemType SubNode(LinkList *list, LinkListNode *prevNode)  
  517. {  
  518.     assert(list != NULL);                       // 链表不能为空  
  519.     assert(prevNode != NULL);                       // 待删除结点的前一个位置不能为空  
  520.     assert(IsNodeInList(list, prevNode) != -1); // 待删除位置的前一个结点必须在链表中  
  521.   
  522.     // 删除pNode的后一个结点  
  523.     LinkListNode *delNode = prevNode->m_next;  
  524.     ElemType delElem = delNode->m_data;  
  525.     prevNode->m_next = delNode->m_next;  
  526.     free(delNode);  
  527.   
  528.     list->m_length--;                // 结点数目减少一个  
  529.     list->m_head->m_data--;           // 头结点的数据域同样存储着结点总数  
  530.   
  531.     return delElem;  
  532.   
  533. }  
  534.   
  535.   
  536. /** 
  537. ElemType DeleteCurrNode(LinkList *list, LinkListNode *currNode); 
  538. 参数 
  539.     list    :   指向一个链表指针,此处传入表头地址 
  540.     positon :   待删除结点的位置 
  541. 返回值 
  542.     返回待删除结点的数据域 
  543. 功能 
  544.     删除链表list中prevNode结点之后的指针个指针 
  545. */  
  546. ElemType DeleteCurrNode(LinkList *list, LinkListNode *currNode)  
  547. {  
  548.     assert(list != NULL);                           // 链表不能为空  
  549.     assert(currNode != NULL);                           // 待删除结点的前一个位置不能为空  
  550.     assert(IsNodeInList(list, currNode) != -1); // 待删除的结点必须在链表中  
  551.   
  552.     ElemType delElem = -1;                          // 待删除结点的数据域  
  553.     LinkListNode *delNode = NULL;                   // 指向将要删除的结点的指针  
  554.   
  555.     if(currNode->m_next != NULL)                 // 如果待删除结点不是最后一个结点  
  556.     {  
  557.         // 将currNode的后一个结点delNode作为删除结点,  
  558.         delNode = currNode->m_next;  
  559.         currNode->m_next = delNode->m_next;           //从链表中删除delNode  
  560.   
  561.         // 并将delNode的数据域保存到delNode中  
  562.         delElem = currNode->m_data;                  // delElem保存currNode的数据域  
  563.         currNode->m_data = delNode->m_data;           // 真正删除的结点其实是currNode下一个结点, 因此用currNode保存下一个结点的数据域  
  564.     }  
  565.     else                                            // 否则待删除结点是最后一个结点  
  566.     {  
  567.         // 直接将最后一个结点删除即可, 应该把其前一个结点的指针域赋值为空  
  568.         delNode = currNode;  
  569.         // 下面应该将currnNode的前一个结点的指针域赋值为空[时间复杂度O(n)]  
  570.         LinkListNode *prevNode = FindPrevNode(list, currNode);  
  571.         prevNode->m_next = NULL;  
  572.     }  
  573.     free(delNode);  
  574.     list->m_length--;                // 结点数目减少一个  
  575.     list->m_head->m_data--;           // 头结点的数据域同样存储着结点总数  
  576.   
  577.     return delElem;  
  578. }  
  579.   
  580.   
  581. ///*////////////////////////////////////////////////////////////////////////////  
  582. ///  
  583. /// 其他函数  
  584. ///  
  585. /// 显示单链表的信息  
  586. /// void ShowList(LinkList *list  
  587. ///  
  588. /// 删除链表list中prevNode结点之后的指针个指针  
  589. /// void SetNode(LinkList *list, int position, ElemType data)  
  590. ///  
  591. /// 获取单链表list第position个结点的数据域  
  592. /// ElemType GetNode(LinkList *list, int position)  
  593. ///  
  594. /// 获取单链表list的长度[即元素个数]  
  595. /// int LengthLinkList(LinkList *list)  
  596. ///  
  597. /// 判断当前链表是否是空链表  
  598. /// bool IsEmptyLinkList(LinkList *list)  
  599. ///*////////////////////////////////////////////////////////////////////////////  
  600. /** 
  601. void ShowLinkList(LinkList *list) 
  602. 参数 
  603.     list    :   指向一个链表指针,此处传入表头地址 
  604. 返回值 
  605.     无 
  606. 功能 
  607.     显示单链表的信息 
  608. */  
  609. void ShowList(LinkList *list)  
  610. {  
  611. // assert(list->m_head != NULL)  
  612.     if(list->m_head ==  NULL)            //  单链表可能没有被初始化  
  613.     {  
  614.         fprintf(stderr, "you can't SHOW the list without the list INITLINKLIST...\n");  
  615.         return ;  
  616.     }  
  617.   
  618.   
  619.     printf("there are %d data in list\n", list->m_length);  
  620.     if(list->m_length == 0)  
  621.     {  
  622.         return ;  
  623.     }  
  624.   
  625.     LinkListNode *pNode = list->m_head->m_next;           // 从头指针开始遍历  
  626.   
  627.     while(pNode != NULL)                                //开始遍历单链表  
  628.     {  
  629.         printf("%d  ", pNode->m_data);  
  630.         pNode = pNode->m_next;  
  631.     }  
  632.     printf("\n");  
  633.   
  634. //  ElemType data;  
  635. //  for(int pos = 0; pos < list->m_length; pos++)  
  636. //  {  
  637. //      data = GetNode(list, pos);  
  638. //      printf("%d  ", data);  
  639. //  }  
  640. //  printf("\n");  
  641. }  
  642.   
  643. /** 
  644. void SetNode(LinkList *list, int position, ElemType data) 
  645. 参数 
  646.     list    :   指向一个链表指针,此处传入表头地址 
  647.     positon :   待修改的结点的数据 
  648.     data    :   待更正的新数据域 
  649. 返回值 
  650.     无 
  651. 功能 
  652.     修改单链表list第position个结点的数据域为data 
  653. */  
  654. void SetNode(LinkList *list, int position, ElemType data)  
  655. {  
  656.     LinkListNode *pNode = FindPosNode(list, position);      // 找到单链表的第position个结点  
  657.   
  658.     pNode->m_data = data;  
  659. }  
  660.   
  661.   
  662. /** 
  663. ElemType GetNode(LinkList *list, int position 
  664. 参数 
  665.     list    :   指向一个链表指针,此处传入表头地址 
  666.     positon :   待查询的结点的位置 
  667. 返回值 
  668.     获取到的结点数据 
  669. 功能 
  670.     获取单链表list第position个结点的数据域 
  671. */  
  672. ElemType GetNode(LinkList *list, int position)  
  673. {  
  674.     LinkListNode *pNode = FindPosNode(list, position);      // 找到单链表的第position个结点  
  675.   
  676.     return pNode->m_data;  
  677. }  
  678.   
  679. /** 
  680. int LengthLinkList(LinkList *list) 
  681. 参数 
  682.     list    :   指向一个链表指针,此处传入表头地址 
  683.     positon :   待查询的结点的位置 
  684. 返回值 
  685.     获取到的结点数据 
  686. 功能 
  687.     获取单链表list的长度[即元素个数] 
  688. */  
  689. int LengthLinkList(LinkList *list)  
  690. {  
  691.     return list->m_length;  
  692. }  
  693.   
  694.   
  695. /** 
  696. bool IsEmptyLinkList(LinkList *list) 
  697. 参数 
  698.     list    :   指向一个链表指针,此处传入表头地址 
  699. 返回值 
  700.     如果单链表是空表,返回true 
  701.     否则返回false 
  702. 功能 
  703.     判断当前链表是否是空链表 
  704. */  
  705. bool IsEmptyLinkList(LinkList *list)  
  706. {  
  707.     return (list->m_length == 0);  
  708.     // return (list->m_head->m_next == NULL);  
  709. }  
  710.   
  711.   
  712.   
  713.   
  714. #define LIST_SIZE 7  
  715. // 主函数  
  716. int main(void)  
  717. {  
  718.     int pos;  
  719.   
  720.     printf("TEST 1...\n");  
  721.     LinkList *plist = CreateLinkList( );                // 创建单链表  
  722.     for(int pos = 0; pos < LIST_SIZE; pos++)         // 循环向单链表中插入数据  
  723.     {  
  724.         InsertNode(plist, pos, pos + 1);  
  725.     }  
  726.     ShowList(plist);                                    // 插入结束后显示单链表的信息  
  727.   
  728.     DeleteNode(plist, 0);                               // 删除第一个元素  
  729.     ShowList(plist);  
  730.     DeleteNode(plist, 1);                               // 删除第二个元素  
  731.     ShowList(plist);  
  732.   
  733.     ClearLinkList(plist);                               // 将单链表清空  
  734.     ShowList(plist);  
  735.     DestroyLinkList(plist);                             // 将单链表销毁  
  736.     plist = NULL;  
  737.   
  738.     printf("\n\nTEST 2...\n");  
  739.     LinkList list;  
  740.     InitLinkList(&list);                                // 初始化单链表  
  741.     for(int pos = 0; pos < LIST_SIZE; pos++)         // 训话向单链表中插入数据  
  742.     {  
  743.         InsertNode(&list, pos, pos + 1);  
  744.     }  
  745.     ShowList(&list);                                    // 显示单链表  
  746.     ClearLinkList(&list);                               // 清空单链表  
  747. //  FinitLinkList(&list);       // ERROR== list->m_head->m_next == NULL  
  748.     ShowList(&list);  
  749.   
  750.     printf("\n\nTEST 3...\n");  
  751.     LinkListNode *prevNode = list.m_head;  
  752.     LinkListNode *addNode = NULL;  
  753.     for(int pos = 0; pos < LIST_SIZE; pos++)  
  754.     {  
  755.         if((addNode = AddNode(&list, prevNode, pos + 1)) != NULL)  
  756.         {  
  757.             prevNode = addNode;  
  758.         }  
  759.     }  
  760.     ShowList(&list);  
  761.     while(IsEmptyLinkList(&list) != true)           // 循环删除单链表中的数据  
  762.     {  
  763.         DeleteCurrNode(&list, list.m_head->m_next);  
  764.     }  
  765.     ShowList(&list);                                    // 显示单链表  
  766.   
  767.     return  EXIT_SUCCESS;  
  768. }  


转载:http://blog.csdn.net/gatieme/article/details/42496989

目录
相关文章
|
14天前
|
存储 Java
java数据结构,线性表链式存储(单链表)的实现
文章讲解了单链表的基本概念和Java实现,包括头指针、尾节点和节点结构。提供了实现代码,包括数据结构、接口定义和具体实现类。通过测试代码演示了单链表的基本操作,如添加、删除、更新和查找元素,并总结了操作的时间复杂度。
java数据结构,线性表链式存储(单链表)的实现
|
2天前
|
存储
【初阶数据结构】深入解析单链表:探索底层逻辑(无头单向非循环链表)(一)
【初阶数据结构】深入解析单链表:探索底层逻辑(无头单向非循环链表)
|
1天前
|
存储
数据结构--单链表
数据结构--单链表
|
29天前
|
存储 人工智能 C语言
数据结构基础详解(C语言): 栈的括号匹配(实战)与栈的表达式求值&&特殊矩阵的压缩存储
本文首先介绍了栈的应用之一——括号匹配,利用栈的特性实现左右括号的匹配检测。接着详细描述了南京理工大学的一道编程题,要求判断输入字符串中的括号是否正确匹配,并给出了完整的代码示例。此外,还探讨了栈在表达式求值中的应用,包括中缀、后缀和前缀表达式的转换与计算方法。最后,文章介绍了矩阵的压缩存储技术,涵盖对称矩阵、三角矩阵及稀疏矩阵的不同压缩存储策略,提高存储效率。
|
29天前
|
C语言
数据结构基础详解(C语言):图的基本概念_无向图_有向图_子图_生成树_生成森林_完全图
本文介绍了图的基本概念,包括图的定义、无向图与有向图、简单图与多重图等,并解释了顶点度、路径、连通性等相关术语。此外还讨论了子图、生成树、带权图及几种特殊形态的图,如完全图和树等。通过这些概念,读者可以更好地理解图论的基础知识。
|
2天前
|
存储 缓存
【初阶数据结构】深入解析单链表:探索底层逻辑(无头单向非循环链表)(二)
【初阶数据结构】深入解析单链表:探索底层逻辑(无头单向非循环链表)
|
1月前
|
存储 算法 C语言
C语言手撕实战代码_循环单链表和循环双链表
本文档详细介绍了用C语言实现循环单链表和循环双链表的相关算法。包括循环单链表的建立、逆转、左移、拆分及合并等操作;以及双链表的建立、遍历、排序和循环双链表的重组。通过具体示例和代码片段,展示了每种算法的实现思路与步骤,帮助读者深入理解并掌握这些数据结构的基本操作方法。
|
1月前
|
算法 C语言 开发者
C语言手撕实战代码_单链表
本文档详细介绍了使用C语言实现单链表的各种基本操作和经典算法。内容涵盖单链表的构建、插入、查找、合并及特殊操作,如头插法和尾插法构建单链表、插入元素、查找倒数第m个节点、合并两个有序链表等。每部分均配有详细的代码示例和注释,帮助读者更好地理解和掌握单链表的编程技巧。此外,还提供了判断子链、查找公共后缀等进阶题目,适合初学者和有一定基础的开发者学习参考。
|
1月前
|
存储 C语言
数据结构基础详解(C语言): 树与二叉树的应用_哈夫曼树与哈夫曼曼编码_并查集_二叉排序树_平衡二叉树
本文详细介绍了树与二叉树的应用,涵盖哈夫曼树与哈夫曼编码、并查集以及二叉排序树等内容。首先讲解了哈夫曼树的构造方法及其在数据压缩中的应用;接着介绍了并查集的基本概念、存储结构及优化方法;随后探讨了二叉排序树的定义、查找、插入和删除操作;最后阐述了平衡二叉树的概念及其在保证树平衡状态下的插入和删除操作。通过本文,读者可以全面了解树与二叉树在实际问题中的应用技巧和优化策略。
|
1月前
|
存储 算法 C语言
C语言手撕数据结构代码_顺序表_静态存储_动态存储
本文介绍了基于静态和动态存储的顺序表操作实现,涵盖创建、删除、插入、合并、求交集与差集、逆置及循环移动等常见操作。通过详细的C语言代码示例,展示了如何高效地处理顺序表数据结构的各种问题。