Java数据结构--平衡二叉树

最新推荐文章于 2022-11-22 00:15:00 发布
最新推荐文章于 2022-11-22 00:15:00 发布
阅读量205 收藏
点赞数
分类专栏： java 文章标签： java 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pf_1308108803/article/details/78926576
版权

DEMO地址：
https://github.com/zhaopingfu/MDataStruct/blob/master/src/com/pf/%E6%A0%91/AVLBintrayTree.java

在这里有一些资源，辅助看的:
https://github.com/zhaopingfu/MDataStruct/tree/master/resources/%E6%A0%91/AVL%E6%A0%91

  • 平衡二叉树是一种二叉排序树，其中每一个节点的左子树和右子树的高度差至多等于1.

  • 平衡因子：二叉树上节点的左子树深度减去右子树的深度的值成为平衡因子BF（Balance Factor）。

  • 最小不平衡子树：距离插入节点最近的，且平衡因子的绝对值大于1的节点为根的子树为最小不平衡树。

这里写图片描述

  • 构建AVL树

    这里写图片描述

    /**
 * @author zhaopf
 * @version 1.0
 * @QQ: 1308108803
 * @date 2017年12月25日
 * 平衡二叉树
 */
public class AVLBintrayTree<E extends Comparable<E>> {
    /**
     * 根节点
     */
    private Node<E> root;
    /**
     * 树的节点
     */
    private int size;
    /**
     * 左边高，左边减去右边
     */
    private static final int LEFT_HEIGHT = 1;
    /**
     * 两边一样高，左边减去右边
     */
    private static final int EQUALS_HEIGHT = 0;
    /**
     * 右边高，左边减去右边
     */
    private static final int RIGHT_HEIGHT = -1;

    /**
     * 添加一个元素
     *
     * @param element
     * @return
     */
    public boolean put(E element) {
        if (element == null) {
            return false;
        }
        Node<E> t = root;
        if (t == null) {
            root = new Node<>(element, null);
            size++;
            return true;
        }
        // 开始添加元素
        Node<E> parent = null;
        Comparable<? super E> e = element;
        int compare;
        // 查找父节点
        do {
            parent = t;
            compare = e.compareTo(t.element);
            if (compare > 0) {
                t = t.right;
            } else if (compare < 0) {
                t = t.left;
            } else {
                return false;
            }
        } while (t != null);
        // 添加到父节点上
        Node<E> newNode = new Node<>(element, parent);
        compare = newNode.element.compareTo(parent.element);
        if (compare > 0) {
            parent.right = newNode;
        } else if (compare < 0) {
            parent.left = newNode;
        }
        // 检查平衡问题
        while (parent != null) {
            compare = newNode.element.compareTo(parent.element);
            // 如果节点是添加到右子树
            if (compare > 0) {
                parent.balance--;
            } else {
                parent.balance++;
            }
            // 还是平衡的
            if (parent.balance == 0) {
                break;
            }
            // 如果出现了平衡问题
            if (Math.abs(parent.balance) == 2) {
                fixAfterInsertion(parent);
                break;
            } else {
                // 回溯到父节点
                parent = parent.parent;
            }
        }
        size++;
        return true;
    }

    private void fixAfterInsertion(Node<E> parent) {
        if (parent.balance == 2) {
            leftBalance(parent);
        } else if (parent.balance == -2) {
            rightBalance(parent);
        }
    }

    /**
     * 中序遍历节点
     *
     * @return
     */
    public List<Node<E>> midSelectTree() {
        List<Node<E>> result = new ArrayList<>(size);
        Node<E> temp = root;
        if (temp == null) {
            return result;
        }
        Stack<Node<E>> stack = new Stack<>();
        // 添加根节点
        stack.add(temp);
        Set<Node<E>> set = new HashSet<>(size);
        while (!stack.isEmpty()) {
            Node<E> t = stack.pop();
            if (t.getLeft() != null && !set.contains(t.getLeft())) {
                if (t.getRight() != null) {
                    stack.push(t.getRight());
                }
                stack.push(t);
                stack.push(t.getLeft());
            } else {
                set.add(t);
                result.add(t);
                if (t.getRight() != null && !stack.contains(t.getRight())) {
                    stack.push(t.getRight());
                }
            }
        }
        return result;
    }

