线索化二叉树并遍历（前序、中序、后序）

前序线索化

方法1

/**
     * @param node 当前需要线索化的结点
     */
    public void preThreadedNodes(HeroNode node) {
        if (node == null) {
            return;
        }

        //1、线索化当前结点（重点）
        //处理当前结点的前驱结点
        if (node.getLeft() == null) {
            //让当前结点的左指针指向前驱结点
            node.setLeft(pre);
            //让当前结点的左指针指向前驱结点
            node.setLeftType(1);
        }

        //处理后继结点
        /**
         * 如果前一处理节点pre的left结点为当前节点node，则不能把pre的right结点设为node
         * 否则preThreadedNodes(node.getLeft())会出现死循环
         */
        if (pre != null && pre.getRight() == null && pre.getLeft() != node) {
            //让前驱结点的右指针指向当前结点
            pre.setRight(node);
            //修改前驱结点的右指针类型
            pre.setRightType(1);
        }

        //每处理一个结点后，让当前结点是下一个结点的前驱结点
        pre = node;

        //2、线索化左子树
        /**
         * node.getLeftType()==0 防止出现死循环
         * 如果当前结点是左叶子结点
         * node.setLeft(pre)已经把node的left设为了pre，而node是pre的左子结点
         * preThreadedNodes(node.getLeft())会进入同一个结点，出现死循环
         */
        if (node.getLeftType() == 0) {
            preThreadedNodes(node.getLeft());
        }

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

方法2

 /**
     * @param node 当前需要线索化的结点
     */
    public void preThreadedNodes2(HeroNode node) {
        if (node == null) {
            return;
        }

        //1、线索化当前结点（重点）
        //处理当前结点的前驱结点
        if (node.getLeft() == null) {
            //让当前结点的左指针指向前驱结点
            node.setLeft(pre);
            //让当前结点的左指针指向前驱结点
            node.setLeftType(1);
        }

        //处理后继结点
        if (pre != null && pre.getRight() == null && pre.getLeft() != node) {
            //让前驱结点的右指针指向当前结点
            pre.setRight(node);
            //修改前驱结点的右指针类型
            pre.setRightType(1);
        }

        //每处理一个结点后，让当前结点是下一个结点的前驱结点
        pre = node;

        //2、线索化左子树
        if (node.getLeftType() == 0) {
            preThreadedNodes2(node.getLeft());
        }

        //3、线索化右子树
        /**
         * 与方法1不同，此处判断右子节点是否为后继节点，故不会陷入死循环
         * 所以可不加条件pre.getLeft() != node(加上最好)
         */
        if (node.getRightType() == 0) {
            preThreadedNodes2(node.getRight());
        }
    }

前序遍历

方法1

  //遍历前序线索化二叉树
    public void preThreadedList() {
        //存储当前遍历的结点，从 root 开始
        HeroNode node = root;

        while(node != null) {
            System.out.println(node + " ");
            //如果存在左子节点就往左走，否则往右走，此时右指针一定是前序遍历的下一个节点
            if(node.getLeftType() == 0) {
                node = node.getLeft();
            }else {
                node = node.getRight();
            }
        }

    }

方法2

 //遍历前序线索化二叉树
    public void preThreadedList2() {
        //存储当前遍历的结点，从 root 开始
        HeroNode node = root;

        while (node != null) {

            // 打印当前节点
            System.out.println(node);

            //如果当前结点的左指针指向的是左子结点,就一直输出
            while (node.getLeftType() == 0) {
                node = node.getLeft();
                System.out.println(node);
            }

            //当前结点的右指针指向的是后继结点
            if (node.getRightType() == 1) {
                //获取到当前结点的后继结点
                node = node.getRight();
            } else if (node.getRight() == null) {
                break;
            }
        }
    }

方法3

     public void preThreadedList3() {
        //存储当前遍历的结点，从 root 开始
        HeroNode node = root;
        while (node != null) {
            //如果当前结点的左指针指向的是左子结点,就一直输出
            while (node.getLeftType() == 0) {
                System.out.println(node);
                node = node.getLeft();
            }
            // 打印当前节点
            System.out.println(node);
            node = node.getRight();
        }
    }

中序线索化

 /**
     * @param node 当前需要线索化的结点
     */
    public void infixThreadedNodes(HeroNode node) {
        if (node == null) {
            return;
        }

        //1、先线索化左子树
        infixThreadedNodes(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、先线索化右子树
        infixThreadedNodes(node.getRight());
    }

中序遍历

 //遍历线索化二叉树
    public void infixThreadedList() {
        //存储当前遍历的结点，从 root 开始
        HeroNode node = root;

        while (node != null) {
            //循环找到 leftType == 1 的结点，第一个找到就是 8 结点
            //当 leftType==1 时，说明该结点是按照线索化，左子节点为线索化后的前驱结点
            while (node.getLeftType() == 0) {
                node = node.getLeft();
            }

            // 找到 leftType == 1 的结点
            System.out.println(node);

            //如果当前结点的右指针指向的是后继结点,就一直输出
            while (node.getRightType() == 1) {
                //获取到当前结点的后继结点
                node = node.getRight();
                System.out.println(node);
            }

            //当前结点的右指针指向的是右子树, 替换这个遍历的结点
            node = node.getRight();
        }

    }

后序线索化

 //对二叉树进行后序线索化
    /**
     * @param node 当前需要线索化的结点
     */
    public void postThreadedNodes(HeroNode node) {
        if (node == null) {
            return;
        }

        //1、先线索化左子树
        postThreadedNodes(node.getLeft());

        //2、线索化右子树
        postThreadedNodes(node.getRight());

        //3、线索化当前结点（重点）
        //处理当前结点的前驱结点
        if (node.getLeft() == null) {
            //让当前结点的左指针指向前驱结点
            node.setLeft(pre);
            //让当前结点的左指针指向前驱结点
            node.setLeftType(1);
        }

        //处理后继结点
        /**
         * 如果pre的left结点为node(当前) 则不能把pre的right结点设为node(当前)
         * 否则下面的“preThreadedNodes(node.getLeft())”会出现死循环
         */
        if (pre != null && pre.getRight() == null) {
            //让前驱结点的右指针指向当前结点
            pre.setRight(node);
            //修改前驱结点的右指针类型
            pre.setRightType(1);
        }

        //每处理一个结点后，让当前结点是下一个结点的前驱结点
        pre = node;
    }

后序遍历

 //遍历后序线索化二叉树
    public void postThreadedList() {
        //存储当前遍历的结点，从 root 开始
        HeroNode node = root;

        // 先从左子树开始，找到第一个开始遍历的线索化左子节点
        while (node != null && node.getLeftType() == 0) {
            node = node.getLeft();
        }

        HeroNode preNode = null;
        while (node != null) {
            if (node.getRightType() == 1) {
                System.out.println(node);
                preNode = node;
                node = node.getRight();
            } else {
                // 判断当前节点的右子节点是否与前一个处理的节点为同一节点
                if (node.getRight() == preNode) {
                    System.out.println(node);
                    if (node == root) {
                        break;
                    }
                    preNode = node;
                    node = root;
                } else {
                    node = node.getRight();
                    // 从根节点的右子树，开始寻找第一个开始遍历的左子节点
                    while (node != null && node.getLeftType() == 0) {
                        node = node.getLeft();
                    }
                }
            }
        }
    }