Java与数据结构——树（二）

顺序存储二叉树

特点：（1）顺序二叉树通常只考虑完全二叉树；（2）第 n 个元素的左子节点为 2*n+1 ；（3）第 n 个元素的右子节点为 2*n+2；（3）第 n 个元素的父节点为 （n-1）/2；（5）n：表示二叉树中的第 n 个元素，按0开始编号，如图所示。

 应用实例：给你一个数组{1,2,3,4,5,6,7}，要求以二叉树前序遍历的方式进行遍历，前序遍历的结果应该为1,2,4,5,3,6,7，进一步完成对数组的中序遍历和后序遍历。

package tree;

public class ArrBinaryTreeDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        //创建一个ArrBinaryTree
        ArrBinaryTree arrBinaryTree = new ArrBinaryTree(arr);
        arrBinaryTree.preOrder();
        arrBinaryTree.infixOrder();
        arrBinaryTree.backOrder();
    }
}
//编写一个ArrayBinaryTree,实现顺序存储二叉树遍历
class ArrBinaryTree{
    private int[] arr;//存储数据节点的数组

    public ArrBinaryTree(int[] arr) {
        this.arr = arr;
    }
    //重载preOrder
    public void preOrder(){
        this.preOrder(0);
        System.out.println();
    }
    //重载infixOrder
    public void infixOrder(){
        this.infixOrder(0);
        System.out.println();
    }
    //重载后序遍历
    public void backOrder(){
        this.backOrder(0);
        System.out.println();
    }
    //编写一个方法，完成顺序存储二叉树的前序遍历
    public void preOrder(int index){
        if (arr == null || arr.length == 0){
            System.out.println("数组为空，不能按照二叉树的前序遍历！");
            return;
        }
        //输出这个元素
        System.out.print(arr[index]+" ");
        //向左递归
        if ( (2 * index + 1) <arr.length) {
            preOrder(2 * index + 1);
        }
        //向右递归
        if ((2 * index + 2) < arr.length) {
            preOrder(2 * index + 2);
        }

    }
    //编写一个方法，完成顺序存储二叉树的中序遍历
    public void infixOrder(int index){
        if (arr == null || arr.length == 0){
            System.out.println("数组为空，不能按照二叉树的前序遍历！");
            return;
        }
        //向左递归
        if ( (2 * index + 1) <arr.length) {
            infixOrder(2 * index + 1);
        }
        //输出这个元素
        System.out.print(arr[index]+" ");
        //向右递归
        if ((2 * index + 2) < arr.length) {
            infixOrder(2 * index + 2);
        }
    }
    //编写一个方法，完成顺序存储二叉树的后序遍历
    public void backOrder(int index){
        if (arr == null || arr.length == 0){
            System.out.println("数组为空，不能按照二叉树的前序遍历！");
            return;
        }
        //向左递归
        if ( (2 * index + 1) <arr.length) {
            backOrder(2 * index + 1);
        }
        //向右递归
        if ((2 * index + 2) < arr.length) {
            backOrder(2 * index + 2);
        }
        //输出这个元素
        System.out.print(arr[index]+" ");

    }
}

线索化二叉树：利用空指针域提高效率

（1）n 个节点的二叉链表中含有 n+1 【公式： 2n-(n-1) = n+1】个空指针域。利用二叉链表中的空指针域，存放指向该节点在某种遍历次序下的前驱和后继节点的指针（这种独家的指针被称为“线索”）；

（2）这种加上线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树；

（3）一个节点的前一个节点，称为前驱节点；

（4）一个节点的后一个节点，称为后继节点。

应用实例：将下面的二叉树，进行中序线索二叉树。中序遍历的数列为{8， 3， 10， 1，14， 6}

 思路分析：

 说明：当线索二叉树后，Node节点的属性 left 和 right ，有如下情况：

（1）left 指向的是左子树，也可能是指向前驱节点，比如 1节点 left 指向的是左子树，而 10 节点 left 指向的是前驱结点；（2）right 指向的是右子树，也可能是指向后继节点，比如 1节点 right 指向的是右子树，而 10 节点 right 指向的是后继结点；

遍历线索化二叉树

        因为二叉树线索化后，各个节点指向有变化，因此原来的遍历方式不嫩恶搞使用，这时需要使用新的方式遍历线索化二叉树，各个节点可以通过线性方法遍历。因此，这里遍历无需使用递归方式，提高了效率，遍历的次序应该与线索化的次序一致。

package tree;