    /**
     * 左平衡操作，节点t的不平衡是因为左子树过深
     *
     * @param t
     */
    private void leftBalance(Node<E> t) {
        if (t == null || t.left == null) {
            return;
        }
        Node<E> tLeftChild = t.left;
        switch (tLeftChild.balance) {
            // 如果新的结点插入到t的左孩子的左子树中，则直接进行右旋操作即可
            case LEFT_HEIGHT:
                t.balance = EQUALS_HEIGHT;
                tLeftChild.balance = EQUALS_HEIGHT;
                // 右旋
                rightRotate(t);
                break;
            case EQUALS_HEIGHT:
                break;
            // 如果新的结点插入到t的左孩子的右子树中，则需要进行分情况讨论
            case RIGHT_HEIGHT:
                Node<E> tLeftChildRightChild = tLeftChild.right;
                switch (tLeftChildRightChild.balance) {
                    // 当t的左孩子的右子树根节点的balance = LEFT_HIGH
                    case LEFT_HEIGHT:
                        t.balance = RIGHT_HEIGHT;
                        tLeftChild.balance = EQUALS_HEIGHT;
                        tLeftChildRightChild.balance = EQUALS_HEIGHT;
                        break;
                    // 当t的左孩子的右子树根节点的balance = EQUAL_HIGH
                    case EQUALS_HEIGHT:
                        t.balance = EQUALS_HEIGHT;
                        tLeftChild.balance = EQUALS_HEIGHT;
                        tLeftChildRightChild.balance = EQUALS_HEIGHT;
                        break;
                    // 当t的左孩子的右子树根节点的balance = RIGHT_HIGH
                    case RIGHT_HEIGHT:
                        t.balance = EQUALS_HEIGHT;
                        tLeftChild.balance = LEFT_HEIGHT;
                        tLeftChildRightChild.balance = EQUALS_HEIGHT;
                        break;
                    default:
                        break;
                }
                // 先将t的左子树左旋
                leftRotate(tLeftChild);
                // 在将t右旋
                rightRotate(t);
                break;
            default:
                break;
        }
    }

    /**
     * 右平衡操作，即结点t的不平衡是因为右子树过深
     *
     * @param t
     */
    private void rightBalance(Node<E> t) {
        if (t == null || t.right == null) {
            return;
        }
        Node<E> tRightChild = t.right;
        switch (tRightChild.balance) {
            // 如果新的结点插入到p的右孩子的左子树中，则需要进行分情况讨论
            case LEFT_HEIGHT:
                Node<E> tRightChildLeftChild = tRightChild.left;
                switch (tRightChildLeftChild.balance) {
                    case LEFT_HEIGHT:
                        t.balance = EQUALS_HEIGHT;
                        tRightChild.balance = RIGHT_HEIGHT;
                        tRightChildLeftChild.balance = EQUALS_HEIGHT;
                        break;
                    case EQUALS_HEIGHT:
                        t.balance = EQUALS_HEIGHT;
                        tRightChild.balance = EQUALS_HEIGHT;
                        tRightChildLeftChild.balance = EQUALS_HEIGHT;
                        break;
                    case RIGHT_HEIGHT:
                        t.balance = LEFT_HEIGHT;
                        tRightChild.balance = EQUALS_HEIGHT;
                        tRightChildLeftChild.balance = EQUALS_HEIGHT;
                        break;
                    default:
                        break;
                }
                // 先对t的右孩子进行右旋
                rightRotate(tRightChild);
                // 再对t进行左旋
                leftRotate(t);
                break;
            case EQUALS_HEIGHT:
                break;
            // 如果新的结点插入到t的右孩子的右子树中，则直接进行左旋操作即可
            case RIGHT_HEIGHT:
                t.balance = EQUALS_HEIGHT;
                tRightChild.balance = EQUALS_HEIGHT;
                leftRotate(t);
                break;
            default:
                break;
        }
    }

    /**
     * 左旋
     *
     * @param x 要旋转的节点
     */
    private void leftRotate(Node<E> x) {
        if (x == null || x.right == null) {
            return;
        }
        Node<E> y = x.right;

        // step 1
        x.right = y.left;
        if (y.left != null) {
            y.left.parent = x;
        }

        // step 2
        if (x.parent == null) {
            root = y;
        } else if (x.parent.left == x) {
            x.parent.left = y;
        } else if (x.parent.right == x) {
            x.parent.right = y;
        }
        y.parent = x.parent;

        // step 3
        y.left = x;
        x.parent = y;
    }

