二叉树遍历、查找和删除说明

1.二叉树的概念

（1）数有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
（2）二叉树的子节点分为左节点和右节点
（3）示意图

（4）如果改二叉树的所有叶子节点都在最后一层，并且节点总数=2^n-1，n为层数，则我门称为满二叉树。

（5）如果改二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点再左边连续，倒数第二层的叶子节点再右边连续，我们称为完全二叉树。

2.二叉数遍历说明

（1）前序遍历：先输出父节点，再遍历左子树和右子树，总结起来就是根左右。
（2）中序遍历：先输出左子树，再输出父节点，再遍历右子树，总结起来左根右。
（3）后续遍历：先遍历左子树，再遍历右子树，最后输出父节点，总结起来左右根。

3.二叉树遍历应用实例

3.1思路分析
1.创建一颗二叉树
2.前序遍历
2.1先输出当前节点
2.2如果左节点不为空，则递归继续前序遍历
2.3如果右节点不为空，则递归继续前序遍历
3.中序遍历
3.1如果左节点不为空，则递归继续前序遍历
3.2再输出当前节点
3.3如果右节点不为空，则递归继续前序遍历
4.后序遍历
4.1如果左节点不为空，则递归继续前序遍历
4.2如果右节点不为空，则递归继续前序遍历
4.3.最后输出当前节点
3.2代码演示

public class BinaryTreeeDemo {
    public static void main(String[] args) {
        HeroNode heroNode1 = new HeroNode(1, "宋江");
        HeroNode heroNode2 = new HeroNode(2, "卢俊义");
        HeroNode heroNode3 = new HeroNode(3, "吴用");
        HeroNode heroNode4 = new HeroNode(4, "林冲");
        BinaryTree tree = new BinaryTree();
        heroNode1.setLeft(heroNode2);
        heroNode1.setRight(heroNode3);
        heroNode2.setLeft(heroNode4);
        tree.setRoot(heroNode1);
        /*
         *二叉树
         *      1
         *    2   3
         *  4
         */
        //tree.preOrder();//1243
        //tree.infixOrder();//4213
        tree.postOrder();//4231
    }
}
//二叉树
class BinaryTree{
    //根节点
    private HeroNode root;

    public HeroNode getRoot() {
        return root;
    }

    public void setRoot(HeroNode root) {
        this.root = root;
    }
    //前序遍历
    public void preOrder() {
        if (this.root != null){
            this.root.preOrder();
        }
    }
    //中序遍历
    public void infixOrder() {
        if (this.root != null){
            this.root.infixOrder();
        }
    }
    //后序遍历
    public void postOrder() {
        if (this.root != null){
            this.root.postOrder();
        }
    }
}
//定义HeroNode，每个HeroNode对象就是一个节点
class HeroNode {
    private Integer no;
    private String name;
    private HeroNode left;//左指针
    private HeroNode right;//右指针
    public HeroNode() {
    }

    public HeroNode(Integer no, String name) {
        this.no = no;
        this.name = name;

    }

    public Integer getNo() {
        return no;
    }

    public void setNo(Integer 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;
    }
    //前序遍历
    public void preOrder() {
        //先输出跟节点
        System.out.println(this);
        //再输出左节点
        if (this.left != null){
            this.left.preOrder();
        }
        //最后输出右节点
        if (this.right != null) {
            this.right.preOrder();
        }
    }
    //中序遍历
    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);

    }
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name=" + name +
                "}";
    }
}

4.二叉树查找应用实例

4.1思路分析
前序查找
(1)先判断当前节点是否是要查找的节点，如果是则返回当前节点
(2)如果不等，判断当前节点的左节点是否不为空，如果不为空再左子树上递归前序查找
(3)如果再左子树上找到目标节点，则直接返回该节点，否则继续在右子树上进行递归前序查找，不管找没找到都直接返回。
中序查找
(1)判断当前节点的左节点是否不为空，如果不为空再左子树上递归中序查找
(2)如果再左子树上找到目标节点，则直接返回该节点
(3)不然判断当前节点是否是是要查找的节点，如果是则返回当前节点
(4)如果不是，判断当前节点的右节点是否不为空，如果不为空再右子树上递归中序查找，不管找没找到都直接返回
后序查找
(1)判断当前节点的左节点是否不为空，如果不为空再左子树上递归中序查找
(2)如果再左子树上找到目标节点，则直接返回该节点，否则继续在右子树上进行递归后序查找
(3)随后判断当前节点是否是目标节点，如果是直接返回
(4)最后，不管找没找到都直接返回
4.2代码实现

