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语言头文件 最近在工作中,产品这边总是要调整一些参数,而我们在这一块要求所有的配置必须用宏定义来做,因为不同型号直接硬编码写死在代码里,但是一但数量大了, ...
随机推荐
- 在docker中,运行Jcmd命令,报错
起因: 想调整JVM的设置,观察一下当前jvm进程的资源情况. 输入:docker exec -it xxxxx /bin/sh 输入: jcmd 1 help ,报错 com.sun.tools.a ...
- CodeGym自学笔记05——类名
1.Java 程序由类组成.每个类都存储在一个单独的文件中,其文件名称与类名一致.该文件的扩展名为 java. 2.当我们有许多类文件时,我们会将它们分组到文件夹和子文件夹中.此外,类还会被分组到包和 ...
- 每次 git 都需要输入用户名和密码的解决办法
git config --global credential.helper store git pull /git push (第一次输入,下次就不用再次输入数据)
- SpringCloudBus实现配置文件动态更新
前言 在SpringCloud之配置中心(config)的使用的基础上加上SpringCloudBus实现配置文件动态更新 在此之前需要修改版本,否则会出现"Endpoint ID 'bus ...
- VLC播放器 for Mac OS X
VLC 是一款自由.开源的跨平台多媒体播放器及框架,可播放大多数多媒体文件,以及 DVD.音频 CD.VCD 及各类流媒体协议. https://www.videolan.org/vlc/down ...
- 常用Linxu指令
1.查看端口占用情况 1.查看所有的服务端口: netstat -a 2.查看所有端口并显示进程号(PID): netstat -ap 若需停止某一进程,可通过kill PID来杀死进程或者用kill ...
- go 编程基础学习笔记
dos 命令 2023-01-26 1.切换盘符 只要输入 c: d: e: 等即可 2.显示目录详细内容 dir 3.切换目录 cd 留意 一个点 . 代表当前目录, 两个点.. 代表上一级目录 4 ...
- LCP 03.机器人大冒险
def robot(command, obstacles, x, y): xx = 0 yy = 0 tmp = [] for c in command: if c == 'U': yy += 1 i ...
- linux 中后台运行python脚本
nohup python yourscript.py &可以让你的程序在后台运行,控制台输出导向nohup.out文件 使用nobup命令 结尾处加一个& 符号
- kafka删除topic清空数据
一般情况下,是不会删除数据的.到达一定时间后,kafka会自动删除.如果一定要删除可以删除topic在重建topic了 No. 1: 如果需要被删除topic 此时正在被程序 produce和cons ...