    /**
     * 右旋
     *
     * @param y 要旋转的节点
     */
    private void rightRotate(Node<E> y) {
        if (y == null || y.left == null) {
            return;
        }
        Node<E> x = y.left;

        // step 1
        y.left = x.right;
        if (x.right != null) {
            x.right.parent = y;
        }

        // step 2
        if (y.parent == null) {
            root = x;
        } else if (y.parent.left == y) {
            y.parent.left = x;
        } else if (y.parent.right == y) {
            y.parent.right = x;
        }
        x.parent = y.parent;

        // step 3
        x.right = y;
        y.parent = x;
    }

    public int getSize() {
        return size;
    }

    public Node<E> getRoot() {
        return root;
    }

    /**
     * 节点
     *
     * @param <E> 实现了Comparable接口
     */
    public class Node<E extends Comparable<E>> {
        /**
         * 数据
         */
        private E element;
        /**
         * 平衡因子
         */
        private int balance;
        /**
         * 左子树
         */
        private Node<E> left;
        /**
         * 右子树
         */
        private Node<E> right;
        /**
         * 父节点
         */
        private Node<E> parent;

        public Node(E element, Node<E> parent) {
            this.element = element;
            this.parent = parent;
        }

        public E getElement() {
            return element;
        }

        public void setElement(E element) {
            this.element = element;
        }

        public int getBalance() {
            return balance;
        }

        public void setBalance(int balance) {
            this.balance = balance;
        }

        public Node<E> getLeft() {
            return left;
        }

        public void setLeft(Node<E> left) {
            this.left = left;
        }

        public Node<E> getRight() {
            return right;
        }

        public void setRight(Node<E> right) {
            this.right = right;
        }

        public Node<E> getParent() {
            return parent;
        }

