数据结构之二叉树和平衡二叉树

沐风听雨_A2024-04-04 18:29

1、二叉树：

java 复制代码 
package com.datastructure.tree;
//一个常用的第三方库是Apache Commons Collections，它提供了一个名为BinaryTree的类，用于表示二叉树。
//可以使用org.apache.commons.collections4.BinaryTree类创建二叉树和进行操作。
//可以在Maven中添加以下依赖项：
//<dependency>
//<groupId>org.apache.commons</groupId>
//<artifactId>commons-collections4</artifactId>
//<version>4.4</version>
//</dependency>
public class BinaryTree {
    private Node root;

    private class Node {
        private int data;
        private Node left;
        private Node right;

        public Node(int data) {
            this.data = data;
            this.left = null;
            this.right = null;
        }
    }

    // 插入节点
    public void insert(int data) {
        root = insert(root, data);
    }

    private Node insert(Node node, int data) {
        if (node == null) {
            node = new Node(data);
        } else {
            if (data <= node.data) {
                node.left = insert(node.left, data);
            } else {
                node.right = insert(node.right, data);
            }
        }
        return node;
    }

    // 前序遍历
    public void preOrderTraversal() {
        preOrderTraversal(root);
    }

    private void preOrderTraversal(Node node) {
        if (node != null) {
            System.out.println(node.data);
            preOrderTraversal(node.left);
            preOrderTraversal(node.right);
        }
    }

    // 中序遍历
    public void inOrderTraversal() {
        inOrderTraversal(root);
    }

    private void inOrderTraversal(Node node) {
        if (node != null) {
            inOrderTraversal(node.left);
            System.out.println(node.data);
            inOrderTraversal(node.right);
        }
    }

    // 后序遍历
    public void postOrderTraversal() {
        postOrderTraversal(root);
    }

    private void postOrderTraversal(Node node) {
        if (node != null) {
            postOrderTraversal(node.left);
            postOrderTraversal(node.right);
            System.out.println(node.data);
        }
    }
}
java 复制代码 
package com.datastructure.tree;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();
        tree.insert(5);
        tree.insert(3);
        tree.insert(7);
        tree.insert(2);
        tree.insert(4);
        tree.insert(6);
        tree.insert(8);

        System.out.println("前序遍历:");
        tree.preOrderTraversal();

        System.out.println("中序遍历:");
        tree.inOrderTraversal();

        System.out.println("后序遍历:");
        tree.postOrderTraversal();
    }
}

2、平衡二叉树：

java 复制代码 
package com.datastructure.tree;
//平衡树
//AVLTree是一个泛型类，可以存储任意实现了Comparable接口的类型。
//在AVLTree类中，使用Node类来表示树节点，并在节点中保存了节点值、左子节点、右子节点和节点高度。
//在插入操作中，使用递归的方式在树中查找合适的位置插入新节点，并在返回时重新平衡树。
//在插入节点之后，检查当前节点的平衡因子，如果超出范围，则通过旋转操作来恢复平衡。
//除了插入操作之外，还可以实现其他操作，例如删除节点、查找节点、遍历等。
public class AVLTreeDemo<T extends Comparable<T>> {
    private class Node {
        T value;
        Node left;
        Node right;
        int height;

        Node(T value) {
            this.value = value;
            this.height = 1;
        }
    }

    private Node root;

    private int height(Node node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }

    private int balanceFactor(Node node) {
        if (node == null) {
            return 0;
        }
        return height(node.left) - height(node.right);
    }

    private Node rotateLeft(Node x) {
        Node y = x.right;
        Node T2 = y.left;

        y.left = x;
        x.right = T2;

        x.height = Math.max(height(x.left), height(x.right)) + 1;
        y.height = Math.max(height(y.left), height(y.right)) + 1;

        return y;
    }

    private Node rotateRight(Node y) {
        Node x = y.left;
        Node T2 = x.right;

        x.right = y;
        y.left = T2;

        y.height = Math.max(height(y.left), height(y.right)) + 1;
        x.height = Math.max(height(x.left), height(x.right)) + 1;

        return x;
    }

    public void insert(T value) {
        root = insert(root, value);
    }

