二叉树的三种遍历方式（学习记录）

• 二叉树是什么：二叉树就是每个节点最多有两个子节点，且有一个父节点。
• 有些时候会遇到完全二叉树，完全指的就是二叉树的每一层都是按照从左到右一一把每个位置填满，直到最后一个。不会存在最后一层的上面层有节点缺失的情况。

1、二叉树的前序遍历

前序遍历：中左右（先遍历中间，再遍历左边和右边）
分为递归和非递归方式遍历

树的定义
class tree{
int val;
tree left;
tree right;
tree(){}
tree(int val){
this.val = val;
}
tree(int val,tree left,tree right){
this.val = val;
this.left = left;
this.right = right;
}

二叉树的前序遍历：递归方式
public List<Integer> qianxu(tree root){
	List<Integer> res = new ArrayList<>();
	dfs(root,res);
	return res;
}
public void dfs(tree node,List<Integer> res){
	if(node==null)return;//出口
	res.add(node.val);
	dfs(node.left,res);
	dfs(node.right,res);
}

二叉树的前序遍历：迭代方式
public List<Integer> qianxu(tree root){
	List<Integer> res = new ArrayList<>();
	//如果根节点是空，那么就没有东西，直接返回空的list
	if(root==null) return res;
	//栈模拟递归的操作
	Deque<tree> stack = new LinkedList<>();
	//结束条件是，栈空且当前节点为空
	tree node = root;
	while(!stack.isEmpty() || node!=null){
		//针对每一个节点，中左右，先把值加到res中，再一路把左节点入栈
		while(node!=null){
			res.add(node.val);
			stack.addLast(node);
			node= node.left;
		}
		//把前面入栈的最后一个pop出
		//中和左都操作完成，之后需要操作该节点的右节点
		node = stack.pollLast();
		node = node.right;//node移动后，继续前面的中左访问操作
	}
	return res;
}

2、二叉树的中序遍历

中序遍历：左中右（先遍历左边，再中，最后遍历右边）
分为递归和非递归方式遍历

递归方式：左中右
public List<Integer> zhongxu(tree root){
	List<Integer> res = new ArrayList<>();
	dfs(root,res);
	return res;
}
public void dfs(tree node,List<Integer> res){
	if(node==null)return;//出口
	dfs(node.left,res);
	res.add(node.val);
	dfs(node.right,res);
}

迭代方式：左中右
public List<Integer> zhongxu(tree root){
	List<Integer> res = new ArrayList<>();
	//如果根节点是空，那么就没有东西，直接返回空的list
	if(root==null) return res;
	//栈模拟递归的操作
	Deque<tree> stack = new LinkedList<>();
	//结束条件是，栈空且当前节点为空
	tree node = root;
	while(!stack.isEmpty() || node!=null){
		//针对每一个节点，左中右，直接把所有左节点入栈
		while(node!=null){
			stack.addLast(node);
			node = node.left;
		}
		//把前面入栈的最后一个pop出
		node = stack.pollLast();
		res.add(node.val);//加入答案
		node = node.right;//node移动后，继续前面的左中访问操作
	}
	return res;
}

3、二叉树的后序遍历

后序遍历：左右中（先遍历左边和右边，最后中）
分为递归和非递归方式遍历

递归方式：左右中
public List<Integer> houxu(tree root){
	List<Integer> res = new ArrayList<>();
	dfs(root,res);
	return res;
}
public void dfs(tree node,List<Integer> res){
	if(node==null)return;//出口
	dfs(node.left,res);
	dfs(node.right,res);
	res.add(node.val);
}

迭代方式：左右中
public List<Integer> houxu(tree root){
	List<Integer> res = new ArrayList<>();
	//如果根节点是空，那么就没有东西，直接返回空的list
	if(root==null) return res;
	//栈模拟递归的操作
	Deque<tree> stack = new LinkedList<>();
	//前驱节点，目的在于判断什么时候该加res
	tree pre= null;
	//结束条件是，栈空且当前节点为空
	while(!stack.isEmpty() || root!=null){
		//针对每一个节点，把所有左节点入栈
		while(root!=null){
			stack.addLast(root);
			root = root.left;
		}
		//把前面入栈的最后一个pop出
		root= stack.pollLast();
		//如果当前节点的右节点为空，则可以加res
		//或者当前节点的右节点已经访问完了，等于前驱节点
		if(root.right==null||root.right==pre){
			res.add(root.val);
			pre = root;
			root = null;//当前已经访问完，不再走内部while
			}
		else{
			//把当前节点重新入栈，因为它还没被访问完
			stack.addLast(root);
			root = root.right;
			}
	}
	return res;
}

总的来说，前序和中序遍历是差不多的。后序遍历麻烦一点，需要去记录当前节点的前一个被访问完的节点，保证某个节点的左和右全部被访问完成。