C++二叉树非递归遍历大合集1种前序和中序遍历以及两种后序遍历

#include <iostream>
#include <stack>


struct BinTreeNode {
int value;
BinTreeNode * leftChild, *rightChild;


BinTreeNode(int data) : value(data), leftChild(nullptr), rightChild(nullptr) {};
};


void preOrderNonRecur(BinTreeNode * root);
void inOrderNonRecur(BinTreeNode * root);
void posOrderNonRecur1(BinTreeNode * root);
void posOrderNonRecur2(BinTreeNode * root);




int main()
{
BinTreeNode root(5);
BinTreeNode n1(9);
BinTreeNode n2(8);
BinTreeNode n3(7);
BinTreeNode n4(6);
BinTreeNode n5(5);
BinTreeNode n6(4);


root.leftChild = &n1;
root.rightChild = &n4;
n1.leftChild = &n2;
n1.rightChild = &n3;
n3.rightChild = &n6;
n4.leftChild = &n5;


preOrderNonRecur(&root);
inOrderNonRecur(&root);
posOrderNonRecur1(&root);
posOrderNonRecur2(&root);


system("pause");
return 0;
}


void preOrderNonRecur(BinTreeNode * root) //先序遍历，先将右孩子压入栈，再将左孩子压入栈，输出
{ //栈顶元素并弹出，结束条件栈空
if (root == nullptr)
{
return;
}
std::cout << "PreOrder: ";


std::stack<BinTreeNode * > stack;//栈保存二叉树结点
stack.push(root);


while (!stack.empty())
{
BinTreeNode * cur = stack.top();
std::cout << cur->value << " ";
stack.pop();

if (cur->rightChild != nullptr)
{
stack.push(cur->rightChild);
}
if (cur->leftChild != nullptr)
{
stack.push(cur->leftChild);
}
}
std::cout << std::endl;
}


void inOrderNonRecur(BinTreeNode * root) //中序遍历，先保存根节点到非空左子树结点，若当前结点为空
{ //输出当前结点并弹出，当前结点重置为弹出结点的右孩子
if (root == nullptr)//当栈空并且当前结点也为nullptr,结束遍历
{
return;
}


std::cout << "InOrder: ";
std::stack<BinTreeNode *> stack;


while (!stack.empty() || root != nullptr)
{
while (root != nullptr )
{
stack.push(root);
root = root->leftChild;
}


if (root == nullptr)
{
std::cout << stack.top()->value << " ";
root = stack.top()->rightChild;
stack.pop();
}
}
std::cout << std::endl;
}


void posOrderNonRecur1(BinTreeNode * root)
{
if (root == nullptr)
{
return;
}


std::cout << "PosOrderNonRecur1: ";
std::stack<BinTreeNode *> stack1, stack2;
stack1.push(root);


while (!stack1.empty())
{
root = stack1.top();
stack1.pop();
if (root->leftChild)
{
stack1.push(root->leftChild);
}
if (root->rightChild)
{
stack1.push(root->rightChild);
}
stack2.push(root);
}


while (!stack2.empty())
{
std::cout << stack2.top()->value << " ";
stack2.pop();
}
std::cout << std::endl;
}


void posOrderNonRecur2(BinTreeNode * root) //后序遍历一个栈实现，用两个变量记录最近输出
{ //和栈顶结点，判断栈顶结点左右子树和最近输出关系
if (root == nullptr)//以及和nullptr关系，再判断右子树和最近输出以及
{ //nullptr之间的关系，最终确定输出
return;
}


std::cout << "posOrderNonRecur2: ";


std::stack<BinTreeNode *> stack;
BinTreeNode *peek = nullptr, *pop = root;//peek 栈顶元素， pop最近弹出元素
stack.push(root);


while (!stack.empty())
{
peek = stack.top();
if (peek->leftChild != nullptr && peek->leftChild != pop && peek->rightChild != pop)
{
stack.push(peek->leftChild);
}
else if (peek->rightChild != nullptr && peek->rightChild != pop)
{
stack.push(peek->rightChild);
}
else
{
std::cout << stack.top()->value << " ";
pop = stack.top();
stack.pop();
}
}
std::cout << std::endl;
}