二叉树的遍历 C++

二叉树的遍历包括前序遍历、中序遍历、后序遍历三种基本方式,

概念

二叉树的遍历: 是指从根结点出发,按照某种次序依次访问二叉树中所有结点,使得每个结点被访问一次且仅被访问一次。

遍历规则:
先序遍历: 优先输出根节点,而后遍历左子树,最后右子树;
中序遍历: 首先遍历左子树,而后访问根节点,再遍历右子树;
后序遍历:先后序遍历右子树,而后左子树,最后访问根节点。

性质:

  1. 已知前序遍历序列和中序遍历序列,可以唯一确定一棵二叉树。
  2. 已知后序遍历序列和中序遍历序列,可以唯一确定一棵二叉树。

二叉树的结点类

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++).

  • 0
    点赞
  • 4
    收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:创作都市 设计师:CSDN官方博客 返回首页
评论

打赏作者

Hz_xi

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值