个人总结之C++实现二叉树遍历（全）

#include<iostream>
#include<stack> 
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;

/*输入实例 
 
                1
           2        3
        4    5    6    7
      -1-1 -1-1 -1-1 -1-1
此树的前序遍历为：1 2 4 -1 -1 5 -1 -1 3 6 -1 -1 7 -1 -1
而-1为无子数标记；
因此建造树后的前序遍历输出会为：1 2 4 5 3 6 7  
*/ 

// 二叉树节点定义 
struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};


TreeNode* DLR_create_bintree();//前序建树 
TreeNode* DLR_create_bintree2(vector<int>arr, int *p_start);// 直接vector序列建树
 
void DLR_recursion(TreeNode* Tree);//前序遍历（递归形式） 
void LDR_recursion(TreeNode* Tree);//中序遍历（递归形式） 
void LRD_recursion(TreeNode* Tree);//后序遍历（递归形式） 

void DLR_no_recursion_1(TreeNode* Tree);//前序遍历（非递归形式）实现1 
void DLR_no_recursion_2(TreeNode* Tree);//前序遍历（非递归形式）实现2 

void LDR_no_recursion_1(TreeNode* Tree);//中序遍历（非递归形式）实现1，当然还存在其他实现形式，待补充 

void LRD_no_recursion_1(TreeNode* Tree);//后序遍历（非递归形式）实现1，当然还存在其他实现形式，待补充

void level_order(TreeNode* Tree);//层次遍历（就是BFS） 
void DFS_order(TreeNode* Tree);//深度优先遍历（DFS用栈）
void BFS_order(TreeNode* Tree);//广度优先遍历（BFS用队列）


int main(){
//	用户输入树的前序遍历进行建树（-1表示无孩子了） 
//  复制到输入框：1 2 4 -1 -1 5 -1 -1 3 6 -1 -1 7 -1 -1 
//	TreeNode* my_tree1 = DLR_create_bintree();
	
	vector<int> array{1, 2, 4, -1, -1, 5, -1, -1, 3, 6, -1, -1, 7, -1, -1}; 
	int start_index = 0;
	TreeNode* my_tree1 = DLR_create_bintree2(array, &start_index); 
	

	DLR_recursion(my_tree1); cout << endl;// 前序遍历（递归形式）
	DLR_no_recursion_1(my_tree1);cout << endl;// 前序遍历（非递归形式）实现1 
	DLR_no_recursion_2(my_tree1);cout << endl;// 前序遍历（非递归形式）实现2 
//	LDR_recursion(my_tree1); cout << endl;// 中序遍历（递归形式）
//	LDR_no_recursion_1(my_tree1);cout << endl;// 中序遍历（非递归形式）实现1 
//	LRD_recursion(my_tree1); cout << endl;// 后序遍历（递归形式）
//	LRD_no_recursion_1(my_tree1);cout << endl;// 后序遍历（非递归形式）实现1 	
	
//	level_order(my_tree1);cout << endl; //层次遍历（就是BFS）
//	DFS_order(my_tree1);cout << endl;//深度优先遍历（DFS用栈）
//	BFS_order(my_tree1);cout << endl;//广度优先遍历（BFS用队列） 


	return 0;
} 

// 根据用户输入的前序遍历构建二叉树 
TreeNode* DLR_create_bintree(){
	TreeNode* root; 
	int input_data;
	cin >> input_data;
	if(input_data == -1)
		root = NULL;
	else{
		root = new TreeNode(input_data);
		root->left = DLR_create_bintree();
		root->right = DLR_create_bintree();
	}
	return root; 
}
 
// 使用已有的序列（为一颗树的前序遍历）构造二叉树 
TreeNode* DLR_create_bintree2(vector<int>arr, int *start_index){
	TreeNode* root = NULL;
	if(arr[*start_index] != -1){
		root = new TreeNode(arr[(*start_index)]);
		(*start_index)++;
		root->left = DLR_create_bintree2(arr, start_index);
		(*start_index)++;
		root->right = DLR_create_bintree2(arr, start_index);
	}
	return root;			
}

// 递归实现树的 前序遍历
void DLR_recursion(TreeNode* Tree){
	if(NULL != Tree){
		cout << Tree->val << ' ';
		DLR_recursion(Tree->left);
		DLR_recursion(Tree->right); 
	}
} 

