逻辑:利用堆栈先进后出,实现二叉树的非递归遍历;
1.先将根结点放入堆栈,将其标签设为 false。
2、弹出堆栈顶端元素,判断标签;
1》若为false设为true,继续放入堆栈;
2》若为true 输出此结点信息,再将此结点的右结点,左结点依次压入堆栈;
3》若为NULL 不执行任何操作;
3、重复执行步骤2 直到堆栈为空;
代码如下,可用企业链表进行改进;
#include <stdio.h>
#include <stdlib.h>
typedef struct BINARYNODE
{
char ch;
struct BINARYNODE* lChild;
struct BINARYNODE* rChild;
int flag;
}BinaryNode;
typedef struct LINKNODE
{
BinaryNode* data;
struct LINKNODE* next;
} LinkNode;
typedef struct LINKSTACK
{
LinkNode* head;
LinkNode* rearNode;
int size;
}LinkStack;
//栈的初始化
void* init_linkStack()
{
LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
//stack->node.next = NULL;
stack->head = (LinkNode*)malloc(sizeof(LinkNode));
stack->head->next = NULL;
stack->rearNode = stack->head;
stack->size = 0;
return stack;
}
//入栈
void pushBack_LinkStack(LinkStack* stack, BinaryNode* data)
{
if (stack == NULL)
return;
if (data == NULL)
return;
if (stack->size == 0)
{
LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
stack->head->data = data;
stack->size++;
}
else
{
LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
newNode->data = data;
newNode->next = stack->head;
stack->head = newNode;
stack->size++;
}
}
//返回栈顶元素;
BinaryNode* top_SeqStack(LinkStack* stack)
{
if (stack == NULL)
return NULL;
return stack->head->data;
}
//出栈
BinaryNode* pop_LinkStack(LinkStack* stack)
{
LinkNode* tempNode = NULL;
if (stack == NULL)
return NULL;
if (stack->size == 0)
return NULL;
if (stack->size == 1)
{
stack->size--;
return stack->head->data;
}
else
{
tempNode = stack->head;
stack->head = stack->head->next;
stack->size--;
return tempNode->data;
}
}
//返回栈顶元素;
void* top_linkStack(LinkStack* stack)
{
return stack->head->data;
}
void destorySpace_SeqStack(LinkStack* stack)
{
if (stack != NULL)
{
free(stack);
stack = NULL;
}
}
void recursion(BinaryNode* root, int* num)
{
BinaryNode* recursionNode = root;
if (root == NULL)
{
return;
}
if (recursionNode->lChild == NULL && recursionNode->rChild == NULL)
{
*num += 1;
printf("%c", recursionNode->ch);
}
//printf("%c", recursionNode->ch);//先序
if (recursionNode->lChild != NULL)
{
recursion(recursionNode->lChild, num);
}
if (recursionNode->rChild != NULL)
{
recursion(recursionNode->rChild, num);
}
}
//计算深度;
int caculateDepth(BinaryNode* root)
{
BinaryNode* tempNode = root;
if (root == NULL)
return 0;
//return 0 后 caculateDepth 不再执行;
int l = caculateDepth(tempNode->lChild);
int r = caculateDepth(tempNode->rChild);
return r >= l ? r + 1 : l + 1;
}
//拷贝二叉树
BinaryNode* copyTree(BinaryNode* root)
{
if (root == NULL)
{
return NULL;
}
BinaryNode* lChild = copyTree(root->lChild);
BinaryNode* rChild = copyTree(root->rChild);
BinaryNode* newNode = (BinaryNode*)malloc(sizeof(BinaryNode));
//这里的链接是自下到上的;
newNode->ch = root->ch;
newNode->lChild = lChild;
newNode->rChild = rChild;
return newNode;
}
void recursion1(BinaryNode* root)
{
BinaryNode* recursionNode = root;
if (root == NULL)
{
return;
}
printf("%c", recursionNode->ch);//先序
if (recursionNode->lChild != NULL)
{
recursion1(recursionNode->lChild);
}
if (recursionNode->rChild != NULL)
{
recursion1(recursionNode->rChild);
}
}
void destorySpace_BinaryNode(BinaryNode* root)
{
if (root == NULL)
return;
destorySpace_BinaryNode(root->lChild);
destorySpace_BinaryNode(root->rChild);
free(root);
//root = NULL;
}
void creatBitreeNode()
{
}
void main()
{
//初始化堆栈;
LinkStack* stack = init_linkStack();
//创建结点;
BinaryNode nodeA = { 'A', NULL, NULL ,0 };
BinaryNode nodeB = { 'B', NULL, NULL, 0 };
BinaryNode nodeC = { 'C', NULL, NULL, 0 };
BinaryNode nodeD = { 'D', NULL, NULL, 0 };
BinaryNode nodeE = { 'E', NULL, NULL, 0 };
BinaryNode nodeF = { 'F', NULL, NULL, 0 };
BinaryNode nodeG = { 'G', NULL, NULL, 0 };
BinaryNode nodeH = { 'H', NULL, NULL, 0 };
//创建树;
nodeA.lChild = &nodeB;
nodeA.rChild = &nodeF;
nodeB.lChild = NULL;
nodeB.rChild = &nodeC;
nodeC.lChild = &nodeD;
nodeC.rChild = &nodeE;
nodeF.lChild = NULL;
nodeF.rChild = &nodeG;
nodeG.lChild = &nodeH;
nodeG.rChild = NULL;
//--------------非递归遍历----------------//
//压入根结点;
pushBack_LinkStack(stack,&nodeA);
//弹出根结点;
BinaryNode* node = pop_LinkStack(stack);
node->flag = 1;
pushBack_LinkStack(stack, &nodeA);
printf("%c", node->ch);
while (stack->size != 0)
{
//pushBack_LinkStack(stack, node->rChild);
//pushBack_LinkStack(stack, node->lChild);
BinaryNode* node = pop_LinkStack(stack);
if (node == NULL)
continue;
else if (node->flag == 1)
{
printf("%c", node->ch);
pushBack_LinkStack(stack, node->rChild);
pushBack_LinkStack(stack, node->lChild);
}
else
{
node->flag = 1;
pushBack_LinkStack(stack,node);
}
}
printf("\n");
system("pause");
return 0;
}