vs2019 常用数据结构纯C语言头文件实现（持续更新改错中）单链表，

1.单链表：

 1 #pragma once

 2 #ifndef _List_H

 3 #include<stdio.h>

 4 #include<stdlib.h>

 5 #define ElementType int

 6

 7 struct Node;

 8 typedef struct Node* PtrToNode;

 9 typedef PtrToNode List;

10 typedef PtrToNode Position;

11

12 List MakeEmpty(List L);

13 int IsEmpty(List L);

14 int IsLast(Position P, List L);

15 Position Find(ElementType X, List L);

16 void Delete(ElementType X, List L);

17 Position FindPrevious(ElementType X, List L);

18 void Insert(ElementType X, List L, Position P);

19 void DeleteList(List L);

20 Position Header(List L);

21 Position First(List L);

22 Position Advance(Position P);

23 ElementType Rretrieve(Position P);

24 #endif // !_List_H

25

26 struct Node

27 {

28     ElementType Element;

29     Position Next;

30 };

31

32 inline List MakeEmpty(List L)

33 {

34     return List();

35 }

36

37 int IsEmpty(List L)

38 {

39     return L->Next == NULL;

40 }

41

42 int IsLast(Position P, List L)

43 {

44     return P->Next == NULL;

45 }

46

47 Position Find(ElementType X, List L)

48 {

49     Position P;

50     P = L->Next;

51     while (P != NULL && P->Element != X) {

52         P = P->Next;

53     }

54     return P;

55 }

56

57 void Delete(ElementType X, List L)

58 {

59     Position P, TmpCell = nullptr;

60     P = FindPrevious(X, L);

61     if (!IsLast(P, L)) {

62         TmpCell = P->Next;

63         P->Next = TmpCell->Next;

64         free(TmpCell);

65     }

66 }

67

68 Position FindPrevious(ElementType X, List L)

69 {

70     Position P;

71     P = L;

72     while (P->Next != NULL && P->Next->Element != X) {

73         P = P->Next;

74     }

75     return P;

76 }

77

78 void Insert(ElementType X, List L, Position P)

79 {

80     Position TmpCell;

81     TmpCell = (Node*)malloc(sizeof(struct Node));

82     if (TmpCell == NULL) {

83         printf("fatal error:out of space!\n");

84         exit(1);

85     }

86     TmpCell->Element = X;

87 }

88

89 void DeleteList(List L)

90 {

91     L = NULL;

92     free(L);

93 }

2.顺序栈有头结点

 1 #pragma once

 2 #ifndef _sqStack_h

 3 #include<stdio.h>

 4 #include<stdlib.h>

 5 #define StackSize 100

 6 typedef int ElementType;

 7 typedef struct {

 8     ElementType data[StackSize];

 9     int top;

10 }sqStack;

11 void InitStack(sqStack* s);

12 int IsEmpty(sqStack* s);

13 void PrintStack(sqStack* s);

14 int Push(sqStack* s, ElementType* val);

15 int Pop(sqStack* s, ElementType* val);

16 int GetTop(sqStack* s, ElementType* val);

17 int ClearStack(sqStack* s);

18 #endif // !_sqStack_h

19 void InitStack(sqStack* s)

20 {

21     s->top = -1;

22 }

23

24 int IsEmpty(sqStack* s)

25 {

26     if (s->top == -1) {

27         return 1;

28     }

29     else return 0;

30 }

31

32 void PrintStack(sqStack* s)

33 {

34     if (IsEmpty(s)) {

35         printf("Empty Stack!");

36     }

37     else {

38         for (int i = 0; i < (s->top) + 1; i++) {

39             printf("%d\t", s->data[i]);

40         }

41         printf("\n");

42     }

43 }

44 int Push(sqStack* s, ElementType* val)

45 {

46     if (s->top < StackSize - 1) {

47         s->top = s->top + 1;

48         s->data[s->top] = *val;

49         return 1;

50     }

51     else {

52         printf("full stack!");

53         exit(1);

54     }

55 }

56

57 int Pop(sqStack* s, ElementType* val)