    private Node insert(Node node, T value) {
        if (node == null) {
            return new Node(value);
        }

        if (value.compareTo(node.value) < 0) {
            node.left = insert(node.left, value);
        } else if (value.compareTo(node.value) > 0) {
            node.right = insert(node.right, value);
        } else {
            return node; // 不允许插入重复的值
        }

        node.height = Math.max(height(node.left), height(node.right)) + 1;

        int balance = balanceFactor(node);
        if (balance > 1 && value.compareTo(node.left.value) < 0) {
            return rotateRight(node);
        }
        if (balance < -1 && value.compareTo(node.right.value) > 0) {
            return rotateLeft(node);
        }
        if (balance > 1 && value.compareTo(node.left.value) > 0) {
            node.left = rotateLeft(node.left);
            return rotateRight(node);
        }
        if (balance < -1 && value.compareTo(node.right.value) < 0) {
            node.right = rotateRight(node.right);
            return rotateLeft(node);
        }

        return node;
    }

    public void delete(T value) {
        root = delete(root, value);
    }

    private Node delete(Node node, T value) {
        if (node == null) {
            return null;
        }

        if (value.compareTo(node.value) < 0) {
            node.left = delete(node.left, value);
        } else if (value.compareTo(node.value) > 0) {
            node.right = delete(node.right, value);
        } else {
            if (node.left == null || node.right == null) {
                Node temp = null;
                if (node.left != null) {
                    temp = node.left;
                } else {
                    temp = node.right;
                }

                if (temp == null) {
                    temp = node;
                    node = null;
                } else {
                    node = temp;
                }
            } else {
                Node temp = minValueNode(node.right);
                node.value = temp.value;
                node.right = delete(node.right, temp.value);
            }
        }

        if (node == null) {
            return node;
        }

        node.height = Math.max(height(node.left), height(node.right)) + 1;

        int balance = balanceFactor(node);
        if (balance > 1 && balanceFactor(node.left) >= 0) {
            return rotateRight(node);
        }
        if (balance > 1 && balanceFactor(node.left) < 0) {
            node.left = rotateLeft(node.left);
            return rotateRight(node);
        }
        if (balance < -1 && balanceFactor(node.right) <= 0) {
            return rotateLeft(node);
        }
        if (balance < -1 && balanceFactor(node.right) > 0) {
            node.right = rotateRight(node.right);
            return rotateLeft(node);
        }

        return node;
    }

    private Node minValueNode(Node node) {
        Node current = node;
        while (current.left != null) {
            current = current.left;
        }
        return current;
    }

    // 其他操作方法...
    
    // 中序遍历
    public void inorderTraversal() {
        inorderTraversal(root);
    }
    
    private void inorderTraversal(Node node) {
        if (node != null) {
            inorderTraversal(node.left);
            System.out.print(node.value + " ");
            inorderTraversal(node.right);
        }
    }
}
java 复制代码 
package com.datastructure.tree;
//可以在项目中添加Apache Commons Collections库的依赖。
//可以在Maven项目中的pom.xml文件中添加以下代码片段：
//<dependency>
//<groupId>org.apache.commons</groupId>
//<artifactId>commons-collections4</artifactId>
//<version>4.4</version>
//</dependency>
//import org.apache.commons.collections4.map.AVLTree;
public class AVLTreeDemoMain {
    public static void main(String[] args) {
        AVLTreeDemo<Integer> tree = new AVLTreeDemo<>();

        tree.insert(5);
        tree.insert(10);
        tree.insert(3);
        tree.insert(7);
        tree.insert(8);
        tree.insert(1);

        System.out.println("Inorder Traversal:");
        tree.inorderTraversal();

        tree.delete(5);

        System.out.println("nAfter deleting 5:");
        tree.inorderTraversal();
    }
}
相关推荐
yuanManGan1 小时前
数据结构漫游记：静态链表的实现(CPP)
数据结构·链表
2401_858286114 小时前
115.【C语言】数据结构之排序(希尔排序)
c语言·开发语言·数据结构·算法·排序算法
猫猫的小茶馆4 小时前
【数据结构】数据结构整体大纲
linux·数据结构·算法·ubuntu·嵌入式软件
2401_858286116 小时前
109.【C语言】数据结构之求二叉树的高度
c语言·开发语言·数据结构·算法
huapiaoy6 小时前
数据结构---Map&Set
数据结构
南宫生6 小时前
力扣-数据结构-1【算法学习day.72】
java·数据结构·学习·算法·leetcode
yuanbenshidiaos6 小时前
数据结构---------二叉树前序遍历中序遍历后序遍历
数据结构
^南波万^6 小时前
数据结构--排序
数据结构
yuanbenshidiaos7 小时前
数据结构----链表头插中插尾插
网络·数据结构·链表
逊嘘7 小时前
【Java数据结构】LinkedList
java·开发语言·数据结构
热门推荐
01【一文读懂】NTN（非地面网络）技术介绍02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明0719个Web前端交互式3D JavaScript框架和库08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO