2025-01-21 线索化二叉树

src/dataANDcalc/java/tree/ThreadedBinaryTree.java

@@ -0,0 +1,147 @@
+package tree;
+
+public class ThreadedBinaryTree {
+
+    private TreeNode root;
+
+    private TreeNode prev;
+
+    private void transTree(int[] arr){
+        for (int i = 0; i < arr.length; i++) {
+            TreeNode treeNode = new TreeNode(arr[i]);
+            addNode(root, treeNode);
+        }
+    }
+
+    private void addNode(TreeNode tempNode, TreeNode treeNode){
+        if(root == null){
+            root = treeNode;
+            return;
+        }
+
+        if(treeNode.node<tempNode.node){
+            if (tempNode.left == null){
+                tempNode.left = treeNode;
+            } else {
+                addNode(tempNode.left, treeNode);
+            }
+        }
+
+        if(treeNode.node>tempNode.node){
+            if (tempNode.right == null){
+                tempNode.right = treeNode;
+            } else {
+                addNode(tempNode.right, treeNode);
+            }
+        }
+    }
+
+    //left指向的是左子树，也可能是指向的前驱节点；right指向的是右子树，也有可能是指向后继节点
+    public void middleThreadNode(TreeNode treeNode){
+        if (treeNode == null){
+            return;
+        }
+
+        //先线索化左子树
+        middleThreadNode(treeNode.left);
+
+        //处理当前节点的前驱节点
+        if (treeNode.left == null){
+            // 如果当前节点的左指针为空，则左指针类型就为前驱节点，并且指向前驱节点
+            treeNode.left = prev;
+            treeNode.leftType = 1;
+        } else {
+            treeNode.leftType = 0;
+        }
+        //处理当前节点的后继节点
+        if (prev != null){
+            if (prev.right == null){
+                // 如果前驱节点的右指针为空，则前驱节点的右指针类型就为后继节点，并且指向当前节点
+                prev.right = treeNode;
+                prev.rightType = 1;
+            } else {
+                prev.rightType = 0;
+            }
+        }
+
+        prev = treeNode;
+
+        //线索化右子树
+        middleThreadNode(treeNode.right);
+    }
+
+    private void middleIterator(TreeNode treeNode){
+        if(treeNode == null){
+            System.out.println("当前节点为空");
+            return;
+        }
+        TreeNode temp = root;
+
+        while(true){
+            if(temp == null){
+                break;
+            }
+            // 一直向左搜索到有线索指针为止
+            if(temp.leftType == 0){
+                temp = temp.left;
+            }
+
+            while(true){
+                // 找到线索指针之后，一直根据后继指针输出，直到节点右指针不为线索指针为止
+                if(temp.rightType == 1){
+                    System.out.println(temp);
+                    temp = temp.right;
+                }
+                break;
+            }
+            System.out.println(temp);
+
+            // 如果节点的右指针不为线索指针，则向右节点检索
+            if(temp.rightType == 0){
+                temp = temp.right;
+            }
+        }
+    }
+
+    public static class TreeNode{
+
+        private int node;
+
+        private TreeNode left;
+
+        private TreeNode right;
+
+        private int leftType; // 0表示指向左子树，1表示指向前驱节点
+
+        private int rightType; // 0表示指向右子树，1表示指向后继节点
+
+        public TreeNode(int node) {
+            this.node = node;
+        }
+
+        @Override
+        public String toString() {
+            return "TreeNode{" +
+                    "node=" + node +
+                    ", leftType=" + leftType +
+                    ", rightType=" + rightType +
+                    ", left=" + (left == null ? "null" : left.node) +
+                    ", right=" + (right == null ? "null" : right.node) +
+                    '}';
+        }
+
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {7, 3, 10, 12, 5, 1, 9};
+        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
+        threadedBinaryTree.transTree(arr);
+        /**
+         7
+         3      10
+         1   5  9    12
+         **/
+        threadedBinaryTree.middleThreadNode(threadedBinaryTree.root);
+        threadedBinaryTree.middleIterator(threadedBinaryTree.root);
+    }
+}