小白都能理解的三种遍历非递归算法C++实现

文章结构

一.这篇博客先从最简单的中序遍历非递归算法讲起，提供伪码，并提供具体的C++实现代码，帮助你理解整个过程。
二.然后接下来你会发现，先序遍历非递归算法，只需将中序遍历进行改一行代码即可实现先序遍历非递归算法
三.最后进行讲解后序遍历非递归算法

中序遍历非递归遍历算法

1. 遇到一个结点，就把它压栈，并去遍历它的左子树；
2. 当左子树遍历结束后，从栈顶弹出这个结点并访问它；
3. 然后按其右指针再去中序遍历该结点的右子树。
   伪码如下：

void InOrderTraversal( BinTree BT )
{ 	BinTree T=BT;
	Stack S = CreatStack( MaxSize ); /*创建并初始化堆栈S*/
	while( T || !IsEmpty(S) ){
		while(T){ /*一直向左并将沿途结点压入堆栈*/
		Push(S,T);
		T = T->Left;
}
	if(!IsEmpty(S)){
	T = Pop(S); /*结点弹出堆栈*/
	printf(“%5d”, T->Data); /*（访问）打印结点*/
	T = T->Right; /*转向右子树*/
}
}
}

//C++代码

#include<iostream>
#define MAX 100//定义数组长度
using namespace std;
typedef struct node{
	int data;
	struct node *lchild;
	struct node *rchild;
}Node, *BTnode;
//建树算法
Node *createBiTree(){
	BTnode root;
	int ch;
	cin >> ch;
	if (ch == 0)
		root = NULL;//节点值置空 输入1 2 0 0 0 先序遍历得到1 2两个节点值
	else{
		root = new node;
		root->data = ch;
		root->lchild = createBiTree();
		root->rchild = createBiTree();
	}
	return root;
}
struct Stack//建立栈
{
	BTnode point[MAX];//节点数组 
	//int value[MAX];
	int top;//栈顶的数组序号
};
void Init(Stack &s)//初始化栈
{
	s.top = -1;
}
int Push(Stack &s, BTnode e)//把节点e压入栈顶
{
	if (s.top>MAX - 1)//如果超出栈的容量，返回0
		return 0;
	s.top++;//栈顶加1
	s.point[s.top] = e;//把e赋给栈顶
	return 1;
}
int IsEmpty(Stack s)//判定栈是否为空
{
	if (s.top == -1)
		return 1;
	else
		return 0;
}
Node* Pop(Stack &s){
	if (s.top == -1)
		return NULL;
	BTnode root = s.point[s.top--];//退栈 
	return root;
}

//中序遍历非递归算法
void Inorder(BTnode T){
	//建栈
	Stack s;
	Init(s);//记得初始化栈
	while (T || !IsEmpty(s)){
		while (T){
			Push(s, T);
			T = T->lchild;
		}
		if (!IsEmpty(s)){
			T = Pop(s);
			cout << T->data << " ";
			//printf("%d ", T->data);
			T = T->rchild;

		}

	}
}

int main(){
	BTnode root;
	root = NULL;
	root = createBiTree();//建树成功 
	Inorder(root);//中序遍历非递归算法 
	return 0;
}

输入1 2 0 0 0
中序遍历得到2 1

//

先序遍历非递归算法

其实，先序遍历非递归算法，与中序遍历非递归算法基本相似。只需要在遍历过程中，第一次遇见该节点，就输出该节点值

//先序遍历非递归算法
void Inorder(BTnode T){
	//建栈
	Stack s;
	Init(s);//记得初始化栈
	while (T || !IsEmpty(s)){
		while (T){
			Push(s, T);
			cout << T->data << " ";//第一次遇见该节点，输出该节点值
			T = T->lchild;
		}
		if (!IsEmpty(s)){
			T = Pop(s);
			//printf("%d ", T->data);
			T = T->rchild;

		}

	}
}

后序遍历非递归算法

思路大概这样：第二次pop出来再cout,第二次pop的时候要么右节点是空的，要么右节点刚刚被cout
所以，我需要另一个指针LT来记录被刚刚输出的节点。
或者你可以用flag来标记其是否已被访问过两次

伪码如下：

