【完整代码】二叉树的遍历与二叉树查找（Java实现）

一、二叉树遍历

（1）前序遍历
步骤：

1. 创建一棵二叉树
2. 先输出当前节点（根节点root）
3. 如果左子节点不为空，则递归继续前序遍历
4. 如果右子节点不为空，则递归继续前序遍历

（2）中序遍历
步骤：

1. 创建一棵二叉树
2. 如果当前节点的左子节点不为空，则递归中序遍历
3. 输出当前节点（root）
4. 如果当前节点的右子节点不为空，则递归中序遍历

（3）后序遍历
步骤：

1. 创建一棵二叉树
2. 如果当前节点的左子节点不为空，则递归后序遍历
3. 如果当前节点的右子节点不为空，则递归后序遍历
4. 输出当前节点（root）

package erchashu;

public class BinaryTreeDemo {

	public static void main(String[] args) {
		//创建二叉树
		BinaryTree tree = new BinaryTree();
		//创建需要的节点：5-2-4-7-9
		TreeNode root = new TreeNode(5);//节点1
		TreeNode node2 = new TreeNode(2);//节点2
		TreeNode node3 = new TreeNode(4);//节点3
		TreeNode node4 = new TreeNode(7);//节点4
		TreeNode node5 = new TreeNode(9);//节点5
		
		//先手动创建二叉树
		/*        5
		 *    2       4
		 * 7       9
		*/
		root.setLeft(node2);
		root.setRight(node3);
		node2.setLeft(node4);
		node3.setLeft(node5);
		tree.setRoot(root);
		
		//测试前序遍历:5-2-7-4-9
		System.out.println("前序遍历：");
		tree.preOrder();
		//测试中序遍历:7-2-5-9-4
		System.out.println("中序遍历：");
		tree.midOrder();
		//测试后序遍历:7-2-9-4-5
		System.out.println("后序遍历：");
		tree.postOrder();
		
	}
}

//定义二叉树
class BinaryTree{
	private TreeNode root;//节点类的root
	public void setRoot(TreeNode root) {
		this.root = root;
	}
	//前序遍历
	public void preOrder() {
		if(this.root != null) {
			this.root.preOrder();
		}else {
			System.out.println("二叉树为空，无法遍历");
		}
	}
	//中序遍历
	public void midOrder() {
		if(this.root != null) {
			this.root.midOrder();
		}else {
			System.out.println("二叉树为空，无法遍历");
		}
	}
	//后序遍历
	public void postOrder() {
		if(this.root != null) {
			this.root.postOrder();
		}else {
			System.out.println("二叉树为空，无法遍历");
		}
	}
}

//先创造TreeNode节点类
class TreeNode{
	private int value;
	private TreeNode left;
	private TreeNode right;
	public int getValue() {
		return value;
	}
	
	//自动生成方法：Source——Generate Getter and Setter
	public void setValue(int value) {
		this.value = value;
	}
	public TreeNode getLeft() {
		return left;
	}
	public void setLeft(TreeNode left) {
		this.left = left;
	}
	public TreeNode getRight() {
		return right;
	}
	public void setRight(TreeNode right) {
		this.right = right;
	}
	public TreeNode(int value){
		this.value = value;
	}
	//重写toString方法
	@Override
	public String toString() {
		return return Integer.toString(value);
	}
	
	//前序遍历方法
	public void preOrder() {
		//输出父节点
		System.out.println(this);
		//递归向左子树前序遍历
		if(this.left != null) {
			this.left.preOrder();//左子树递归
		}
		//递归向右子树前序遍历
		if(this.right != null) {
			this.right.preOrder();//右子树递归
		}
	}
	
	//中序遍历方法
	public void midOrder() {
		//递归向左子树前序遍历
		if(this.left != null) {
			this.left.midOrder();//左子树递归
		}
		//输出父节点
		System.out.println(this);//输出父节点
		//递归向右子树前序遍历
		if(this.right != null) {
			this.right.midOrder();//右子树递归
		}
	}
	
	//后序遍历方法
	public void postOrder() {
		//递归向左子树前序遍历
		if(this.left != null) {
			this.left.postOrder();//左子树递归
		}
		//递归向右子树前序遍历
		if(this.right != null) {
			this.right.postOrder();//右子树递归
		}
		//输出父节点
		System.out.println(this);//输出父节点
	}
}

二、二叉树查找

使用前序、中序、后续来查找指定
（1）前序查找
步骤：
1.先判断当前结点的值是否等于要查找的；
2.如果相等，则返回当前结点；
3.如果不等，则判断当前结点的左子结点是否为空，不为空则递归前序查找；
4.如果左递归前序查找，找到了结点，则返回，否则继续判断当前结点的右子节点是否为空，不为空则继续向右递归前序查找，找到则返回，否则返回null.

（2）中序查找
步骤：
1.先判断当前结点的左子节点是否为空，如果不为空，则左递归中序查找；
2.如果找到了节点，则返回，否则，和当前结点比较，如果相等，则返回当前结点；
3.如果不等，则判断当前结点的右子节点是否为空，不为空，则右递归中序查找，找到则返回，否则返回null.

（3）后序查找
步骤：
1.先判断当前结点的左子节点是否为空，如果不为空，则左递归后序遍历；
2.如果找到了节点，则返回，否则判断当前结点的右子节点是否为空；
3.如果不为空，则右递归后序查找，找到则返回，否则与当前结点比较；
4.如果相等，则返回当前结点，否则返回null.