58 {

59     if (s->top == -1) {

60         printf("Empty Stack!");

61         exit(-1);

62     }

63     else {

64         *val = s->data[s->top];

65         s->top--;

66     }

67     return 1;

68 }

69

70 int GetTop(sqStack* s, ElementType* val)

71 {

72     if (IsEmpty(s)) {

73         printf("Empty Stack!");

74         exit(-1);

75     }

76     else {

77         *val = s->data[s->top];

78     }

79

80     return 1;

81 }

82

83 int ClearStack(sqStack* s)

84 {

85     s->top = -1;

86     return 1;

87 }

3.链栈（无头结点）

 1 #pragma once

 2 #ifndef _LStack_H

 3 #include<stdio.h>

 4 #include<stdlib.h>

 5 typedef int ElementType;

 6 typedef struct stnode {

 7     ElementType data;

 8     struct  stnode* next;

 9     size_t LenStack;

10 }Lstack;

11

12 Lstack* LstackCreate();

13 void InitStack(Lstack* s);

14 int push(Lstack* s, ElementType val);

15 int pop(Lstack* s, ElementType* val);

16 int gettop(Lstack* s, ElementType* val);

17 int IsEmpty(Lstack* s);

18 void print(Lstack* s);

19 #endif // !_LStack_H

20 Lstack* LstackCreate()

21 {

22     Lstack* s = (Lstack*)malloc(sizeof(Lstack));

23     InitStack(s);

24     return s;

25 }

26 //带头结点的链栈

27 void InitStack(Lstack* s)

28 {

29     s->next = NULL;

30     s->LenStack = 0;

31 }

32 int push(Lstack* s, ElementType val)

33 {

34     Lstack* p;

35     p = LstackCreate();

36     p->data = val;

37     if (IsEmpty(s)) {

38         s = p;

39     }

40     else {

41         p->next = s;

42         s->next = p;

43     }

44     (s->LenStack)++;

45     return 1;

46 }

47

48 int pop(Lstack* s, ElementType* val)

49 {

50     if (IsEmpty(s)) {

51         printf("Empty Stack!");

52         exit(1);

53     }

54     Lstack* tmp;

55     tmp = LstackCreate();

56     tmp = s->next;

57     *val = tmp->data;

58     s->next = tmp->next;

59     free(tmp);

60     return 1;

61 }

62

63 int gettop(Lstack* s, ElementType* val)

64 {

65     if (IsEmpty(s)) {

66         printf("Empty Stack!");

67         exit(1);

68     }

69     *val = s->next->data;

70     return 1;

71 }

72

73 int IsEmpty(Lstack* s)

74 {

75     if (s->LenStack == 0) {

76         return 1;

77     }

78     return 0;

79 }

80

81 void print(Lstack* s)

82 {

83     ;//懒得写了，也挺简单的

84 }

4.链栈

 1 #pragma once

 2 #ifndef _LStack_H

 3 #include<stdio.h>

 4 #include<stdlib.h>

 5 typedef int ElementType;

 6 typedef struct stnode {

 7     ElementType data;

 8     struct  stnode* next;

 9     size_t LenStack;

10 }Lstack;

11

12 Lstack* LstackCreate();

13 void InitStack(Lstack* s);

14 int push(Lstack* s, ElementType val);

15 int pop(Lstack* s, ElementType* val);

16 int gettop(Lstack* s, ElementType* val);

17 int IsEmpty(Lstack* s);

18 void print(Lstack* s);

19 #endif // !_LStack_H

20 Lstack* LstackCreate()

21 {

22     Lstack* s = (Lstack*)malloc(sizeof(Lstack));

23     InitStack(s);

24     return s;

25 }

26 //带头结点的链栈

27 void InitStack(Lstack* s)

28 {

29     s->next = NULL;

30     s->LenStack = 0;

31 }

32 int push(Lstack* s, ElementType val)

33 {

34     Lstack* p;

35     p = LstackCreate();

36     p->data = val;

37     if (IsEmpty(s)) {

38         s->next = p;

39     }

40     else {

41         p->next = s->next;

42         s->next = p;

43     }

44     (s->LenStack)++;

45     return 1;

46 }

