完全二叉树线索化

首先说一下满二叉树，以下是百度对满二叉树的定义

满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。

完全二叉树：如果二叉树的深度为k，则除第k层外其余所有层节点的度都为2，且叶子节点从左到右依次存在。也即是，将满二叉树的最后一层从左到右依次删除若干节点就得到完全二叉树。满二叉树是一棵特殊的完全二叉树，但完全二叉树不一定是满二叉树。

线索二叉树：在二叉树的结点上加上线索的二叉树称为线索二叉树，对二叉树以某种遍历方式（如先序、中序、后序或层次等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化。对于n个结点的二叉树，在二叉链存储结构中有n+1个空链域，利用这些空链域存放在某种遍历次序下该结点的前驱结点和后继结点的指针，这些指针称为线索，加上线索的二叉树称为线索二叉树。

下面我们先定义二叉树节点：

package ThreadBinaryTree;

public class BinaryTreeNode {
    
    int data ;
    
    //左节点
    BinaryTreeNode leftNode = null;
    
    //右节点
    BinaryTreeNode RightNode = null;
    
    //左标志
    int LeftType ;
    
    //右标志
    int RightType ;
    
    
    public BinaryTreeNode(int data) {
        this.data = data;
        this.LeftType = 0;
        this.RightType = 0;
    }
    
    
    public void addLeftChild(BinaryTreeNode Node) {
        this.leftNode = Node;
    }
    
    public void addRightChild(BinaryTreeNode Node) {
        this.RightNode = Node;
    }
    
    public BinaryTreeNode getLeftChild() {
        if(this.leftNode==null) {
            System.out.println("不存在左子节点");
        }
        return this.leftNode;
    }
    
    public BinaryTreeNode getRightChild() {
        if(this.RightNode==null) {
            System.out.println("不存在右子节点");
        }
        return this.RightNode;
    }
    
    //中序遍历
    public void midshow() {
        
        if(this.leftNode!=null) {
            this.leftNode.midshow();
        }
        System.out.print(this.data+",");
        
        if(this.RightNode!=null) {
            this.RightNode.midshow();
        }
        
    }
    
    //线索化之后的中序遍历
    public void afterThreadMidShow() {
            
            if(this.leftNode!=null) {
                if(this.LeftType==0)
                this.leftNode.afterThreadMidShow();
            }
            System.out.print(this.data+",");
            
            if(this.RightNode!=null) {
                if(this.RightType==0)
                this.RightNode.afterThreadMidShow();
            }
            
        }

}

这里左标志和右标志 是线索化二叉树会用到的节点，因为我们要标记出来哪个节点是左节点还是前序节点

下面是上面二叉树线索化的实例

package ThreadBinaryTree;

public class ThreadBinaryTreeDemo {
    
    BinaryTreeNode preNode = null;
    
    
    @SuppressWarnings("unused")
    public void ThreadingBinaryTree(BinaryTreeNode Node) {
    

        
        if(Node.leftNode!=null) {
            ThreadingBinaryTree(Node.leftNode);
        }
        
        //前一个节点右边联系到本节点
        
        if(preNode != null && preNode.RightNode==null)
        {
            preNode.RightNode=Node;
            preNode.RightType=1;
        }
        
        //左边联系到前一个节点
        if(Node.leftNode==null) {
            Node.leftNode = preNode;
            Node.LeftType = 1;
        }
        
        preNode = Node;
        
        
        if(Node.RightNode!=null) {
            ThreadingBinaryTree(Node.RightNode);
        }
        
    }
    
    
    
}

最后进行测试

package ThreadBinaryTree;

public class BinaryTreeTest {

    public static void main(String[] args) {
        
        BinaryTreeNode root = new BinaryTreeNode(1);
        BinaryTreeNode Node1 = new BinaryTreeNode(2);
        BinaryTreeNode Node2 = new BinaryTreeNode(3);
        BinaryTreeNode Node3 = new BinaryTreeNode(4);
        BinaryTreeNode Node4 = new BinaryTreeNode(5);
        BinaryTreeNode Node5 = new BinaryTreeNode(6);
        BinaryTreeNode Node6 = new BinaryTreeNode(7);
    
        root.addLeftChild(Node1);
        root.addRightChild(Node2);
        Node1.addLeftChild(Node3);
        Node1.addRightChild(Node4);
        Node2.addLeftChild(Node5);
        Node2.addRightChild(Node6);
        
        root.midshow();
        
        ThreadBinaryTreeDemo tbtd = new ThreadBinaryTreeDemo();
        tbtd.ThreadingBinaryTree(root);
        System.out.println();
        root.afterThreadMidShow();
//        System.out.println(Node4.leftNode.data);        
//        System.out.println(Node4.RightNode.data);
        
        
    }
}

以上便完成了一个完全二叉树的线索化