java实现前中后序线索化二叉树和遍历前中后序线索化二叉树

0.备注

private Node pre = null;
//在递归进行线索化时，pre总是保留前一个结点
private int leftNodeType = 0;
private int rightNodeType = 0;
//0表示子结点，1表示前驱或后继结点。

1.前序线索化

public void preorderThreadedBinaryTree(Node node){
        if(node == null){
            return;
        }
        if(node.getLeft() == null){
            node.setLeft(pre);
            node.setLeftNodeType(1);
        }
        if(pre != null && pre.getRight() == null){
            pre.setRight(node);
            pre.setRightNodeType(1);
        }
        pre = node;
        /**
         *  这里要排除前面添加的线索，访问真正的子节点
         */
        if(node.getLeftNodeType() != 1){
            preorderThreadedBinaryTree(node.getLeft());
        }
        if(node.getRightNodeType() != 1){
            preorderThreadedBinaryTree(node.getRight());
        }



    }

2.遍历前序线索化

public void traverseThreadedTreePreorder(){
        Node temp = getRoot();
        while(temp != null ){
            while( temp.getLeftNodeType() == 0){
                System.out.println(temp);
                temp = temp.getLeft();
            }
            System.out.println(temp);
            while(temp.getRightNodeType() == 1){
                temp = temp.getRight();
                System.out.println(temp);
            }
            /**
             *  下面这句话和遍历的方式有关系，
             *  即在没有记录后继结点指针的情况下，当前结点依照特定顺序的下一个结点是谁。
             *  结点的leftNodeType 为 0,从前序遍历这个角度看，左子节点就是此节点后继。
             *  另外一个角度是rightNodeType == 1,右指针指向后继结点
             *  另外值得注意的是，rightNodeType为 1 一定是后继，但为 0也有可能是，比如最后一个结点的null
             */
            if(temp.getLeftNodeType() == 0){
                temp = temp.getLeft();
            }else if(temp.getLeftNodeType() == 1){
                temp = temp.getRight();
            }

        }
    }

3.中序线索化

 public void inorderThreadBinaryTree(Node node){
//        while(node != null && node.getLeft() != null){
//            node = node.getLeft();
//        }
//        node.setLeft(pre);
//        node.setLeftNodeType(1);
        if(node == null){
            return;
        }
        inorderThreadBinaryTree(node.getLeft());
        if(node.getLeft() == null){
            node.setLeft(pre);
            node.setLeftNodeType(1);
        }
        if(pre != null && pre.getRight() == null){
            pre.setRight(node);
            pre.setRightNodeType(1);
        }
        pre = node;
        inorderThreadBinaryTree(node.getRight());
//        pre = node;
    }

4.遍历中序线索化

 public void traverseThreadedTreeInorder(){
        Node temp = getRoot();
        while(temp != null){
//            temp若要赋值空则leftNodeType为1，所以temp必不为空
            while(temp.getLeftNodeType() == 0){
                temp = temp.getLeft();
            }
            System.out.println(temp);
            while(temp.getRightNodeType() == 1){
                temp = temp.getRight();
                System.out.println(temp);
            }
            temp = temp.getRight();
        }
//        if(temp == null){
//            return;
//        }
//        判断当前结点的左指针类型而不是去判断当前结点的左节点左指针类型
//        while(temp.getLeft() != null && temp.getLeft().getLeftNodeType() == 0){
//            temp = temp.getLeft();
//        }
//        System.out.println(temp);

    }

5.后序线索化

 public void postorderThreadBinaryTree(Node node){
        if(node == null){
            return;
        }
        postorderThreadBinaryTree(node.getLeft());
        postorderThreadBinaryTree(node.getRight());
        if(node.getLeft() == null){
            node.setLeft(pre);
            node.setLeftNodeType(1);
        }
        if(pre != null && pre.getRight() == null){
            pre.setRight(node);
            pre.setRightNodeType(1);
        }
        pre = node;
    }

6.遍历后序线索化
注意，在遍历后序线索化之前需要在Node类新增两个成员变量，parent 记录父节点，traverseRightChildTree 来判断是否遍历过右子树
核心思路是，判断结点的traverseRightChildTree。
真 遍历右子树，并将traverseRightChildTree 置为真（默认都是假）。
假 再往上找父节点，直到找到一个traverseRightChildTree为假的结点进行右子树遍历。
如下一些被注释的代码可以不用看，都是一些构思与错误尝试，直接看do循环那一部分即可。

 public void traverseThreadedTreePostorder(){
        Node temp = getRoot();
        while(temp != null){
            while(temp.getLeftNodeType() == 0){
                temp = temp.getLeft();
            }
            System.out.println(temp);
            while(temp.getRightNodeType() == 1){
                temp = temp.getRight();
                System.out.println(temp);

            }
//            观察到和第一段话一样，可以不用重复再写
//            while(temp.getParent() != null){
//                temp = temp.getParent().getRight();
//                while(temp.getLeftNodeType() == 0){
//                    temp = temp.getLeft();
//                }
//            }

//            比如说findRightChildTree验证为假，则可以将它置为真。
//            if((temp = temp.getParent()) != null){
                如果没有到此节点的右边找一次，则
//                if(!temp.isTraverseRightChildTree()){
//                    temp.setTraverseRightChildTree(true);
//                    temp = temp.getRight();
//                }else{
                    while(!temp.isFindRightChildTree()){
                        temp = temp.getParent();
                    }
//                    if(temp == getRoot()){
//                        System.out.println(temp);
//                        return;
//                    }
//                    do{
//                        temp = temp.getParent();
//                    }while(temp.isTraverseRightChildTree());
//
//                }
//            }
/**
 *          一直往上找，直到找到没有遍历过右子树的结点，进入右子树
 */
            do{
                temp = temp.getParent();
                if(temp == getRoot() && temp.isTraverseRightChildTree()){
                    System.out.println(temp);
                    return;
                }
            }while(temp.isTraverseRightChildTree());
            temp.setTraverseRightChildTree(true);
            temp = temp.getRight();
//            这里不能固定的写成getRight,或者外面给加一个条件
//            if(temp.getParent() != null){
//                temp = temp.getParent().getRight();
//            }
        }
    }