数据结构和算法-顺序存储二叉树、线索化二叉树

1.顺序存储二叉树

1.1 顺序存储二叉树概念

• 从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组
  要求:
  右图的二叉树的结点，要求以数组的方式来存放 arr : [1, 2, 3, 4, 5, 6, 7]
  要求在遍历数组 arr时，仍然可以以前序遍历，中序遍历和后序遍历的方式完成结点的遍历
  

1.2 顺序存储二叉树的特点:

顺序二叉树通常只考虑完全二叉树
第n个元素的左子节点为 2 * n + 1
第n个元素的右子节点为 2 * n + 2
第n个元素的父节点为 (n-1) / 2

n : 表示二叉树中的第几个元素(按0开始编号，如图所示)

代码：

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();//1,2,4,5,3,6,7
    }

}
//编写一个ArrBinaryTree,实现顺序存储二叉树
class ArrBinaryTree{
    private int[] arr;

    public ArrBinaryTree(int[] arr) {
        this.arr = arr;
    }

    public void preOrder(){
        preOrder(0);
    }

    /**
     * 完成顺序存储二叉树的前序遍历
     * @param index
     */
    public void preOrder(int index){
        //如果数组为空，或者arr.length=0
        if(arr == null || arr.length == 0){
            System.out.println("数组为空，不能按照二叉树的前序遍历");
        }
        //输出当前这个元素
        System.out.println(arr[index]);
        //向左递归遍历
        if((index * 2 + 1) < arr.length){
            preOrder(2 * index + 1);
        }
        //向右递归遍历
        if((index * 2 + 2) < arr.length){
            preOrder(2 * index + 2);
        }
    }
}

2. 线索化二叉树

• n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）
• 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种
• 一个结点的前一个结点，称为前驱结点（遍历时）
• 一个结点的后一个结点，称为后继结点
  
  进行中序线索二叉树。中序遍历的数列为 {8, 3, 10, 1, 14, 6}
  

说明: 当线索化二叉树后，Node节点的 属性 left 和 right ，有如下情况:
left 指向的是左子树，也可能是指向的前驱节点. 比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是前驱节点.
right指向的是右子树，也可能是指向后继节点，比如 ① 节点right 指向的是右子树，而⑩ 节点的right 指向的是后继节点.
代码：

public class ThreadedBinaryTreeDemo {
    public static void main(String[] args){
        System.out.println("中序线索二叉树");
        HeroNode root = new HeroNode(1, "tom");
        HeroNode node2= new HeroNode(3, "jack");
        HeroNode node3 = new HeroNode(6, "smith");
        HeroNode node4 = new HeroNode(8, "mary");
        HeroNode node5 = new HeroNode(10, "king");
        HeroNode node6 = new HeroNode(14, "dim");
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);
        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
        threadedBinaryTree.setRoot(root);
        threadedBinaryTree.threadedNodes();
        //10的前驱结点为3
        System.out.println("10号节点的前驱结点："+node5.getLeft());
        System.out.println("10号节点的后继结点："+node5.getRight());

        System.out.println("线索化方式遍历线索化二叉树");
        threadedBinaryTree.threadList();
    }
}
/**
 * 定义线索化二叉树
 */
class ThreadedBinaryTree{
    private HeroNode root;
    //指向当前节点的前驱节点的指针
    private HeroNode pre = null;
    public  void setRoot(HeroNode root){
        this.root=root;
    }

    public void threadedNodes(){
        this.threadedNodes(root);
    }

    //遍历线索化二叉树
    public void threadList(){
        //存储当前遍历的节点，从root开始
        HeroNode  node = root;
        while(node != null){
            //循环的找到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();
        }
    }

    /**
     * 二叉树中进行中序线索化
     * @param node 当前需要线索化的节点
     */
    public void threadedNodes(HeroNode 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());
    }
}

/**
 * 创建结点
 */
@Getter
@Setter
class HeroNode{
    private int no;
    private String name;
    private HeroNode left;//默认 null
    private HeroNode right;//默认 null
    private int leftType;//为0 表示指向左子树，为1 表示指向前驱节点
    private int rightType;//为0 表示指向右子树，为1 表示指向后继节点

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

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