Day04 二叉树的四种遍历(灵活使用Queue、Stack、ArrayList)

博客介绍二叉树有层序、前序、中序、后序四种遍历方式,每种遍历有递归和非递归两种实现算法,实现涉及Queue、Stack、ArrayList等数据结构,还将给出具体实现及测试。

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

转载注明! https://blog.youkuaiyun.com/qq_31842777/article/details/90382639
菜鸟入门,望指正

二叉树有四种遍历方式,即层序遍历、前序遍历、中序遍历、后序遍历。每种遍历都有两种实现方式:递归算法和非递归算法,不同的遍历方式的实现涉及的数据机构不同,主要会用到Queue、Stack、ArrayList。
下面给出各种遍历方式的具体实现及测试。
学习推荐

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

//定义二叉树
public class TreeNode{
	int value=0; //数据域
	TreeNode left=null;// 左子树根节点
	TreeNode right=null;// 右子树根节点
	
	public TreeNode() {}						
	public TreeNode(int value){
		this.value=value;
	}
	public TreeNode(int value,TreeNode left,TreeNode right) {
		this.value=value;
		this.left=left;
		this.right=right;
	}
	
	//层序遍历  使用ArrayList顺序存储数据,使用Queue存取
	public ArrayList<Integer> levelTraversal(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		
		Queue<TreeNode> queue=new LinkedList<TreeNode>();
		queue.offer(root);
		while(!queue.isEmpty()) {
			TreeNode node=queue.poll();
			array.add(node.value);//将遍历到的结点的值添加到array
			if(node.left!=null) {
				queue.offer(node.left);
			}
			if(node.right!=null) {
				queue.offer(node.right);
			}	
		}		
		return array;
	}
	
	//前序遍历递归算法   返回ArrayList对象    
	public ArrayList<Integer> preorderTraversalRec(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		preorderTraversalRec(root,array);
		return array;
	}
	//方法重载
	public void preorderTraversalRec(TreeNode root,ArrayList<Integer> array) {
		if(root==null) {
			return;
		}
		array.add(root.value);
		preorderTraversalRec(root.left,array);
		preorderTraversalRec(root.right,array);
	}
	
	
	//前序遍历非递归算法   ArrayList Stack  先压入右结点,再压入左结点,取出,则为前序遍历
	public ArrayList<Integer> preorderTraversal(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		Stack<TreeNode> stack=new Stack<TreeNode>();
		stack.push(root);
		while(!stack.isEmpty()) {
			TreeNode node=stack.pop();
			array.add(node.value);
			//压入右结点
			if(node.right!=null) {
				stack.push(node.right);
			}
			if(node.left!=null) {
				stack.push(node.left);
			}			
		}
		return array;
	}
	
	
	//中序遍历递归
	public ArrayList<Integer> inorderTraversalRec(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		inorderTraversal(root,array);
		return array;
	}
	public void inorderTraversal(TreeNode root,ArrayList<Integer> array) {
		if(root==null) {
			return;
		}
		inorderTraversal(root.left,array);
		array.add(root.value);
		inorderTraversal(root.right,array);
	}
	
	///中序遍历非递归算法   先存入所有左节点, 
	/**
	 * 拿测试中的二叉树举例,从左到右,从上到下为1,2,4,7,8,见测试
	 * 如 1,2,7  7无左节点,执行if,抛出7,7无右节点,cur为空,不执行while,继续执行if,抛出2
	 * 2有右节点,赋值给cur,cur!=null,执行while,压入8,得到1,8
	 * 8无左节点,执行if,抛出8,8无右节点,cur为空,继续抛出1,此时依次抛出了7,2,8,1
	 * 1有右节点,执行while,压入4,得到4,4无左节点,执行if
	 * 抛出4,得到中序遍历结果7,2,8,1,4
	 */
	public ArrayList<Integer> inorderTraversal(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		Stack<TreeNode> stack=new Stack<TreeNode>();
		TreeNode cur=root;
		while(cur!=null||!stack.isEmpty()) {
			while(cur!=null) {
			stack.add(cur);
			cur=cur.left;
			}
			if(!stack.isEmpty()) {
				cur=stack.pop();
				array.add(cur.value);
				cur=cur.right;
			}
		}
		return array;
	}
	
