#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);
}
}