2025-01-23 平衡二叉树

src/dataANDcalc/java/tree/AvlTree.java

@@ -0,0 +1,190 @@
+package tree;
+
+public class AvlTree {
+
+    private TreeNode root;
+
+    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);
+            }
+        }
+    }
+
+    private void avl(TreeNode treeNode){
+        TreeNode avlNode = searchAvlNode(root);
+        if(avlNode == null){
+            System.out.println("无需转换");
+            return;
+        }
+        // 左旋转
+        if(height(avlNode.right) - height(avlNode.left) > 1){
+            if (avlNode.right != null && height(avlNode.right.left) > height(avlNode.right.right)){
+                //如果他的右子树的左子树高度大于右子树高度，先对当前这个节点的右节点进行右旋转，再对当前节点进行左旋转的操作
+                rightSpin(avlNode.right);
+                leftSpin(avlNode);
+            } else {
+                leftSpin(avlNode);
+            }
+            return;
+        }
+        //右旋转
+        if(height(avlNode.left) - height(avlNode.right) > 1){
+            if (avlNode.left != null && height(avlNode.left.right) > height(avlNode.left.left)){
+                //如果他的左子树的右子树高度大于左子树高度，先对当前这个节点的左节点进行左旋转，再对当前节点进行右旋转的操作
+                leftSpin(avlNode.left);
+                rightSpin(avlNode);
+            } else {
+                rightSpin(avlNode);
+            }
+        }
+    }
+
+    private void leftSpin(TreeNode avlNode){
+        TreeNode newNode = new TreeNode(avlNode.node);
+        newNode.left = avlNode.left;
+        newNode.right = avlNode.right.left;
+        avlNode.node = avlNode.right.node;
+        avlNode.right = avlNode.right.right;
+        avlNode.left = newNode;
+    }
+
+    private void rightSpin(TreeNode avlNode){
+        TreeNode newNode = new TreeNode(avlNode.node);
+        newNode.right = avlNode.right;
+        newNode.left = avlNode.left.right;
+        avlNode.node = avlNode.left.node;
+        avlNode.left = avlNode.left.left;
+        avlNode.right = newNode;
+    }
+
+    private TreeNode searchAvlNode(TreeNode treeNode){
+        if(treeNode == null){
+            return null;
+        }
+        Integer leftHeight = height(treeNode.left);
+        Integer rightHeight = height(treeNode.right);
+        if (Math.abs(leftHeight - rightHeight)>1){
+            return treeNode;
+        }
+
+        TreeNode leftNode = searchAvlNode(treeNode.left);
+        if(leftNode != null){
+            return leftNode;
+        }
+
+        TreeNode rightNode = searchAvlNode(treeNode.right);
+        if(rightNode != null){
+            return rightNode;
+        }
+        return null;
+    }
+
+    private int height(TreeNode treeNode){
+        if (treeNode == null){
+            return 0;
+        }
+        int leftHeight = 0;
+        int rightHeight = 0;
+        if (treeNode.left == null){
+            leftHeight = 0;
+        } else {
+            leftHeight = height(treeNode.left);
+        }
+        if (treeNode.right == null){
+            rightHeight = 0;
+        } else {
+            rightHeight = height(treeNode.right);
+        }
+        int height = Math.max(leftHeight, rightHeight) + 1;
+        return height;
+    }
+
+    private void forwardIterator(TreeNode treeNode){
+        if(treeNode == null){
+            System.out.println("当前节点为空");
+            return;
+        }
+
+        System.out.println(treeNode.toString());
+
+        if (treeNode.left != null){
+            forwardIterator(treeNode.left);
+        }
+
+        if (treeNode.right!= null){
+            forwardIterator(treeNode.right);
+        }
+    }
+
+    public static class TreeNode{
+        private int node;
+
+        private TreeNode left;
+
+        private TreeNode right;
+
+        public TreeNode(int node) {
+            this.node = node;
+        }
+
+        @Override
+        public String toString() {
+            return "TreeNode{" +
+                    "node=" + node +
+                    ", left=" + (left == null ? "null" : left.node) +
+                    ", right=" + (right == null ? "null" : right.node) +
+                    '}';
+        }
+    }
+
+    public static void main(String[] args) {
+//        int[] arr = {4,3,6,5,7,8};
+//        int[] arr = {10,12,8,9,7,6};
+//        int[] arr = {10,11,7,6,8,9};
+        int[] arr = {2,1,6,5,7,3};
+        AvlTree avlTree = new AvlTree();
+        avlTree.transTree(arr);
+        /**
+             4
+        3           6
+                5       7
+                              8
+        **/
+        /**
+                    10
+                7        11
+             6    8
+                     9
+         **/
+        System.out.println("左子树高度:"+avlTree.height(avlTree.root.left));
+        System.out.println("右子树高度:"+avlTree.height(avlTree.root.right));
+        System.out.println(avlTree.searchAvlNode(avlTree.root));
+        avlTree.avl(avlTree.root);
+        System.out.println("前序遍历:");
+        avlTree.forwardIterator(avlTree.root);
+    }
+}