C语言- 基础数据结构和算法 - 13 二叉树非递归遍历（链式栈）20220612
作者：互联网
13 二叉树非递归遍历（链式栈）20220612，
听黑马程序员教程《基础数据结构和算法 (C版本)》，
照着老师所讲抄的， 视频地址https://www.bilibili.com/video/BV1vE411f7Jh?p=1
喜欢的朋友可以去看看，欢迎大家一起交流学习。
13 二叉树非递归遍历（链式栈）20220612_main.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4
5 #include "LinkStack.c"
6
7 // 标识
8 #define MY_FALSE 0
9 #define MY_TRUE 1
10
11
12 // 二叉树结点
13 typedef struct BINARYNODE{
14 char ch;
15 struct BINARYNODE* lchild; // 左结点
16 struct BINARYNODE* rchild; // 右结点
17 }BinaryNode;
18
19
20 typedef struct BITREESTACKNODE{
21 LinkNode node;
22 BinaryNode* root;
23 int flag;
24 }BiTreeStackNode;
25
26 // 创建栈中的结点
27 BiTreeStackNode* CreateBiTreeStackNode(BinaryNode* node,int flag){
28
29 BiTreeStackNode* newnode = (BiTreeStackNode*)malloc(sizeof(BiTreeStackNode));
30 newnode->root= node;
31 newnode->flag = flag;
32
33 return newnode;
34 }
35
36 // 二叉树的非递归遍历（栈方式）
37 void NonRecursion(BinaryNode* root){
38
39 // 创建栈
40 LinkStack* stack = Init_LinkStack();
41 // 把根结点扔栈里
42 Push_LinkStack(stack,(LinkNode*)CreateBiTreeStackNode(root,MY_FALSE));
43
44 while(Size_LinkStack(stack) > 0){
45
46 // 先弹出栈顶元素
47 BiTreeStackNode* node = (BiTreeStackNode*)Top_LinkStack(stack);
48 Pop_LinkStack(stack);
49
50 // 判断弹出的结点是否为空
51 if(node->root == NULL){
52 continue; // 跳出本次循环（后面代码不执行了），直接进行下一次循环。
53 }
54 if(node->flag == MY_TRUE){
55 printf("%c ",node->root->ch);
56 }
57 else{
58 // 先序遍历，按下面R-L-D步，中序遍历按R-D-L顺序，后序遍历按D-R-L
59 // 因为栈是后进先出，所以入栈步骤要与之（先序、中序、后序）相反。
60 // R、当前节点的右结点入栈
61 Push_LinkStack(stack,(LinkNode*)CreateBiTreeStackNode(node->root->rchild,MY_FALSE));
62 // L、当前节点的左结点入栈
63 Push_LinkStack(stack,(LinkNode*)CreateBiTreeStackNode(node->root->lchild,MY_FALSE));
64 // D、改变当前节点的flag标识，并入栈
65 node->flag = MY_TRUE;
66 Push_LinkStack(stack,(LinkNode*)node);
67 }
68
69 }
70 }
71
72
73
74 // 手动构建二叉树
75 void CresteBinaryTree(){
76 // 共8个结点
77 BinaryNode nodeA = {'A',NULL,NULL};
78 BinaryNode nodeB = {'B',NULL,NULL};
79 BinaryNode nodeC = {'C',NULL,NULL};
80 BinaryNode nodeD = {'D',NULL,NULL};
81 BinaryNode nodeE = {'E',NULL,NULL};
82 BinaryNode nodeF = {'F',NULL,NULL};
83 BinaryNode nodeG = {'G',NULL,NULL};
84 BinaryNode nodeH = {'H',NULL,NULL};
85 //BinaryNode nodeI = {'I',NULL,NULL};
86 //BinaryNode nodeJ = {'J',NULL,NULL};
87 // 节点关系
88 nodeA.lchild = &nodeB;
89 nodeA.rchild = &nodeF;
90 nodeB.rchild = &nodeC;
91 nodeC.lchild = &nodeD;
92 nodeC.rchild = &nodeE;
93 nodeF.rchild = &nodeG;
94 nodeG.lchild = &nodeH;
95 // nodeH.lchild = &nodeI;
96 // nodeI.lchild = &nodeJ;
97
98 // 非递归遍历
99 NonRecursion(&nodeA);
100
101 }
102
103
104 int main(){
105 printf("好好学习，天天向上~！\t\t 13 二叉树非递归遍历（链式栈）20220612\n\n");
106
107
108
109 CresteBinaryTree();
110
111
112
113 printf("\n\n");
114 system("pause");
115 return 0;
116 }
LinkStack.c
1 #include "LinkStack.h"
2
3
4 // 初始化
5 LinkStack* Init_LinkStack(){
6
7 // 开内存
8 LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
9 // 初始化
10 stack->HeadNode.next = NULL;
11 stack->size = 0;
12
13 return stack;
14 }
15
16 // 入栈
17 void Push_LinkStack(LinkStack* stack,LinkNode* data){
18
19 if(stack == NULL){
20 return;
21 }
22 if(data == NULL){
23 return;
24 }
25
26 data->next = stack->HeadNode.next;
27 stack->HeadNode.next = data;
28
29 stack->size++;
30
31 }
32
33 // 出栈 (删除第一个元素）
34 void Pop_LinkStack(LinkStack* stack){
35
36 if(stack == NULL){
37 return ;
38 }
39 if(stack->size==0){
40 return ;
41 }
42
43 // 第一个有效节点
44 LinkNode* pNext = stack->HeadNode.next;
45 stack->HeadNode.next = pNext->next; // pNext.next为第一个有效节点的下一个节点
46
47 stack->size--;
48
49 }
50
51 // 返回栈顶元素
52 LinkNode* Top_LinkStack(LinkStack* stack){
53
54 if(stack == NULL){
55 return NULL;
56 }
57 if(stack->size==0){
58 return NULL;
59 }
60
61 return stack->HeadNode.next;
62 }
63
64 // 返回栈元素的个数
65 int Size_LinkStack(LinkStack* stack){
66 if(stack == NULL){
67 return -1;
68 }
69 return stack->size;
70 }
71
72 // 清空栈
73 void Clear_LinkStack(LinkStack* stack){
74
75 if(stack == NULL){
76 return;
77 }
78 stack->HeadNode.next = NULL;
79 stack->size=0;
80
81 }
82
83 // 销毁栈
84 void FreeSpace_LinkStack(LinkStack* stack){
85
86 if(stack == NULL){
87 return;
88 }
89
90 free(stack);
91
92
93 }
LinkStack.h
1 #ifndef LINKSTACK_H
2 #define LINKSTACK_H
3
4 #include <stdio.h>
5 #include <stdlib.h>
6
7
8 // 链式栈的节点
9 typedef struct LINKNODE{
10 struct LINKNODE* next;
11 }LinkNode;
12
13 // 链式栈
14
15 typedef struct LINKSTACK{
16 LinkNode HeadNode; //头节点
17 int size;
18 }LinkStack;
19
20 // 初始化
21 LinkStack* Init_LinkStack();
22 // 入栈
23 void Push_LinkStack(LinkStack* stack,LinkNode* data);
24 // 出栈 (删除第一个元素）
25 void Pop_LinkStack(LinkStack* stack);
26 // 返回栈顶元素
27 LinkNode* Top_LinkStack(LinkStack* stack);
28 // 返回栈元素的个数
29 int Size_LinkStack(LinkStack* stack);
30 // 清空栈
31 void Clear_LinkStack(LinkStack* stack);
32 // 销毁栈
33 void FreeSpace_LinkStack(LinkStack* stack);
34
35
36
37 #endif
标签：LinkStack,13,return,20220612,二叉树,NULL,LinkNode,stack,BinaryNode 来源： https://www.cnblogs.com/stou/p/16368293.html