47

48 int pop(Lstack* s, ElementType* val)

49 {

50     if (IsEmpty(s)) {

51         printf("Empty Stack!");

52         exit(1);

53     }

54     Lstack* tmp;

55     tmp = LstackCreate();

56     tmp = s->next;

57     *val = tmp->data;

58     s->next = tmp->next;

59     free(tmp);

60     return 1;

61 }

62

63 int gettop(Lstack* s, ElementType* val)

64 {

65     if (IsEmpty(s)) {

66         printf("Empty Stack!");

67         exit(1);

68     }

69     *val = s->next->data;

70     return 1;

71 }

72

73 int IsEmpty(Lstack* s)

74 {

75     if (s->LenStack == 0) {

76         return 1;

77     }

78     return 0;

79 }

80

81 void print(Lstack* s)

82 {

83     ;

84 }

5.顺序队列

 1 #pragma once

 2 #ifndef _sqQueue_h

 3 #include<stdio.h>

 4 #include<stdlib.h>

 5 #define MaxSize 20

 6 typedef int ElementType;

 7 typedef struct asqQueue {

 8     ElementType data[MaxSize];

 9     int front, rear;

10 }squeue;

11

12 void Initqueue(squeue* q);

13 squeue* squeueCreate();

14 int IsEmpty(squeue q);

15 int EQueue(squeue* q, ElementType val);

16 int OQueue(squeue* q, ElementType* val);

17 int GetQhead(squeue* q, ElementType* val);

18 void ClearQueue(squeue* q);

19

20 #endif // !_sqQueue_h

21 void Initqueue(squeue* q)

22 {

23     q->rear = 0;

24     q->front = 0;

25 }

26 squeue* squeueCreate()

27 {

28     squeue* q = (squeue*)malloc(sizeof(squeue));

29

30     return q;

31 }

32

33 int IsEmpty(squeue q)

34 {

35     if (q.rear == q.front) {

36         return 1;

37     }

38     return 0;

39 }

40

41 inline int EQueue(squeue* q, ElementType val)

42 {

43     if (((q->rear) + 1) % MaxSize == q->front) {

44         printf("overflow queue!");

45         exit(1);

46     }

47     else {

48         q->rear = ((q->rear) + 1) % MaxSize;

49         q->data[q->rear] = val;

50     }

51

52     return 1;

53 }

54

55 inline int OQueue(squeue* q, ElementType* val)

56 {

57     if (q->front == q->rear) {

58         printf("Empty Queue!");

59         exit(1);

60     }

61     else {

62         q->front = ((q->front) + 1) % MaxSize;

63         *val = q->data[q->front];

64     }

65

66     return 1;

67 }

68

69 inline int GetQhead(squeue* q, ElementType* val)

70 {

71     if (q->front == q->rear) {

72         printf("Empty Queue!");

73         exit(1);

74     }

75     else {

76         *val = (q->data[q->front + 1]) % MaxSize;

77     }

78     return 1;

79 }

80

81 inline void ClearQueue(squeue* q)

82 {

83     q->front = q->rear = 0;

84     printf("Clear Success!");

85 }

