后续遍历最麻烦,对比记忆!
中序遍历(迭代)
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<Integer>();
Stack<TreeNode> stack = new Stack<TreeNode>();
while(stack.size() > 0 || root != null) {
//不断往左子树方向走,每走一次就将当前节点保存到栈中
//这是模拟递归的调用
if(root!=null) {
stack.push(root);
root = root.left;
//当前节点为空,说明左边走到头了,从栈中弹出节点并保存
//然后转向右边节点,继续上面整个过程
} else {
TreeNode tmp = stack.pop();
res.add(tmp.val);
root = tmp.right;
}
}
return res;
}
}
作者:王尼玛
链接:https://leetcode.cn/problems/binary-tree-inorder-traversal/solutions/96765/dong-hua-yan-shi-94-er-cha-shu-de-zhong-xu-bian-li/
来源:力扣(LeetCode)
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
前序遍历(迭代)
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
while (stack.size() > 0 || root != null) {
if (root != null) {
res.add(root.val);
stack.push(root);
root = root.left;
} else {
TreeNode tmp = stack.pop();
root = tmp.right;
}
}
return res;
}
}
后序遍历
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
TreeNode pre = null;
while (stack.size() > 0 || root != null) {
if (root != null) {
stack.push(root);
root = root.left;
} else {
root = stack.pop();
if (root.right == null || pre == root.right) {
res.add(root.val);
pre = root;
root = null;
} else {
stack.push(root);
root = root.right;
}
}
}
return res;
}
}
20180905更新:这个博客中的解法不是很好,看相应的LeetCode题目笔记~~~
我感觉此博客中的说法更容易让人理解:https://blog.csdn.net/woshinannan741/article/details/52825163,还是看这个博客比较好,下面的内容不是很好理解啊。。
本博客转载自:https://blog.csdn.net/xiaominkong123/article/details/51567437
二叉树的三种遍历为:前序遍历,中序遍历和后序遍历。
遍历的实现可分为递归和非递归。递归法与二叉树的定义相似,非递归法采用栈去模拟实现。
定义树节点
struct BinaryTreeNode {
int val;
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
};
##一、前序遍历
遍历的次序为:根结点——左结点——右结点。
###递归
//前序遍历的递归实现
void Pre_travel1(BinaryTreeNode* pRoot) {
if(pRoot == NULL)
return;
cout<< pRoot->val << endl;
if(pRoot->left != NULL)
Pre_travel1(pRoot->left);
if(pRoot->right != NULL)
Pre_travel1(pRoot->right);
}
###非递归
前序遍历的访问顺序为:根,左和右。对于任一结点,其可看做根结点,因此可直接访问。访问完后,若其左孩子不为空,则按照相同规则访问它的左子树;访问完左子树,再访问它的右子树。处理过程如下:
对于任一结点P:
step 1:访问结点p,并将结点p入栈。
step 2:判断结点p的左孩子是否为空。若为空,则取栈顶结点并出栈,将栈顶元素的右孩子设为当前的结点p,循环至 第1步。若不为空,则将p的左孩子设为当前结点p。
step 3:直到p为NULL,并且栈为空,则遍历结束。
//前序遍历的非递归遍历
void Pre_travel2(BinaryTreeNode* pRoot) {
stack<BinaryTreeNode*> s;
BinaryTreeNode *p = pRoot;
if(pRoot == NULL)
return;
while(p != NULL || !s.empty()) {
while(p != NULL) {
cout << p->val << endl;
s.push(p);
p=p->left;
}
if(!s.empty()) {
p=s.top();
s.pop();
p=p->right;
}
}
}
##二、中序遍历
遍历的次序为:左结点——根结点——右结点。
###递归
//中序遍历的递归实现
void Inorder_travel1(BinaryTreeNode* pRoot) {
if(pRoot == NULL)
return;
if(pRoot->left != NULL)
Inorder_travel1(pRoot->left);
cout<< pRoot->val << endl;
if(pRoot->right != NULL)
Inorder_travel1(pRoot->right);
}
###非递归
根据中序遍历的顺序,对于任一结点,先访问其左孩子。而左孩子又可以看做一个根结点,然后继续访问左孩子,直到遇到的左孩子结点为空,则停止访问。然后访问右孩子。
处理过程如下:
对于任一结点p:
step 1:若其左孩子不为空,则将p入栈,并将p的左孩子置为当前的p。然后对当前结点p再进行相同的处理。
step 2:若其左孩子为空,则取栈顶元素并进行出栈操作,访问该栈顶结点,然后将栈顶结点的右孩子置为当前的P结点。
step 3:直到p为NULL并且栈为空则遍历结束。
//中序遍历的非递归法
void Inorder_travel2(BinaryTreeNode* pRoot) {
stack<BinaryTreeNode*> s;
BinaryTreeNode *p = pRoot;
while(p != NULL || !s.empty()) {
while(p!=NULL) {
s.push(p);
p=p->left;
}
if(!s.empty()) {
p=s.top();
cout << p->value <<endl;
s.pop();
p=p->right;
}
}
}
##三、后序遍历
遍历的次序为:左结点——右结点——根结点。
###递归
//后序遍历的递归实现
void Postorder_travel1(BinaryTreeNode* pRoot) {
if(pRoot == NULL)
return;
if(pRoot->left != NULL)
Postorder_travel1(pRoot->left);
if(pRoot->right != NULL)
Postorder_travel1(pRoot->right);
cout<< pRoot->val << endl;
}
###非递归
非递归遍历:要保证根结点在左孩子和右孩子访问之后才能访问。因此对于任一结点p,先将其入栈。
若p不存在左孩子和右孩子,则可以直接访问它。或者p存在左孩子或者右孩子,但是左孩子和右孩子都已经被访问过了,则可以直接访问该结点。
若非上述两种情况,则将右孩子和左孩子依次入栈。这样可以保证每次取栈顶元素时,左孩子在右孩子前面被访问,根结点在左孩子和右孩子访问之后被访问。
//后序遍历的非递归法
void Postorder_travel2(BinaryTreeNode* pRoot) {
stack<BinaryTreeNode*> s;
BinaryTreeNode *cur;
BinaryTreeNode *pre=NULL;
s.push(pRoot);//根结点入栈
while(!s.empty()) {
cur=s.top();
if((cur->left==NULL&&cur->right==NULL)||(pre!=NULL&&(pre==cur->left||pre==cur->right))) {
//左孩子和右孩子同时为空,或者当前结点的左孩子或右孩子已经遍历过了
cout << cur->value << endl;
s.pop();
pre=cur;
}
else {
if(cur->right!=NULL)
s.push(cur->right);
if(cur->left!=NULL)
s.push(cur->left);
}
}
}
关于层次遍历参考链接:剑指offer——面试题60:把二叉树打印成多行
https://blog.csdn.net/allenlzcoder/article/details/79785180