概念：
- 前序遍历：先输出父节点，再遍历左子树和右子树。
- 中序遍历：先遍历左子树，再输出父节点，再遍历右子树。
- 后序遍历：先遍历左子树，再遍历右子树，最后输出父节点。
小结：看输出父节点的顺序，就确定是前序，中序还是后序。
遍历步骤：
- 前序：根左右
- 中序：左根右
- 后序：左右根
代码
先创建一个 HeroNode 节点，里面包含基本属性、构造方法、各种遍历方法的底层代码。
再定义 BinaryTree 二叉树，在二叉树中调用相关的接口。
相当于节点提供具体的底层实现方法，树来进行调用。和前面的哈希表类似。
HeroNode节点类
//先创建HeroNode节点
class HeroNode {
private int no;
private String name;
private HeroNode left;// 默认null
private HeroNode right;// 默认null
public HeroNode(int no, String name) {
super();
this.no = no;
this.name = name;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public HeroNode getLeft() {
return left;
}
public void setLeft(HeroNode left) {
this.left = left;
}
public HeroNode getRight() {
return right;
}
public void setRight(HeroNode right) {
this.right = right;
}
@Override
public String toString() {
return "HeroNode [no=" + no + ", name=" + name + "]";
}
// 编写前序遍历的方法
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);// 最后输出父节点
}
}
定义BinaryTree（二叉树类）
// 定义BinaryTree 二叉树
class BinaryTree {
private HeroNode root;
public void setRoot(HeroNode root) {
this.root = root;
}
// 前序遍历
public void preOrder() {
if (this.root != null) {
this.root.preOrder();// 谁调用，this就指向谁，第一次调用时this就指向root
} 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("二叉树为空，无法遍历~");
}
}
}
关于代码中的this:
谁调用，this就指向谁。
例如：
this.root.postOrder();// 谁调用，this就指向谁，第一次调用时this就指向root
二叉树中的前序遍历中，第一个this，指代当前 BinaryTree类的对象。
postOrder()方法中的 this 指的就是此处的root。
重写toString
记录一下，这里重写的toString方法
在Object类（顶级父类、超类，是所有类的父类）里，定义toString（）方法的时候返回的对象的hashcode码，这个hashcode码不能直观的表示出对象的属性，所以需要重写toString()方法。
当需要将一个对象输出到显示器时，通常要调用他的toString()方法,将对象的内容转换为字符串.java中的所有类默认都有一个toString()方法（因为都继承了Object）。
默认情况下 System.out.println(对象名) 或者System.out.println(对象名.toString())输出的是：此对象的类名和此对象对应内存的首地址，若想自定义输出信息必须重写toString()方法。
以前序遍历为例，因为在 HeroNode 类中重写过了 toString() 方法，所以
第一次调用的 this指代当前类的对象，也就是BinaryTree 类的对象binaryTree
主函数调用当前 BinaryTree 类对象：binaryTree 的 preOrder（前序)方法。
跳转到BinaryTree类中的前序遍历方法，并调用底层，即HeroNode中的前序遍历方法。
跳转到底层代码，执行输出语句
其中，这里的this指代的就是root，因为第一次是被root调用的。
因为重写过了 toString() 方法，所以输出的就不再是：此对象的类名和此对象对应内存的首地址 ，而是输出重写的内容了，如下：
所以，在主函数里测试的前序遍历，会输出：
第一次输出的是root节点，然后递归输出剩下来的子节点。
测试一把：
此时，再加入一个5号节点：关胜。检验一下前、中、后序遍历是否已经理解了。
先预测一波~
前：12354
中：21534
后：25431
输出：没毛病
完整代码：
package com.huey.tree;
public class BinaryTreeDemo {
public static void main(String[] args) {
// 先需要创建一颗二叉树
BinaryTree binaryTree = new BinaryTree();
// 创建需要创建的节点
HeroNode root = new HeroNode(1, "宋江");
HeroNode node2 = new HeroNode(2, "吴用");
HeroNode node3 = new HeroNode(3, "卢俊义");
HeroNode node4 = new HeroNode(4, "林冲");
HeroNode node5 = new HeroNode(5, "关胜");
// 说明：我们先手动创建该二叉树，后面使用递归的方式创建二叉树
root.setLeft(node2);// 由于left是私有的，所以原来的root.left = node2;不能用了
root.setRight(node3);
node3.setRight(node4);
node3.setLeft(node5);
binaryTree.setRoot(root);
// 测试前序
System.out.println("前序遍历~");
binaryTree.preOrder();
// 测试中序
System.out.println("中序遍历~");
binaryTree.midOrder();
// 测试后序
System.out.println("后序遍历~");
binaryTree.postOrder();
}
}
// 定义BinaryTree 二叉树
class BinaryTree {
private HeroNode root;
public void setRoot(HeroNode root) {
this.root = root;
}
// 前序遍历
public void preOrder() {
if (this.root != null) {
this.root.preOrder();// 谁调用，this就指向谁，第一次调用时this就指向root
} 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("二叉树为空，无法遍历~");
}
}
}
//先创建HeroNode节点
class HeroNode {
private int no;
private String name;
private HeroNode left;// 默认null
private HeroNode right;// 默认null
public HeroNode(int no, String name) {
super();
this.no = no;
this.name = name;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public HeroNode getLeft() {
return left;
}
public void setLeft(HeroNode left) {
this.left = left;
}
public HeroNode getRight() {
return right;
}
public void setRight(HeroNode right) {
this.right = right;
}
@Override
public String toString() {
return "HeroNode [no=" + no + ", name=" + name + "]";
}
// 编写前序遍历的方法
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);// 最后输出父节点
}
}