|
二叉树的遍历包括前序遍历、中序遍历、后序遍历三种基本方式，
概念
二叉树的遍历: 是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。
遍历规则：
先序遍历： 优先输出根节点，而后遍历左子树，最后右子树；
中序遍历： 首先遍历左子树，而后访问根节点，再遍历右子树；
后序遍历：先后序遍历右子树，而后左子树，最后访问根节点。
性质：
- 已知前序遍历序列和中序遍历序列，可以唯一确定一棵二叉树。
- 已知后序遍历序列和中序遍历序列，可以唯一确定一棵二叉树。
二叉树的结点类
struct BinaryTreeNode {
int val;
BinaryTreeNode* leftchild;
BinaryTreeNode* rightchild;
BinaryTreeNode(int const& _val, BinaryTreeNode* _leftchild=NULL, BinaryTreeNode* _rightchild=NULL) :
val(_val), leftchild(_leftchild), rightchild(_rightchild) {}
};
遍历方法有两种，一种是递归遍历，一种是非递归遍历，所以接下来每种遍历方法我都会分两种情况进行说明。
递归遍历
首先是递归遍历方法，这种方法只需要熟记三种遍历方法的规则，而后依次递归输出就可以了^ v ^
先序遍历
void PreOrderTraverse(BiTree *T)
{
if(!T.empty()){
cout<<T->ch<<" ";
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
中序遍历
void InOrderTraverse(BiTree *T)
{
if(!T.empty()){
PreOrderTraverse(T->lchild);
cout<<T->ch<<" ";
PreOrderTraverse(T->rchild);
}
}
后序遍历
void PostOrderTraverse(BiTree *T)
{
if(!T.empty()){
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
cout<<T->ch<<" ";
}
}
层序遍历
void getTreeNode(TreeNode* node, vector<vector<int>> &vec, int depth) {
if(node != NULL) {
if(vec.size() <= depth){
vec.push_back(vector<int>());
}
vec[depth].push_back(node->val);
}
else
return;
getTreeNode(node->left,vec,depth+1);
getTreeNode(node->right,vec,depth+1);
}
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> vec;
getTreeNode(root,vec,0);
return vec;
}
非递归遍历
非递归遍历感觉要比递归遍历复杂许多，参考了许多其他博客，大致都是使用栈的思想。
先序遍历
对于根节点P：
1)访问结点P，并将结点P入栈;
2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1)；若不为空，则将P的左孩子置为当前的结点P;
3)直到P为NULL并且栈为空，则遍历结束。
void pre_traversal(BinaryTreeNode* root) {
std::stack<BinaryTreeNode*> node_stack;
while (root != nullptr || !node_stack.empty()) {
if (root != nullptr) {
std::cout << root->val << " ";
node_stack.push(root);
root = root->leftchild;
}
else {
root = node_stack.top();
node_stack.pop();
root = root->rightchild;
}
}
}
中序遍历
与先序遍历类似，唯一区别是到达当前节点时 并不直接输出该节点的值，而是遍历完的左子树后，在输出根节点值。
void in_traversal(BinaryTreeNode* root) {
std::stack<BinaryTreeNode*> stack_node;
while (root != nullptr || !stack_node.empty()) {
if (root != nullptr) {
stack_node.push(root);
root = root->leftchild;
}
else {
root = stack_node.top();
std::cout << root->val << " ";
stack_node.pop();
root = root->rightchild;
}
}
}
后序遍历
后序遍历与先序、中序遍历有所不同，后序遍历在决定是否可以输出当前节点的值的时候，需要考虑其左右子树是否都已经遍历完成。
因此我们需要设置一个lastvisit游标。若lastvisit等于当前考查节点的右子树，表示该节点的左右子树都已经遍历完成，则可以输出当前节点（否则，继续向右子树进发）。并把lastvisit节点设置成当前节点，将当前游标节点root设置为空，下一轮就可以访问栈顶元素。
void post_traversal(BinaryTreeNode* root) {
std::stack<BinaryTreeNode*> stack_node;
BinaryTreeNode* lastvisit = root;
while (root != nullptr || !stack_node.empty()) {
if (root != nullptr) {
stack_node.push(root);
root = root->leftchild;
}
else {
root = stack_node.top();
if (root->rightchild == nullptr || root->rightchild == lastvisit) {
std::cout << root->val << " ";
stack_node.pop();
lastvisit = root;
root = nullptr;
}
else {
root = root->rightchild;
}
}
}
}
参考别的博客，还有另一种方法：
对于根结点P：
1)将P入栈，设置当前结点 cur ；
2)将当前的 cur 置为栈顶结点，如果 cur 不存在左孩子和右孩子，或者 cur 存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则可以直接访问该结点并进行出栈操作。否则将 cur 的右孩子和左孩子依次入栈；
3)直到栈为空则遍历结束。
void nPostOrderTraverse(BiTNode *T)
{
if(T==NULL)
return;
BiTNode* cur;
BiTNode* pre = NULL;
std::stack<BiTNode*> stk;
stk.push(T);
while(!stk.empty())
{
cur = stk.top();
if((cur->lchild==NULL && cur->rchild==NULL) ||
(pre!=NULL && (cur->lchild==pre || cur->rchild==pre)))
{
std::cout<<cur->data<<"\t";
stk.pop();
pre = cur;
}
else
{
if(cur->rchild!=NULL)
stk.push(cur->rchild);
if(cur->lchild!=NULL)
stk.push(cur->lchild);
}
}
}
层序遍历
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode *> q;
vector<vector<int>> vec;
if(root == NULL) return vec;
q.push(root);
while(!q.empty())
{
vector<int> rec;
for(int i=q.size();i>0;i--)
{
TreeNode* list = q.front();
rec.push_back(list->val);
q.pop();
if(list->left)
{
q.push(list->left);
}
if(list->right)
{
q.push(list->right);
}
}
if(!rec.empty())
{
vec.push_back(rec);
}
}
return vec;
}
参考博客链接：
1. 二叉树的遍历 （C++实现）.
2. C++ 二叉树遍历实现.
3.C++编程练习(8)----“二叉树的建立以及二叉树的三种遍历方式“（前序遍历、中序遍历、后续遍历.
4. LeetCode-102. 二叉树的层次遍历(C++).
|