二叉树的非递归遍历-CSDN博客

本文链接：https://blog.csdn.net/taiyanggongsi/article/details/48996227

二叉树是一种经典的数据结构，各大公司面试的时候也喜欢考，我将我所总结积累的二叉树的几种非递归遍历分享一下，欢迎大家提出更多更好的方法：

一、先序遍历

方法一，思想是从根节点一直向左边走，边走边打印，左边走不通了，出栈向右边走，边界条件是current!=null或者栈非空

public void preOrder1(){
		if(root==null) return;
		Node current=root;
		Stack<Node> s=new Stack<Node>();
		while(current!=null||!s.isEmpty()){
			while(current!=null){
				System.out.print(current.data+" ");
				s.push(current);
				current=current.leftchild;
			}
			//中间节点不可以再次向左边走
			current=s.pop().rightchild;
			
		}
		System.out.println();
	}

方法二，使用栈先进后出的特性，简洁，我喜欢。先将中间节点出栈打印，然后依次将右孩子、左孩子入栈，循环该步骤。

public void preOrder2(){
		if(root==null) return;
		Stack<Node> s=new Stack<Node>();
		s.push(root);
		while(!s.isEmpty()){
			Node node=s.pop();
			System.out.print(node.data+" ");
			if(node.rightchild!=null)
				s.push(node.rightchild);
			if(node.leftchild!=null)
				s.push(node.leftchild);
		}
		System.out.println();
	}

二、中序遍历

方法一，类似于先序遍历的方法一，在打印顺序上略有不同

public void inOrder1(){
		if(root==null) return;
		Node current=root;
		Stack<Node> s=new Stack<Node>();
		while(current!=null||!s.isEmpty()){
			while(current!=null){
				
				s.push(current);
				current=current.leftchild;
			}
			Node n=s.pop();
			System.out.print(n.data+" ");
			current=n.rightchild;
			
		}
		System.out.println();
	}

方法二，有时候我们不想使用current!=null||!s.isEmpty()这个边界条件，想用简单一点循环终止条件!s.isEmpty()。

两种方法，一种是在向左搜索和向右搜索时，遇到null也入栈，可以保证即使右孩子为null，栈也非空；另一种是向右搜索时做判断，右孩子为空时向上回溯，非空时将右孩子入栈，这就是下面的这种处理方式：

//PS：如果把null也放入栈中，会使代码简洁一点
	public void inOrder2(){
		Stack<Node> s=new Stack<Node>();
		if(root==null) return;
		s.push(root);
		while(!s.isEmpty()){
			Node n=(Node) s.peek();
			while(n.leftchild!=null){
				n=n.leftchild;
				s.push(n);
				
			}
			//栈非空 且都无右节点 往上回溯
			while(!s.isEmpty()&&((Node) s.peek()).rightchild==null){
				
				System.out.print(((Node)s.pop()).data+" ");
				
			}
			if(!s.isEmpty())
			{
				n=((Node) s.pop());
			
				System.out.print(n.data+" ");
				s.push(n.rightchild);
			}
		}
		System.out.println();
	}

三、后序遍历

后序遍历较前两种复杂一点，主要是由于后序遍历时，要经过中间节点两次，每次经过的我们就要想是出栈打印呢还是向右搜索呢，如果右孩子为空，当然直接出栈打印，如果右孩子不为空呢，那么我们要进行一个判断，

方法一：可以使用flag标记，第一次由中间节点到达右孩子时，flag=1,第二次由右孩子返回中间节点时，判断flag==1即可知右子树已经遍历完了，将中间节点出栈打印

方法二：记录下前一个节点pre，经过中间节点时判断，当右孩子为空或者cur.rightchild==pre即pre等于右孩子，则将中间节点出栈打印，否则向右搜索右子树

方法三：使用栈先进后出的特性，中间节点peek后先右孩子入栈再左孩子入栈。这里要做处理，记录下前一个节点，当current.leftchild==pre||current.rightchild==pre时，表示中间节点的左右子树已经遍历过了，将中间节点打印出栈，否则就要考虑将右左孩子入栈。注意：该方法开始时并没有一下子向左遍历到左下节点。

下面是上面三种方法的代码：

<span style="white-space:pre">	</span>public void postOrder1(){
		if(root==null) return;
		Stack<Node> s=new Stack<Node>();
		Node cur=root;
		while(cur!=null||!s.isEmpty()){
			while(cur!=null){
				s.push(cur);
				cur=cur.leftchild;
			}
			cur=s.peek();
			if(cur.rightchild==null||cur.flag==1){
				System.out.print(cur.data+" ");
				s.pop();
				cur=null;
			}else{
				cur.flag=1;
				cur=cur.rightchild;
			}
		}
		System.out.println();
	}

<span style="white-space:pre">	</span>public void postOrder2(){
		if(root==null) return;
		Stack<Node> s=new Stack<Node>();
		Node pre=root;
		Node cur=root;
		while(cur!=null||!s.isEmpty()){
			while(cur!=null){
				s.push(cur);
				cur=cur.leftchild;
			}
			cur=s.peek();
			if(cur.rightchild==null||cur.rightchild==pre){
				System.out.print(cur.data+" ");
				pre=cur;
				s.pop();
				//下次循环时为避免重新push cur后重新向左搜索，要释放掉该cur
				cur=null;
			}else{
				cur=cur.rightchild;
			}
		}
		System.out.println();
	}

//和方法二类似，但是用到了栈的特性，故不用先一直搜索到左下节点
	public void postOrder3(){
		if(root==null) return;
		
		Stack<Node> s=new Stack<Node>();
		s.push(root);
		Node pre=root;
		while(!s.isEmpty()){
			Node current=s.peek();
			//主要是注意回溯栈时，判断栈顶节点是弹出栈打印还是继续向左右方向搜索
			
			
			//后序遍历时，一节点必和其左右子节点相邻且在其后
			//注意不可以使用current.rightchild!=null&¤t.rightchild!=pre来代替判断条件
			if(current.rightchild!=null&¤t.leftchild!=pre&¤t.rightchild!=pre){
				
						s.push(current.rightchild);
			}
			if(current.leftchild!=null&¤t.leftchild!=pre&¤t.rightchild!=pre){
			
					s.push(current.leftchild);
			}
			
			if(current.leftchild==null&¤t.rightchild==null){
				System.out.print(s.pop().data+" ");
				pre=current;
			}
			if(current.leftchild==pre||current.rightchild==pre){
				System.out.print(s.pop().data+" ");
				pre=current;
			}
		}
		System.out.println();
			
	}

方法四：

下面还有一种方法，使用双栈法，相当巧妙，我很喜欢，注意这一次栈s1是先将左孩子入栈，再将右孩子入栈的。

<span style="white-space:pre">	</span>public void postOrder4(){
		if(root==null) return;
		Stack<Node> s1=new Stack<Node>();
		Stack<Node> s2=new Stack<Node>();
		s1.push(root);
		Node cur=root;
		while(!s1.isEmpty()){
			cur=s1.pop();
			s2.push(cur);
			if(cur.leftchild!=null)
				s1.push(cur.leftchild);
			if(cur.rightchild!=null)
				s1.push(cur.rightchild);
		}
		while(!s2.isEmpty()){
			System.out.print(s2.pop().data+" ");
		}
		System.out.println();
	}