二叉树的遍历 JAVA

最新推荐文章于 2025-05-11 23:54:51 发布

原创最新推荐文章于 2025-05-11 23:54:51 发布 · 170 阅读

0 ·

CC 4.0 BY-SA版权

补基础专栏收录该内容

6 篇文章

订阅专栏

本文详细介绍了二叉树的前序、中序和后序遍历方法，包括递归和非递归实现方式，并提供了具体的Java代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

回忆一下二叉树的遍历呼呼~~

首先建立node的基本数据结构

package Easy;
//二叉树的遍历
public class treenode {
    public treenode(int val, treenode left, treenode right){
    	this.val = val;
    	this.left = left;
    	this.right= right;
    }
	
    int val;
    treenode left;
    treenode right;

}

然后构建一棵树呼呼~

public static treenode initial(){
        treenode J = new treenode(34, null, null);  
        treenode H = new treenode(14, null, null);  
        treenode G = new treenode(55, null, null);  
        treenode F = new treenode(13, null, J);  
        treenode E = new treenode(5, H, null);  
        treenode D = new treenode(23, null, G);  
        treenode C = new treenode(4, F, null);  
        treenode B = new treenode(2, D, E);  
        treenode A = new treenode(1, B, C);  
        return A;  //注意在构造二叉树的时候要倒序
	}

第一部分===========================================

使用递归

使用递归就很简单了前序中序后序直接调换顺序即可

public static void preorder(treenode root){
		if(root == null) return;
		System.out.println(root.val);
		preorder(root.left);
		preorder(root.right);
		
	}
	
	public static void inorder(treenode root){
		if(root == null) return;
		
		preorder(root.left);
		System.out.println(root.val);
		preorder(root.right);
		
	}
	
	public static void afterorder(treenode root){
		if(root == null) return;
		
		preorder(root.left);
		preorder(root.right);
		System.out.println(root.val);
		
	}

使用stack

不使用递归的情况下要对节点进行压栈

public static void preorder(treenode root){
		Stack<treenode> stack = new Stack<treenode>();
		treenode node = root;
		 while(node!=null || stack.size()>0){
	        if(node!=null){
			 System.out.println(node.val);//前序是直接先访问根节点
			 stack.push(node);
			 node = node.left;
		 }
		 else {
			 node = stack.pop();//直到所有的左孩子都压栈了在pop然后访问右孩子
			 node = node.right;
		 }
		 }
		
	}
	
	public static void inorder(treenode root){
		Stack<treenode> stack = new Stack<treenode>();
		treenode node = root;
		 while(node!=null || stack.size()>0){
			 if(node!=null){
			 stack.push(node);//中序遍历的时候先不访问root  直接压栈
			 node = node.left;
		 }
		 else {
			 node = stack.pop();//在左孩子全部压栈之后  在pop 然后再考虑右孩子
			 System.out.println(node);
			 node = node.right;
		 }
		 }
	}
	
	public static void afterorder(treenode root){//不使用递归的后序遍历比较麻烦 因为要最后输出root
		 if(root==null)return;  
	        Stack<treenode> s=new Stack<treenode>();  
	        Map<treenode,Boolean> map=new HashMap<treenode,Boolean>();   
	        s.push(root);  
	        while(!s.isEmpty()){  
	        	treenode temp=s.peek();  
	            if(temp.left!=null&&!map.containsKey(temp.left)){  
	                temp=temp.left;  
	                while(temp!=null){  
	                    if(map.containsKey(temp))break;  //在有左孩子的情况下 如果左孩子已经被访问了则不再重复访问
	                    else s.push(temp); //把所有的左孩子都压栈 
	                    temp=temp.left;  
	                }  
	                continue;  
	            }  
	            if(temp.right!=null&&!map.containsKey(temp.right)){  
	                s.push(temp.right);  
	                continue;  //当前temp已经没有左孩子了 就把右孩子压栈
	            }  
	            treenode t=s.pop(); 如果左右孩子都没有 开始退栈 
	            map.put(t,true);  //输出过的节点放进map
	            System.out.println(t.val);  
	        }  
	    }  
	}