// 非递归实现树的 前序遍历（需要使用 栈 来记录回溯点）
// 实现1 
void DLR_no_recursion_1(TreeNode* Tree){
	stack<TreeNode*> node_stack;
	while(Tree != NULL || !node_stack.empty()){
		if(Tree != NULL){
			cout << Tree->val << ' ';
			node_stack.push(Tree); // 将当前节点保存以便处理右子树时回溯 
			Tree = Tree->left;
		}else{
			TreeNode* root_node  = node_stack.top();
			node_stack.pop();
			Tree = root_node->right; 
		}
	}	
} 
// 非递归实现树的 前序遍历（需要使用 栈 来记录回溯点）
// 实现2 
void DLR_no_recursion_2(TreeNode* Tree){
	stack<TreeNode*> node_stack;
	if(Tree != NULL)
		node_stack.push(Tree); 
	while(!node_stack.empty()){
		TreeNode* tmp_node = node_stack.top();
		node_stack.pop();
		// 此处使用 栈 因此入栈顺序得反着来；
		// 若还按原先的根左右，则是二叉树的镜像二叉树的前序遍历 
		cout << tmp_node->val << ' '; // 根 
		if(tmp_node->right != NULL) // 右 
			node_stack.push(tmp_node->right);
		if(tmp_node->left != NULL) // 左 
			node_stack.push(tmp_node->left);	
	}
}

// 递归实现树的 中序遍历
void LDR_recursion(TreeNode* Tree){
	if(Tree != NULL){
		LDR_recursion(Tree->left);
		cout << Tree->val << ' ';
		LDR_recursion(Tree->right);
	} 
} 

// 非递归实现树的 中序遍历（需要使用 栈 来记录回溯点）
// 实现1 
void LDR_no_recursion_1(TreeNode* Tree){
	stack<TreeNode*> node_stack;
	while(Tree != NULL || !node_stack.empty()){
		if(Tree != NULL){
			node_stack.push(Tree);
			Tree = Tree->left;
		}else{
			TreeNode* root_node = node_stack.top();
			node_stack.pop();
			cout << root_node->val << ' '; 
			Tree = root_node->right;
		}
	}
} 


// 递归实现树的 后序遍历
void LRD_recursion(TreeNode* Tree){
	if(Tree != NULL){
		LRD_recursion(Tree->left);
		LRD_recursion(Tree->right);
		cout << Tree->val << ' ';
	} 
} 

// 非递归实现树的 后序遍历（需要使用 栈 来记录回溯点）
// 镜像二叉树的先序遍历 = 原二叉树后序遍历
// 因此，后序遍历可以看作镜像二叉树的前序遍历然后再反转一下即可； 
// 镜像二叉树的前序遍历 十分 类似 原二叉树的前序遍历非递归形式； 
void LRD_no_recursion_1(TreeNode* Tree){ 
	stack<TreeNode*> node_stack;
	vector<int> tmp_vec;
	if(Tree != NULL)
		node_stack.push(Tree); 
	while(!node_stack.empty()){
		TreeNode* tmp_node = node_stack.top();
		node_stack.pop();
		// 注意此处是 镜像二叉树的前序遍历，不同于二叉树的前序遍历 
		tmp_vec.push_back(tmp_node->val);
		if(tmp_node->left != NULL)
			node_stack.push(tmp_node->left);
		if(tmp_node->right != NULL)
			node_stack.push(tmp_node->right);
	}
	reverse(tmp_vec.begin(), tmp_vec.end());
	for(int i = 0; i < tmp_vec.size(); i++) 
		cout << tmp_vec[i] << ' ';
} 


//层次遍历（就是广度优先遍历BFS）用队列 
void level_order(TreeNode* Tree){
	queue<TreeNode*> node_queue;
	if(Tree != NULL)
		node_queue.push(Tree);
	while(!node_queue.empty()){
		TreeNode* tmp_node = node_queue.front();
		node_queue.pop();
		
		cout << tmp_node->val << ' ';
		if(tmp_node->left != NULL)
			node_queue.push(tmp_node->left);
		if(tmp_node->right != NULL)
			node_queue.push(tmp_node->right);
	}
}

//深度优先遍历（DFS用栈）
void DFS_order(TreeNode* Tree){
	stack<TreeNode*> node_stack;
	if(Tree != NULL)
		node_stack.push(Tree); 
	while(!node_stack.empty()){
		TreeNode* tmp_node = node_stack.top();
		node_stack.pop();
 
		cout << tmp_node->val << ' '; 
		if(tmp_node->right != NULL) 
			node_stack.push(tmp_node->right);
		if(tmp_node->left != NULL) 
			node_stack.push(tmp_node->left);	
	}
}

//广度优先遍历（BFS用队列）
void BFS_order(TreeNode* Tree){
	queue<TreeNode*> node_queue;
	if(Tree != NULL)
		node_queue.push(Tree);
	while(!node_queue.empty()){
		TreeNode* tmp_node = node_queue.front();
		node_queue.pop();
		
		cout << tmp_node->val << ' ';
		if(tmp_node->left != NULL)
			node_queue.push(tmp_node->left);
		if(tmp_node->right != NULL)
			node_queue.push(tmp_node->right);
	}
}