void PostOrderTraversal(Bintree BT) {  
    Bintree T = BT;
	Bintree LT = NULL;
    Stack S = CreateStack(Maxsize);
    while (T || !IsEmpty(S)) {
        while (T) {
            Push(S, T);  
            T = T->left;   //转向左子树
        }
        if (!IsEmpty(S)) {
            T = Pop(s);
            if ((T-> Right== NULL)||(T->Right == LT)) {    //判断右节点为空或者右节点已经输出
        printf("%d", T->Data);
				LT = T； //记录下上一个被输出的节点
				T = NULL;//已经成功输出了节点，进行置空
            }
            else {
                Push(S, T);  //第二次入栈（相当于T没有出栈）
                T = T->Right;  //转向右子树
            }
        }
    }
}

算法实现如下：

#include<iostream>
#define MAX 100//定义数组长度
using namespace std;
typedef struct node{
	int data;
	struct node *lchild;
	struct node *rchild;
}Node, *BTnode;
//建树算法
Node *createBiTree(){
	BTnode root;
	int ch;
	cin >> ch;
	if (ch == 0)
		root = NULL;
	else{
		root = new node;
		root->data = ch;
		root->lchild = createBiTree();
		root->rchild = createBiTree();
	}
	return root;
}
struct Stack//建立栈
{
	BTnode point[MAX];//节点数组 
	//int value[MAX];
	int top;//栈顶的数组序号
};
void Init(Stack &s)//初始化栈
{
	s.top = -1;
}
int Push(Stack &s, BTnode e)//把节点e压入栈顶
{
	if (s.top>MAX - 1)//如果超出栈的容量，返回0
		return 0;
	s.top++;//栈顶加1
	s.point[s.top] = e;//把e赋给栈顶
	return 1;
}
int IsEmpty(Stack s)//判定栈是否为空
{
	if (s.top == -1)
		return 1;
	else
		return 0;
}
Node* Pop(Stack &s){
	if (s.top == -1)
		return NULL;
	BTnode root = s.point[s.top--];//退栈 
	return root;
}

//后序遍历非递归算法
#include<iostream>
#define MAX 100//定义数组长度
using namespace std;
typedef struct node{
	int data;
	struct node *lchild;
	struct node *rchild;
}Node, *BTnode;
//建树算法
Node *createBiTree(){
	BTnode root;
	int ch;
	cin >> ch;
	if (ch == 0)
		root = NULL;
	else{
		root = new node;
		root->data = ch;
		root->lchild = createBiTree();
		root->rchild = createBiTree();
	}
	return root;
}
struct Stack//建立栈
{
	BTnode point[MAX];//节点数组 
	//int value[MAX];
	int top;//栈顶的数组序号
};
void Init(Stack &s)//初始化栈
{
	s.top = -1;
}
int Push(Stack &s, BTnode e)//把节点e压入栈顶
{
	if (s.top>MAX - 1)//如果超出栈的容量，返回0
		return 0;
	s.top++;//栈顶加1
	s.point[s.top] = e;//把e赋给栈顶
	return 1;
}
int IsEmpty(Stack s)//判定栈是否为空
{
	if (s.top == -1)
		return 1;
	else
		return 0;
}
Node* Pop(Stack &s){
	if (s.top == -1)
		return NULL;
	BTnode root = s.point[s.top--];//退栈 
	return root;
}

//后序遍历非递归算法
void Postorder(BTnode T){
	BTnode LT;
	//建栈
	Stack s;
	Init(s);//记得初始化栈
	while (T || !IsEmpty(s)){
		while (T){
			Push(s, T);
			T = T->lchild;
		}
		if (!IsEmpty(s)){
			T = Pop(s);
			if ((T->rchild == NULL) || (T->rchild == LT)){
				cout << T->data << " ";
				LT = T;//记录下上一个被输出的
				T = NULL;//该节点成功输出了，就可以置空
			}
			else{
				Push(s, T);//刚弹出，又压栈进入
				T = T->rchild;
			}
		}

	}
}

int main(){
	BTnode root;
	root = NULL;
	root = createBiTree();//建树成功 
	Postorder(root);//后序遍历非递归算法 
	return 0;
}