public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {
        //测试中序线索二叉树功能
        HeroNode2 root = new HeroNode2(1,"tjs");
        HeroNode2 node1 = new HeroNode2(3,"pjh");
        HeroNode2 node2 = new HeroNode2(6,"sjl");
        HeroNode2 node3 = new HeroNode2(8,"wyt");
        HeroNode2 node4 = new HeroNode2(10,"qhb");
        HeroNode2 node5 = new HeroNode2(14,"lyj");

        //二叉树，手动创建，后面会递归创建
        root.setLeft(node1);
        root.setRight(node2);
        node1.setLeft(node3);
        node1.setRight(node4);
        node2.setLeft(node5);


        //测试中序线索化
        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
        threadedBinaryTree.setRoot(root);//设置线索二叉树的根节点
        threadedBinaryTree.infixOrder();

        System.out.println("中序线索化前：");
        HeroNode2 leftNode = node4.getLeft();
        System.out.println("10号节点的前驱节点是：" + leftNode);
        HeroNode2 rightNode = node4.getRight();
        System.out.println("10号节点的后继节点是：" + rightNode);
        System.out.println();
        System.out.println("!!!!!执行线索化操作!!!!!");
        threadedBinaryTree.threadedNodes();//线索化
        System.out.println();
        System.out.println("中序线索化后：");

        //测试：测试 10 号节点
        leftNode = node4.getLeft();
        System.out.println("10号节点的前驱节点是：" + leftNode);
        rightNode = node4.getRight();
        System.out.println("10号节点的后继节点是：" + rightNode);
        System.out.println();
        System.out.println("使用线索化的方式遍历线索化二叉树：");
        threadedBinaryTree.threadedShow();

    }
}
//定义ThreadedBinaryTree 实现线索化二叉树
class ThreadedBinaryTree {
    private HeroNode2 root;
    //为了实现线索化，需要创建一个当前节点的前驱节点的指针
    //在递归进行线索化时，pre 总是保留前一个节点
    private HeroNode2 pre =null;
    public void setRoot(HeroNode2 root) {
        this.root = root;
    }
    //重载中序线索化方法
    public void threadedNodes(){
        this.threadedNodes(root);
    }

    //中序线索化方法
    public void threadedNodes(HeroNode2 node){
        //如果当前节点为空，不能线索化
        if (node == null){
            return;
        }
        //1.先线索化左子树
        threadedNodes(node.getLeft());
        //2.线索化当前节点 !!!有难度!!!

        //处理当前节点的前驱节点
        if (node.getLeft() == null){
            //让当前节点的左指针指向前驱节点
            node.setLeft(pre);
            //修改当前节点的左指针的类型
            node.setLeftType(1);
        }
        //处理后继节点
        if (pre != null && pre.getRight() == null){
            //让前驱结点的右指针指向当前节点
            pre.setRight(node);
            //修改前驱节点的右指针类型
            pre.setRightType(1);
        }
        ///!!!没处理一个节点后，让当前节点是下一个节点的前驱结点
        pre = node;

        //3.线索化右子树
        threadedNodes(node.getRight());
        
    }

    //遍历线索化二叉树的方法
    public void threadedShow(){
        //定义一个遍历，存储当前遍历的节点，从root开始
        HeroNode2 node = root;
        while (node != null){
            //循环找到leftType == 1的节点，第一个找到的就是8节点
            //后面随着遍历而变化，因为当leftType == 1时，说明该节点是按照线索化处理后的有效节点
            while (node.getLeftType() == 0){
                node = node.getLeft();
            }
            //打印当前这个节点
            System.out.println(node);

            //如果当前节点的右指针指向的是后继节点，就一直输出
            while (node.getRightType() == 1){
                //获取到当前节点的后继节点
                node = node.getRight();
                System.out.println(node);
            }
            //替换这个遍历的节点
            node = node.getRight();
        }
    }
    //前序遍历
    public void preOrder(){
        if (this.root != null){
            this.root.preOrder();
        }else{
            System.out.println("二叉树为空，无法遍历！");
        }
    }

    //中序遍历
    public void infixOrder(){
        if (this.root != null){
            this.root.infixOrder();
        }else{
            System.out.println("二叉树为空，无法遍历！");
        }
    }

    //后序遍历
    public void backOrder(){
        if (this.root != null){
            this.root.backOrder();
        }else{
            System.out.println("二叉树为空，无法遍历！");
        }
    }

