二叉树的前序中序后序遍历

前序遍历：中左右 中序遍历：左中右 后序遍历：左右中
1，首先要有一个treemap（treemap是有序 我这个目前没有顺序）类似的一个类
class BinaryTree{
2，要有一个 头结点这个属性
private HeroNode root;
3，有头结点就必须要给他赋值（这里其实可以用构造方法赋值）
public void setRoot(HeroNode root) {
this.root = root;
}
4，前序遍历 判断头结点是否为空不为空调用 HeroNode(节点)的前序遍历
public void preOrder() {
if(this.root!=null) {
this.root.preOrder();
}else {
System.out.println(“二叉树为空无法遍历”);
}
}
5，中序遍历 判断头结点是否为空不为空调用 HeroNode(节点)的中序遍历
public void infixOrder() {
if(this.root!=null) {
this.root.infixOrder();
}else {
System.out.println(“二叉树为空无法遍历”);
}
}
5，后序遍历 判断头结点是否为空不为空调用 HeroNode(节点)的后序遍历
public void postOrder() {
if(this.root!=null) {
this.root.postOrder();
}else {
System.out.println(“二叉树为空无法遍历”);
}
}
public HeroNode preOrderSearch(int no) {//类推查找
if(root!=null) {
return root.preOedersearch(no);
}else {
return null;
}
}
public HeroNode infixOrderSearch(int no) {
if(root!=null) {
return root.infixOrderSearch(no);
}else {
return null;
}
}
public HeroNode postOrderSearch(int no) {
if(root!=null) {
return root.postOrderSearch(no);
}else {
return null;
}
}
6，删除也是类似都要判断头结点是否为空
public void delNode(int no) {
if(root!=null) {
if(root.getNo()no) {
root=null;
}else {
root.delNode(no);
}
}else {
System.out.println(“空树， 不能删除”);
}
}
}
7，这个就是节点 其实和链表相似 都会有节点
（链表是有一个或两个节点 一个节点的时候都是next 两个节点就是next pre 可以反向查找）二叉树节点就是两个节点是左右 没有反向查找的功能
class HeroNode{
8，int容易判断 （两个属性）
private int no;
private String name;
private HeroNode left;//两个节点 初始化值是空
private HeroNode right;
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;
}
@Override//遍历使用
public String toString() {
return “HeroNode [no=” + no + “, name=” + name + “]”;
}
9，前序遍历 ->中左右（中就是每次递归的当前节点 因为再查到之后没法返回到之前的节点所以要用left的方式调用）
public void preOrder() {
System.out.println(this);
//左指数
if(this.left!=null) {
this.left.preOrder();
}
if(this.right!=null) {
this.right.preOrder();
}
}
10，前序查找就是中左右查找 代码精辟在于每次递归都要用当前对象判断no属性 不是想找的no再去调用左节点
public HeroNode preOedersearch(int no) {
11，判断当前节点， 每次递归都会先查找当前值 所以教前序 （中）
if(this.nono) {
return this;
}
12，创建一个空节点 便于返回值
HeroNode resNode=null;
13，在判断当前节点不是的时候他就判断做节点是否为空 不为空他就要调用本身递归 （这里我明白这个递归会无限递归到最后一个数，在最后一个数的做节点为空的时候他就会跳过这个if判断 继续往下执行 这是resNode还是空 因为没执行完代码所以没有返回值在往下执行 这里就会体现出->左右）
if(this.left!=null) {
resNode=this.left.preOrdersearch(no);
}
if(resNode!=null) {
return resNode;
}
if(this.right!=null) {
resNode= this.right.preOrdersearch(no);
}
return resNode;
}
14，中序便利 都是一样的道理 左中右
public HeroNode infixOrderSearch(int no) {
HeroNode resNode=null;
if(this.left!=null) {
resNode=this.left.infixOrderSearch(no);
}
if(resNode!=null) {
return resNode;
}
if(this.nono) {
return this;
}
if(this.right!=null) {
resNode= this.right.infixOrderSearch(no);
}
return resNode;
}
15，中序便利 都是一样的道理 左右中
public HeroNode postOrderSearch(int no) {
HeroNode resNode=null;
if(this.left!=null) {
resNode=this.left.infixOrderSearch(no);
}
if(resNode!=null) {
return resNode;
}
if(this.right!=null) {
resNode= this.right.infixOrderSearch(no);
}
if(resNode!=null) {
return resNode;
}
if(this.nono) {
return this;
}
return resNode;
}
public void infixOrder() {
if(this.left!=null) {
this.left.infixOrder();
}
System.out.println(this);
//递归向右子树中序遍历
if(this.right!=null) {
this.right.infixOrder();
}
}
后续便利
public void postOrder() {
if(this.left!=null) {
this.left.postOrder();
}
//递归向右子树中序遍历
if(this.right!=null) {
this.right.postOrder();
}
System.out.println(this);
}
16，删除 因为这两个左右节点都只能算是next 不能知道自己的父节点 所以要用 left，right判断
public void delNode(int no) {
if(this.left!=null&&this.left.nono) {
this.left=null;
return;
}
if(this.right!=null&&this.right.nono) {
this.right=null;
return;
}
if(this.left!=null) {
this.left.delNode(no);
}
if(this.right!=null) {
this.right.delNode(no);
}
}
}