//前序遍历查找
public void preOrderSearch(int no) {
    if (this.root != null){
        System.out.println("通过英雄排名找到了英雄:"+this.root.preOrderSearch(no));
    }
}
//中序遍历查找
public void infixOrderSearch(int no) {
    if (this.root != null){
        System.out.println("通过英雄排名找到了英雄:"+this.root.infixOrderSearch(no));
    }
}
//后序遍历查找
public void postOrderSearch(int no) {
    if (this.root != null){
        System.out.println("通过英雄排名找到了英雄:"+this.root.postOrderSearch(no));
    }
}

//前序遍历查找
public HeroNode preOrderSearch(int no) {
    if (this.no == no) {
        return this;
    }
    HeroNode result = null;
    //先在左子树上查找
    if (this.left != null){
        result = this.left.preOrderSearch(no);
    }
    //如果result不为null,那么说明找到了，就不用查找右子树了
    if (result != null) {
        return result;
    }
    //再在右子树上查找
    if (this.right != null) {
        result = this.right.preOrderSearch(no);
    }
    return result;
}

//中序遍历查找
public HeroNode infixOrderSearch(int no) {
    HeroNode result = null;
    if (this.left != null){
        result = left.infixOrderSearch(no);
    }
    if (result != null) {
        return result;
    }
    if (this.no == no) {
        return this;
    }
    if (this.right != null) {
        result = right.infixOrderSearch(no);
    }
    return result;
}
//后序遍历查找
public HeroNode postOrderSearch(int no) {
    HeroNode result = null;
    if (this.left != null){
        result = left.postOrderSearch(no);
    }
    if (result != null) {
        return result;
    }
    if (this.right != null) {
        result = right.postOrderSearch(no);
    }
    if (this.no == no) {
        return this;
    }
    return result;
}

5.二叉树删除应用实例

5.1思路分析
规定：
(1)如果删除的节点时叶子节点，则删除改节点
(2)如果删除的节点时非叶子节点，则删除改子树
思路：
(1)如果树是空树，则抛出空指针异常，如果根节点就是目标节点就把根节点置空
(2)因为本次二叉树是单向的，所有我们是判断当前节点的子节点是否是要删除的节点，而不能取判断当前这个节点是不是要删除的节点
(3)如果当前节点的左子节点不为空，并且左子节点就是要删除的节点，就将this.left=null，并且就返回删除节点的编号
(4)如果当前节点的右子节点不为空，并且右子节点就是要删除的节点，就将this.right=null，并且就返回删除节点的编号
(5)如果第3和第4步没有删除节点，那么我们就要向左子树进行递归删除
(6)如果第5步也没有删除节点，则向右子树进行递归删除
5.2代码实现

public void deleteNode(int no) {
    if (root == null) {
        throw new NullPointerException("根节点为空");
    }
    if (this.root.getNo() == no){
        this.root = null;
        System.out.println("删除节点成功："+this.root.getNo());
        return;
    }
    System.out.println("删除节点成功："+this.root.deleteNode(no));
}
//删除节点,返回删除节点的编号
public int deleteNode(int no) {
    //不能直接删除当前节点，要删除当前节点的子节点，因为这是一个单向树，删除当前节点时并不能删除父节点对当前节点的依赖
    //删除当前节点左子节点
    if (this.left != null && this.left.no == no) {
        this.left = null;
        return no;
    }
    //删除当前节点右子节点
    if (this.right != null && this.right.no == no) {
        this.right = null;
        return no;
    }
    int result = -1;
    //在左子树上递归删除节点
    if (this.left != null) {
        result = this.left.deleteNode(no);
    }
    //如果result不等于-1就说明删除目标节点了，就不需要遍历右子树了
    if (result != -1) {
        return result;
    }
    //在右子树上递归删除节点
    if (this.right != null) {
        result = this.right.deleteNode(no);
    }
    return result;
}