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语言头文件 最近在工作中,产品这边总是要调整一些参数,而我们在这一块要求所有的配置必须用宏定义来做,因为不同型号直接硬编码写死在代码里,但是一但数量大了, ...
随机推荐
- 提升IIS权限
如何去修改IIS的权限 在IIS中当前网站高级设置中查看-应用程序池-修改标识-标识代表权限 可以通过调整应用程序池权限来维持后门. 安装IIS.支持.aspx脚本.是为了用木马查看权限. 上面的 ...
- 堆相关题目-python
栈&队列&哈希表&堆-python https://blog.csdn.net/qq_19446965/article/details/102982047 1.丑数 II 编 ...
- day01-java流程
Scanner对象 基本语法: Scanner s = new Scanner(System.in); next()方法 nextLine()方法 顺序结构 选择结构 if单选结构 语法: if(布尔 ...
- vue3 h函数
1. 自定义指令(withDirectives 仅可在setup或render函数中使用)可以使用 withDirectives 将自定义指令应用于 VNode: const { h, resolve ...
- 复习第6点-6.SpringMVC作用域传值
作用域范围 对象名称 作用范围 application 整个作用范围 session 在当前会话中有效 request 在当前请求中有效 page 在当前页面有效 request/session/ap ...
- linux下安装mysql的方式
总体来说,mysql安装有两种方式,一个是源码安装,另一个是使用官方编译好的二进制文件安装. 1.使用rpm方式安装 原文地址:https://blog.csdn.net/liuxw1/article ...
- 关于MounRiver编译器配置的若干问题
目录 一.在工程中单独设置预编译宏 二.将变量存放到指定RAM地址 三.串口打印浮点数 四.添加64位数据处理 五.使用math数学库 六.关闭仿真时自动清dataflash功能 七.配置printf ...
- svn 中的trunk，tags，branches分别是什么意思？
1.trunk是主分支,是日常开发进行的地方.2.branches是分支.一些阶段性的release版本,这些版本是可以继续进行开发和维护的,则放在branches目录中.又比如为不同用户客制化的版本 ...
- Flink Table API & SQL 自定义Redis Sink 代码实现
在自定义source&sink这一块官方给的说明并不是很多,需要去看源代码熟悉,自己实现一个redis sink主要需要实现StreamTableSinkFactory,RichSinkFun ...
- 南大ics-pa/PA0过程及感想
实验教程地址:https://nju-projectn.github.io/ics-pa-gitbook/ics2022/index.html 一.Ubuntu安装 在清华大学镜像站下载了Ubuntu ...