6.链式队列

  1 #pragma once

  2 #ifndef _LQueue_H

  3 #include<stdio.h>

  4 #include<stdlib.h>

  5 typedef int QElementType;

  6 typedef int ElementType;

  7 typedef struct LQNode {

  8     QElementType data;

  9     struct LQNode* next;

 10 }LQNode, * QueuePtr;

 11

 12 typedef struct {

 13     QueuePtr front;

 14     QueuePtr rear;

 15 }LQueue;

 16

 17 void InitQueue(LQueue* LQ);

 18 void EQueue(LQueue* LQ, ElementType val);

 19 void OQueue(LQueue* LQ, ElementType* val);

 20 int IsEmpty(LQueue* LQ);

 21 int GetQhead(LQueue* LQ, ElementType* val);

 22 void ClearQueue(LQueue* LQ);

 23

 24 #endif // !_LQueue_H

 25 void InitQueue(LQueue* LQ)

 26 {

 27     LQ->front = NULL;

 28     LQ->rear = NULL;

 29 }

 30

 31 LQueue* LQueueCreate()

 32 {

 33     LQueue* LQ = (LQueue*)malloc(sizeof(LQueue));

 34     InitQueue(LQ);

 35     return LQ;

 36 }

 37

 38 void EQueue(LQueue* LQ, ElementType val)

 39 {

 40     QueuePtr tmp;

 41     tmp = (QueuePtr)malloc(sizeof(LQNode));

 42     tmp->data = val;

 43     tmp->next = NULL;

 44     if (LQ->front == NULL && LQ->rear == NULL) {

 45         LQ->rear = tmp;

 46         LQ->front = tmp;

 47     }

 48     else {

 49         LQ->rear->next = tmp;

 50         LQ->rear = tmp;

 51     }

 52 }

 53

 54 void OQueue(LQueue* LQ, ElementType* val)

 55 {

 56     QueuePtr tmp;

 57     if (IsEmpty(LQ)) {

 58         printf("Empty LinkQueue!");

 59         exit(1);

 60     }

 61     else {

 62         tmp = LQ->front;

 63         *val = LQ->front->data;

 64         if (LQ->front == LQ->rear) {

 65             LQ->front = NULL;

 66             LQ->rear = NULL;

 67         }

 68         else {

 69             LQ->front = LQ->front->next;

 70         }

 71     }

 72     free(tmp);

 73 }

 74

 75 inline int IsEmpty(LQueue* LQ)

 76 {

 77     if (LQ->front == NULL && LQ->rear == NULL) {

 78         return 1;

 79     }

 80     return 0;

 81 }

 82

 83 inline int GetQhead(LQueue* LQ, ElementType* val)

 84 {

 85     if (IsEmpty(LQ)) {

 86         printf("Empty LQueue!");

 87         exit(1);

 88     }

 89     else {

 90         *val = LQ->front->data;

 91     }

 92     return 0;

 93 }

 94

 95 inline void ClearQueue(LQueue* LQ)

 96 {

 97     QueuePtr tmp1, tmp2;

 98     tmp1 = LQ->front;

 99     while (tmp1) {

100         tmp2 = tmp1;

101         free(tmp2);

102         tmp1 = tmp1->next;

103     }

104     LQ->front = NULL;

105     LQ->rear = NULL;

106 }

vs2019 常用数据结构纯C语言头文件实现（持续更新改错中）单链表，的更多相关文章