	//后序遍历递归算法
	public ArrayList<Integer> postorderTraversalRec(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		postorderTraversal(root,array);
		return array;
	}
	public void postorderTraversal(TreeNode root,ArrayList<Integer> array){
		if(root==null) {
			return;
		}
		postorderTraversal(root.left,array);
		postorderTraversal(root.right,array);
		array.add(root.value);
	}
	//后续遍历非递归算法    双栈法     stack1存储结点,先后压入left、right,抛出后依次压入stack2,satck2抛出返回array
	public ArrayList<Integer> postorderTraversal(TreeNode root){
		ArrayList<Integer> array=new ArrayList<Integer>();
		if(root==null) {
			return array;
		}
		Stack<TreeNode> stack1=new Stack<TreeNode>();
		Stack<TreeNode> stack2=new Stack<TreeNode>();
		stack1.add(root);
		while(!stack1.isEmpty()) {
			TreeNode temp=stack1.pop();
			stack2.push(temp);
			if(temp.left!=null) {
				stack1.push(temp.left);
			}
			if(temp.right!=null) {
				stack1.push(temp.right);
			}			
		}
		while(!stack2.isEmpty()) {//抛出stack2的元素,存入arraylist,并返回
			array.add(stack2.pop().value);
		}
		return array;
	}
	
    //测试
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeNode node1=new TreeNode(2,new TreeNode(7),new TreeNode(8));
        TreeNode bTree=new TreeNode(1,node1,new TreeNode(4));     
        System.out.println("二叉树的层序遍历: "+bTree.levelTraversal(bTree));
        System.out.println("二叉树的前序遍历递归算法: "+bTree.preorderTraversalRec(bTree));
        System.out.println("二叉树的前序遍历非递归算法: "+bTree.preorderTraversal(bTree));
        System.out.println("二叉树的中序遍历递归算法: "+bTree.inorderTraversalRec(bTree));
        System.out.println("二叉树的中序遍历非递归算法: "+bTree.inorderTraversal(bTree));
        System.out.println("二叉树的后序遍历递归算法: "+bTree.postorderTraversalRec(bTree));
        System.out.println("二叉树的后序遍历非递归算法: "+bTree.postorderTraversal(bTree));
	}
}

在 Java 中,你可以使用队列(Queue)数据结构来实现二叉树的层序遍历。层序遍历又称广度优先搜索(Breadth-First Search,BFS),会按照从上到下、从左到右的顺序访问节点。这里提供一个递归版本非递归版本的示例: **递归版本**: ```java import java.util.LinkedList; import java.util.Queue; class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int val) { this.val = val; } } public class Solution { public List<List<Integer>> levelOrder(TreeNode root) { if (root == null) return new ArrayList<>(); Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root); List<List<Integer>> result = new ArrayList<>(); while (!queue.isEmpty()) { int size = queue.size(); List<Integer> level = new ArrayList<>(); for (int i = 0; i < size; i++) { TreeNode node = queue.poll(); level.add(node.val); if (node.left != null) queue.offer(node.left); if (node.right != null) queue.offer(node.right); } result.add(level); } return result; } } ``` **非递归版本(使用栈)**: ```java import java.util.Stack; import java.util.ArrayList; import java.util.List; public class Solution { public List<List<Integer>> levelOrder(TreeNode root) { if (root == null) return new ArrayList<>(); Stack<TreeNode> stack = new Stack<>(); stack.push(root); List<List<Integer>> result = new ArrayList<>(); while (!stack.isEmpty()) { int size = stack.size(); List<Integer> level = new ArrayList<>(); for (int i = 0; i < size; i++) { TreeNode node = stack.pop(); level.add(node.val); if (node.left != null) stack.push(node.left); if (node.right != null) stack.push(node.right); } result.add(level); } return result; } } ``` 在这个例子中,我们首先检查根节点是否为空。如果根节点存在,我们将它放入队列或栈中,并开始循环。每次循环,我们都处理当前层的所有节点,然后将它们的左右子节点加入队列或栈以便于后续处理。这样,每完成一层,我们就将其添加到结果列表中。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值