    //前序查找
    public HeroNode2 preOrderSearch(int no){
        if (root != null){
            return root.preOrderSearch(no);
        }else{
            return null;
        }
    }

    //中序查找
    public HeroNode2 infixOrderSearch(int no){
        if (root != null){
            return root.infixOrderSearch(no);
        }else {
            return null;
        }
    }

    //后序查找
    public HeroNode2 backOrderSearch(int no){
        if (root != null){
            return root.backOrderSearch(no);
        }else{
            return null;
        }
    }

    //删除节点
    public void deleteNode(int no){
        if (root != null){
            if (root.getNo() == no){
                root = null;
            }else{
                root.deleteNode(no);
            }
        }else {
            System.out.println("空树，无法删除！");
        }
    }
}

//创建 heroNode 节点
class HeroNode2{
    private int no;
    private String name;
    private HeroNode2 left;//默认 null
    private HeroNode2 right;//默认 null
    //说明
    //1. 如果 leftType == 0 表示指向的是左子树，如果 leftType == 1 表示指向前驱节点
    //2. 如果 rightType == 0 表示指向的是右子树，如果 rightType == 1 表示指向后继节点
    private int leftType;
    private int rightType;

    public int getLeftType() {
        return leftType;
    }

    public void setLeftType(int leftType) {
        this.leftType = leftType;
    }

    public int getRightType() {
        return rightType;
    }

    public void setRightType(int rightType) {
        this.rightType = rightType;
    }

    public HeroNode2(int no, String name) {
        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 HeroNode2 getLeft() {
        return left;
    }

    public void setLeft(HeroNode2 left) {
        this.left = left;
    }

    public HeroNode2 getRight() {
        return right;
    }

    public void setRight(HeroNode2 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 infixOrder(){
        //左子节点中序遍历
        if (this.left != null){
            this.left.infixOrder();
        }
        //输出当前节点
        System.out.println(this);
        //右子节点中序遍历
        if (this.right != null){
            this.right.infixOrder();
        }
    }

    //编写后序遍历方法
    public void backOrder(){
        //左子节点后序遍历
        if (this.left != null){
            this.left.backOrder();
        }
        //右子节点后序遍历
        if (this.right != null){
            this.right.backOrder();
        }
        //输出当前节点
        System.out.println(this);
    }

    //前序查找
    public HeroNode2 preOrderSearch(int no){
        //先判断当前节点的 no 是否等于要查找的值；
        System.out.println("进入前序遍历~");//记录比较次数
        if (this.no == no){
            return this;
        }
        HeroNode2 resNode = null;
        //判断当前节点的左子节点是否为空，如果不为空则继续递归前序查找；
        if (this.left != null){
            resNode = this.left.preOrderSearch(no);
        }
        //如果左递归前序查找，找到节点，则返回该节点
        if (resNode != null){
            return resNode;
        }
        //断当前节点的右子节点是否为空，如果不为空则向右继续递归前序查找
        if (this.right != null){
            resNode = this.right.preOrderSearch(no);
        }
        //如果找到，则返回该节点，否则返回 null,因为 resNode初始值为 null ，所以直接返回resNode
        return resNode;
    }

    //中序查找
    public HeroNode2 infixOrderSearch(int no){

        HeroNode2 resNode = null;
        if (this.left != null){
            resNode = this.left.infixOrderSearch(no);
        }
        if(resNode != null){
            return resNode;
        }
        System.out.println("进入中序遍历~");//记录比较次数
        if (this.no == no){
            return this;
        }
        if (this.right != null){
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    //后序查找
    public HeroNode2 backOrderSearch(int no){
        HeroNode2 resNode = null;
        if (this.left != null){
            resNode = this.left.backOrderSearch(no);
        }
        if (resNode != null){
            return resNode;
        }
        if (this.right != null){
            resNode = this.right.backOrderSearch(no);
        }
        if (resNode != null){
            return resNode;
        }
        System.out.println("进入后序遍历~");//记录比较次数
        if (this.no == no){
            return this;
        }
        return resNode;
    }

    //递归删除节点
    //(1)如果删除的节点是叶子节点，则删除该节点
    // (2)如果删除的是非叶子节点，则删除该子树
    public void deleteNode(int no){
        if(this.left != null && this.left.no == no){
            this.left = null;
            return;
        }
        if (this.right != null && this.right.no == no){
            this.right = null;
            return;
        }
        if (this.left != null){
            this.left.deleteNode(no);
        }
        if (this.right != null){
            this.right.deleteNode(no);
        }
    }
}