数据结构与算法C语言所有头文件汇总 —— 持续更新
header.h // 顺序表的结构定义 #define Maxsize 100 //const int Maxsize = 100; // 预先定义一个足够大的常数 typedef struct { ...
嵌入式C语言头文件的建立与使用
如何正确编写 C 语言头文件和与之相关联的 c 源程序文件,这首先就要了解它们的各自功能. 要理解 C 文件与头文件(即.h)有什么不同之处,首先需要弄明白编译器的工作过程. 一般说来编译器会做以下几 ...
C语言头文件、库文件的查找路径
在程序设计中,文件包含是很有用的.一个大的程序可以分为多个模块,由多个程序员分别编程.有些公用的符号常量或宏定义等可单独组成一个文件,在其它文件的开头用包含命令包含该文件即可使用.这样,可避免在每个 ...
C语言头文件怎么写？（转载）
---恢复内容开始--- c语言头文件怎么写?我一直有这样的疑问,但是也一直没去问问到底咋回事:所以今天一定要把它弄明白! 其实学会写头文件之后可以为我们省去不少事情,可以避免书写大量的重复代码,还在 ...
c语言头文件中定义全局变量的问题
c语言头文件中定义全局变量的问题 (转http://www.cnblogs.com/Sorean/) 先说一下,全局变量只能定义在函数里面,任意函数,其他函数在使用的时候用extern声明.千万不要 ...
51单片机C语言学习笔记6：51单片机C语言头文件及其使用
很多初学单片机者往往对C51的头文件感到很神秘,而为什么要那样写,甚至有的初学者喜欢问,P1口的P为什么要大写,不大写行不行呢?其实这个是在头文件中用sfr定义的,现在定义好了的是这样的 sfr P1 ...
C语言头文件
最近在工作当中遇到了一点小问题,关于C语言头文件的应用问题,主要还是关于全局变量的定义和声明问题.学习C语言已经有好几年了,工作使用也近半年了,但是对于这部分的东西的确还没有深入的思考过.概念上还是比 ...
C++标准库头文件名字和C语言头文件名字的区别
1.C++版本的C标准库头文件,一般是cname,而C语言头文件一般是name.h 2.命名为cname的头文件中定义的名字都是从std中来的,而如果是name.h则不是这样的. 3.与是用name. ...
C语言头文件的使用（转载）
C语言头文件的使用 ——by janders 转载请注名作者和出处,谢谢! C语言中的.h文件和我认识由来已久,其使用方法虽不十分复杂,但我却是经过了几个月的“不懂”时期,几年的“一知半解”时期才逐渐 ...
用CBrother将excel中的数据转换为C语言头文件
用CBrother将excel中的数据转换为C语言头文件最近在工作中,产品这边总是要调整一些参数,而我们在这一块要求所有的配置必须用宏定义来做,因为不同型号直接硬编码写死在代码里,但是一但数量大了, ...

随机推荐

隐藏来源禁用Referrer 的方法
原文链接: https://www.cnblogs.com/duanweishi/p/16490197.html https://blog.csdn.net/qq996150938/article/d ...
Mysql数据库基础第五章：（二）视图
Mysql数据库基础系列软件下载地址提取码:7v7u 数据下载地址提取码:e6p9 mysql数据库基础第一章:(一)数据库基本概念 mysql数据库基础第一章:(二)mysql环境搭建 mys ...
ACE下载地址
https://download.dre.vanderbilt.edu/previous_versions/ 在某n中找了大半天愣是没人贴出来
linux升级系统内核
1. 查看老版本系统内核 2. 升级内核 rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org rpm -Uvh http://www. ...
压力&负载理论
一.定义: 1.压力测试是给软件不断加压,强制其在极限的情况下运行,观察它可以运行到何种程度,从而发现性能缺陷,是通过搭建与实际环境相似的测试环境,通过测试程序在同一时间内或某一段时间内,向 ...
《CSOL大灾变》开发记录——武器购买逻辑开发
上次完成了武器购买界面设计,这次来完成武器购买逻辑与武器选择逻辑. 武器购买逻辑分为两个部分,一个部分是GUI部分的逻辑,也就是购买菜单,一个是武器游戏数据更新的逻辑,也就是实际中玩家获取武器的逻辑开 ...
关于CMDB
关于CMDB: CMDB运维管理平台是由CMDB开发团队,针对目前服务器运维.监控,批量管理提出的一个开源. 易用.实用的跨平台服务器运维管理平台. 统筹来说cmdb就是将已有的规则化运维技术规则到运 ...
原生js创建节点，添加节点，删除节点
1.操作 var tab=document.querySelector('#app .bpm-container'); var abcbox=document.querySelector('.abcb ...
VirtualBox + Parrot
安装环境:win8 1.官网下载virtualbox安装包,parrot kde sequrity镜像文件 2.用virtualbox创建新的虚拟机,内存4g,类型是linux debian 64,硬 ...
Python 切片/列表/字符串之间装换
1. 怎么实现字符串变为list 使用split(),把字符串拆分再存入数组: 例子 input="ni si shi" output=input.split(" &qu ...

vs2019 常用数据结构 纯C语言 头文件实现 （持续更新改错中）单链表，

vs2019 常用数据结构 纯C语言 头文件实现 （持续更新改错中）单链表，的更多相关文章

随机推荐

热门专题

vs2019 常用数据结构纯C语言头文件实现（持续更新改错中）单链表，

vs2019 常用数据结构纯C语言头文件实现（持续更新改错中）单链表，的更多相关文章