二叉树3种深度优先遍历(递归、非递归)、层次遍历,最简洁、最好记!
#include<iostream>
#include<stack>
#include<queue>
using namespace std;
//节点定义
struct Node
{
char data;
Node *left;
Node *right;
Node(const char &Data, Node *Left = NULL, Node *Right = NULL)
{
data = Data;
left = Left;
right = Right;
}
};
//先序遍历(递归)
void pre_order_recursive(Node *root)
{
if (root == NULL)
return;
cout << root->data << " ";
pre_order_recursive(root->left);
pre_order_recursive(root->right);
}
//中序遍历(递归)
void mid_order_recursive(Node *root)
{
if (root == NULL)
return;
mid_order_recursive(root->left);
cout << root->data << " ";
mid_order_recursive(root->right);
}
//后序遍历(递归)
void post_order_recursive(Node *root)
{
if (root == NULL)
return;
post_order_recursive(root->left);
post_order_recursive(root->right);
cout << root->data << " ";
}
//先序遍历
void pre_order(Node *root)
{
if (root == NULL)
return;
stack<Node*> s;
s.push(root);
Node *p = NULL;
while (!s.empty())
{
p = s.top();
cout << p->data << " ";
s.pop();
if (p->right)
s.push(p->right);
if (p->left)
s.push(p->left);
}
}
//中序遍历
void mid_order(Node *root)
{
if (root == NULL)
return;
stack<Node*> s;
Node *p = root;
while (p != NULL || !s.empty())
{
while (p != NULL)
{
s.push(p);
p = p->left;
}
p = s.top();
cout << p->data << " ";
s.pop();
p = p->right;
}
}
//后序遍历
void post_order(Node *root)
{
if (root == NULL)
return;
stack<Node*> s;
Node *p = root, *r = NULL;
while (p != NULL || !s.empty())
{
while (p != NULL)
{
s.push(p);
p = p->left;
}
p = s.top();
if (p->right&&p->right != r)
{
p = p->right;
}
else
{
cout << p->data << " ";
s.pop();
r = p;
p = NULL;
}
}
}
//层次遍历
void layer_order(Node *root)
{
if (root == NULL)
return;
queue<Node*> q;
q.push(root);
Node *p = NULL;
while (!q.empty())
{
p = q.front();
cout << p->data << " ";
q.pop();
if (p->left)
q.push(p->left);
if (p->right)
q.push(p->right);
}
}
void main()
{
Node *A = new Node('A');
Node *B = new Node('B');
Node *C = new Node('C');
Node *D = new Node('D');
Node *E = new Node('E');
A->left = B;
A->right = C;
B->right = D;
D->left = E;
cout << "先序遍历-递归:";
pre_order_recursive(A);
cout << endl;
cout << "中序遍历-递归:";
mid_order_recursive(A);
cout << endl;
cout << "后序遍历-递归:";
post_order_recursive(A);
cout << endl;
cout << "先序遍历-非递归:";
pre_order(A);
cout << endl;
cout << "中序遍历-非递归:";
mid_order(A);
cout << endl;
cout << "后序遍历-非递归:";
post_order(A);
cout << endl;
cout << "层次遍历:";
layer_order(A);
cout << endl;
delete A; delete B; delete C; delete D; delete E;
getchar();
return;
}
二叉树:
输出: