不学网

 找回密码
 立即注册

只需一步,快速开始

手机号码,快捷登录

查看: 303|回复: 0

[c/c++] [C数据结构]单链表

[复制链接]
j2cat 发表于 2018-1-6 18:41:24 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能,让你轻松玩转社区。

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
linklist.h
  1. #ifndef _LINKLIST_H_
  2. #define _LINKLIST_H_

  3. typedef void LinkList;
  4. typedef struct _tag_linklistnode TLinkListNode;
  5. struct _tag_linklistnode {
  6.         TLinkListNode* next;
  7. };

  8. //创建单链表
  9. LinkList* linklist_create(void);

  10. //销毁单链表
  11. void linklist_destroy(LinkList* list);

  12. //清空单链表
  13. void linklist_clear(LinkList* list);

  14. //插入元素
  15. int linklist_insert(LinkList* list, TLinkListNode* node, int pos);

  16. //删除元素
  17. TLinkListNode* linklist_delete(LinkList* list, int pos);

  18. //获取元素
  19. TLinkListNode* linklist_get(LinkList* list, int pos);

  20. //获取长度
  21. int linklist_length(LinkList* list);

  22. //元素反序
  23. void linklist_reversal(LinkList* list);

  24. #endif
复制代码
linklist.c
  1. #include <malloc.h>
  2. #include "LinkList.h"

  3. typedef struct _tag_LinkList {
  4.         TLinkListNode header;
  5.         int length;
  6. }TLinkList;

  7. //创建单链表
  8. LinkList* linklist_create(void) {
  9.         TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));
  10.         if (ret != NULL) {
  11.                 ret->length = 0;
  12.                 ret->header.next = NULL;
  13.         }

  14.         return ret;
  15. }

  16. //销毁单链表
  17. void linklist_destroy(LinkList* list) {
  18.         free(list);
  19. }

  20. //清空单链表
  21. void linklist_clear(LinkList* list) {
  22.         TLinkList* slist = (TLinkList*)list;
  23.         if (slist != NULL) {
  24.                 slist->header.next = NULL;
  25.                 slist->length = 0;
  26.         }

  27. }

  28. //插入元素
  29. int linklist_insert(LinkList* list, TLinkListNode* node, int pos) {
  30.         TLinkList* slist = (TLinkList*)list;
  31.         int ret = (slist != NULL) && (pos >= 0) && (node != NULL);
  32.         int i;
  33.         if (ret) {
  34.                 TLinkListNode* current = (TLinkListNode*)slist;

  35.                 for (i = 0; i < pos && current->next != NULL; i++) {
  36.                         current = current->next;
  37.                 }
  38.                 node->next = current->next;
  39.                 current->next = node;
  40.                 slist->length++;
  41.         }
  42.         return ret;
  43. }

  44. //删除元素
  45. TLinkListNode* linklist_delete(LinkList* list, int pos) {
  46.         TLinkList* slist = (TLinkList*)list;
  47.         TLinkListNode* ret = NULL;
  48.         int i;
  49.         if ((slist != NULL) && (pos >= 0) && (pos < slist->length)) {
  50.                 TLinkListNode* current = (TLinkListNode*)slist;
  51.                 for (i = 0; i < pos; i++) {
  52.                         current = current->next;
  53.                 }
  54.                 ret = current->next;
  55.                 current->next = ret->next;
  56.                 slist->length--;
  57.         }

  58.         return ret;

  59. }

  60. //获取元素
  61. TLinkListNode* linklist_get(LinkList* list, int pos) {
  62.         TLinkList* slist = (TLinkList*)list;
  63.         TLinkListNode* ret = NULL;
  64.         int i;
  65.         if ((slist != NULL) && (pos >= 0) && (pos < slist->length)) {
  66.                 TLinkListNode* current = (TLinkListNode*)slist;
  67.                 for (i = 0; i < pos; i++) {
  68.                         current = current->next;
  69.                 }
  70.                 ret = current->next;

  71.         }

  72.         return ret;
  73. }

  74. //获取长度
  75. int linklist_length(LinkList* list) {
  76.         TLinkList* slist = (TLinkList*)list;
  77.         int ret = -1;
  78.         if (slist != NULL) {       
  79.                 ret = slist->length;
  80.         }
  81.         return ret;
  82. }


  83. //元素反序
  84. void linklist_reversal(LinkList* list) {
  85.         TLinkList* slist = (TLinkList*)list;
  86.         if (slist != NULL) {
  87.                 TLinkListNode* current = (TLinkListNode*)slist;
  88.                 TLinkListNode* pnext = current->next;
  89.                 TLinkListNode* tmp;
  90.                 current->next = NULL;
  91.                 while (pnext != NULL) {
  92.                         tmp = pnext->next;
  93.                         pnext->next = current->next;
  94.                         current->next = pnext;
  95.                         pnext = tmp;
  96.                 }
  97.         }
  98. }
复制代码
main.c
  1. #include <stdio.h>
  2. #include "linklist.h"

  3. struct Value {
  4.         TLinkListNode header;
  5.         int v;
  6. };

  7. int main(void) {
  8.         LinkList* list = linklist_create();

  9.         struct Value v1;
  10.         struct Value v2;
  11.         struct Value v3;
  12.         struct Value v4;
  13.         struct Value v5;

  14.         v1.v = 1;
  15.         v2.v = 2;
  16.         v3.v = 3;
  17.         v4.v = 4;
  18.         v5.v = 5;

  19.         //头插
  20.         //linklist_insert(list, (TLinkListNode*)&v1, 0);
  21.         //linklist_insert(list, (TLinkListNode*)&v2, 0);
  22.         //linklist_insert(list, (TLinkListNode*)&v3, 0);
  23.         //linklist_insert(list, (TLinkListNode*)&v4, 0);
  24.         //linklist_insert(list, (TLinkListNode*)&v5, 0);

  25.         //尾插
  26.         linklist_insert(list, (TLinkListNode*)&v1, linklist_length(list));
  27.         linklist_insert(list, (TLinkListNode*)&v2, linklist_length(list));
  28.         linklist_insert(list, (TLinkListNode*)&v3, linklist_length(list));
  29.         linklist_insert(list, (TLinkListNode*)&v4, linklist_length(list));
  30.         linklist_insert(list, (TLinkListNode*)&v5, linklist_length(list));

  31.         puts("get");

  32.         for (int i = 0; i < linklist_length(list); i++) {
  33.                 struct Value* pv = (struct Value*)linklist_get(list, i);
  34.                 printf("%d\n",pv->v);
  35.         }

  36.        
  37.         puts("reversal:");
  38.         linklist_reversal(list);
  39.         for (int i = 0; i < linklist_length(list); i++) {
  40.                 struct Value* pv = (struct Value*)linklist_get(list, i);
  41.                 printf("%d\n", pv->v);
  42.         }

  43.         puts("delete:");

  44.         while (linklist_length(list) > 0) {
  45.                 struct Value* pv = (struct Value*)linklist_delete(list, linklist_length(list)-1);
  46.                 printf("%d\n", pv->v);
  47.         }

  48.         puts("destroy:");

  49.         linklist_destroy(list);


  50.         return 0;
  51. }
复制代码


回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|小黑屋|不学网

GMT+8, 2018-9-19 05:46

Powered by Discuz! X3.4

© 2001-2017 Comsenz Inc.

快速回复 返回顶部 返回列表