        public void setParent(Node<E> parent) {
            this.parent = parent;
        }
    }
}
只是丶很孤单
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构（6）树形结构——平衡二叉树（JAVA代码实现）
Joker_ZJN的博客
11-28 1491
平衡二叉树的概念，平很二叉树的LL、RR、RL、LR旋转，以及JAVA版本的AVL树的实现。
二叉树（Java实现）
JiaXingNashishua的博客
05-22 1万+
声明：本文部分文章取自于 Java中关于二叉树详解_来学习的小张的博客-CSDN博客_java 二叉树原理 更多关于二叉树详情可以点击上面链接 一：树形结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点； 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个
Java数据结构——认识二叉树
chenchenchencl的博客
09-29 1187
一文认识二叉树及其性质
Java数据结构之二叉树
fear_wolf的博客
10-25 2319
二叉树的创建很简单，但是难就难在操作上，我们为了简便，先自己手动创建一个简陋的二叉树的结构，着重介绍二叉树的操作，先创建一棵二叉树。我们有前面的概念可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照递归实现的。完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是从满二叉树中引出来的，对于。的数据结构，它是由n（n >= 0）个有限节点组成的一个具有层次关系的集合，遍历是二叉树上最重要的操作之一，是二叉树进行其他运算的基础。称之为完全二叉树，由此可知，满二叉树是一种特殊的完全二叉树。
java数据结构之--树（二叉树）
wcguang博客
11-22 474
树，二叉树
数据结构-二叉树 JAVA语言实现
10-16
在IT领域，数据结构是计算机科学的基础，而二叉树作为一种重要的数据结构，被广泛应用于算法设计、数据库系统、编译器等领域。本教程将详细阐述如何使用JAVA语言实现二叉树的相关操作。 首先，我们要了解二叉树的...
广工数据结构课程设计大作业-平衡二叉树-Java实现（数据结构期末）
最新发布
11-13
在本项目中，我们主要探讨的是数据结构领域中的一个重要概念——平衡二叉树，并通过Java编程语言进行实现。平衡二叉树是一种特殊的二叉搜索树，它的左右子树的高度差不超过1，从而保证了树的平衡性，进一步提高了...
Java-Java数据结构二十讲
10-25
本文将深入探讨Java数据结构的二十个核心主题，包括数组、简单排序算法、栈与队列、链表、递归、树以及图。这些概念不仅在日常编程中常见，也是面试和技术评估的重要内容。 首先，我们从基础的数组开始。数组是存储...
常用数据结构 -- 二叉树
08-13
在实际开发中，结合源码和工具，如Java或C++中的数据结构库，我们可以轻松地创建和操作二叉树。对于深入学习，可以参考给定的文档“常用数据结构--线性结构&二叉树.docx”，它可能包含了更多关于线性结构和二叉树的...
java 数据结构二叉树的实现代码
09-01
在Java中，数据结构中的二叉树是一种重要的抽象数据类型，它由节点组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。在本文中，我们将深入探讨如何使用Java实现二叉树，并通过接口、节点类和具体实现来...
数据结构二叉树专题java代码实现
04-02
数据结构二叉树专题java代码实现
Java数据结构 | 二叉树的基本操作
m0_56361048的博客
10-13 1745
Java数据结构 | 二叉树的基本操作详解
java数据结构与算法之平衡二叉树(AVL树)的设计与实现
zejian的博客
12-31 3万+
【版权申明】未经博主同意，不允许转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/53892797 出自【zejian的博客】 关联文章:java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和L
【Java数据结构】平衡二叉树
萌宅鹿的技术小屋
09-22 417
平衡二叉树二叉排序树的不足平衡二叉树构建二叉排序树平衡因子返回当前节点的高度判断左旋转还是右旋转左左(右旋转)右旋转图解右旋转代码实现左旋转示例完整代码平衡二叉树类 BalancedBinaryTree平衡二叉树节点类 Node测试案例右右(左旋转)左旋转图解左旋转代码实现双旋转 二叉排序树的不足 关于之前就介绍过的二叉排序树，我们设下一下以下的情景： 如果有一组数字：｛1，2，3，4，5，6，7...
关联挖掘算法Apriori和FP-Tree学习
热门推荐
么刚的专栏
06-02 4万+
关联挖掘算法 Apriori算法和FPTree算法原理，伪码和举例说明
Java数据结构----树--平衡二叉树
ChangWen的博客
02-28 1816
1、基础知识 平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质： 1.它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 2.其高度一般都良好地维持在O（log2n），大大降低了操作的时间复杂度。 3.平衡二叉树的常用算法有红黑树、AVL、Treap等。 4.最小二叉平衡树的节点的公式
数据结构，java实现平衡二叉树，AVL树
Numblgw的博客
04-26 223
之前看HashMap源码的时候遇到一些问题，jdk1.8中对HashMap做了一些优化，其中就包括当链表节点大于8个时会将链表转换成红黑树以提高查找效率。我对红黑树了解的比较少，而且之前学的二叉树相关的知识也忘了许多，所以决定近期去复习一下。 红黑树是一种平衡二叉树，平衡二叉树又属于二叉搜索树（二叉排序树）。这几天我就从二叉搜索树开始，把这几种数据结构都用java实现了一遍，二叉排序树比较简单没...
JAVA数据结构与算法之————平衡二叉树
qq_36007633的博客
04-23 476
JAVA数据结构与算法之————平衡二叉树 平衡二叉树 又称AVL树，平衡二叉树具有的特性是：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 本文将从以下几个方面进行介绍： TreeNode结构介绍。 向平衡二叉树中插入元素，然后调整二叉树使其仍然为平衡二叉树。 创建平衡二叉树。 删除平衡二叉树中的节点。 介绍TreeNode结构： 由于我在博客...
数据结构（Java实现）-图解平衡二叉树（AVL树）
jQueryZK的博客
09-17 1961
1、问题引入 给定一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在 分析已经构建的BST树存在的问题： 左子树全部为空，从形式上看，更像一个单链表. 插入速度没有影响 查询速度明显降低(因为需要依次比较), 不能发挥BST树的优势，因为每次还需要比较左子树，其查询速度比单链表还慢 解决方案-平衡二叉树(AVL) 2、平衡二叉树介绍 平衡二叉树：也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树， 可以保证查询效
Java数据结构面试焦点：红黑树与平衡二叉树解析
本文档是关于Java数据结构与算法面试题的最新版，重点讨论了红黑树这一重要数据结构，以及与其相关的AVL树和二叉搜索树。 在计算机科学中，数据结构和算法是编程的基础，尤其在Java开发中，理解并熟练运用各种数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值