AVL树
- 给你一个数列{1,2,3,4,5,6},要求创建一颗二叉排序树(BST), 并分析问题所在
上面BST(二叉排序树) 存在的问题分析:
- 左子树全部为空,从形式上看,更像一个单链表.
- 插入速度没有影响
- 查询速度明显降低(因为需要依次比较), 不能发挥BST的优势,因为每次还需要比较左子树,其查询速度比单链表还慢
- 解决方案-平衡二叉树(AVL)
平衡二叉树:(平衡二叉树的前提是二叉排序树)
平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树, 可以保证查询效率较高。
具有以下特点:
- 它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1,
- 并且左右两个子树都是一棵平衡二叉树。
- 平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。
递归求解二叉树的高度:
/** * 当前节点的树的高度 * @return */ public int height() { //左子树的高度和右子树的高度的最大值 return Math.max(leftNode == null?0:leftNode.height(),rightNode==null?0:rightNode.height())+1; } /** * 右子树的高度 * @return */ public int leftHeight() { if (leftNode == null) { return 0; } else { return leftNode.height(); } } /** * 右子树的高度 * @return */ public int rightHeight() { if (rightNode == null) { return 0; } else { return rightNode.height(); } }
AVL树的旋转:
/** * 左旋转BST */ private void leftRotate() { //创建一个新的节点 newNode (以4这个值创建) //,创建一个新的节点,值等于当前根节点的值 Node newLeft = new Node(value); //把新节点的左子树设置了当前节点的左子树 newLeft.leftNode=leftNode; //把新节点的右子树设置为当前节点的右子树的左子树 newLeft.rightNode=rightNode.leftNode; //把当前节点的值换为右子节点的值 value=rightNode.value; //把当前节点的右子树设置成右子树的右子树 rightNode=rightNode.rightNode; //把当前节点的左子树设置为新节点 leftNode=newLeft; } /** * 右旋转 */ public void rightRotate() { Node newNode = new Node(value); newNode.rightNode = rightNode; newNode.leftNode = leftNode.rightNode; value = leftNode.value; leftNode = leftNode.leftNode; rightNode = newNode; }
由于二叉排序树有可能出现类似的情况:所以需要双旋转
双旋转:
解决思路分析
- 问题分析出来: 在满足右旋转条件时,要判断
- 如果 是 左子树的 右子树高度 大于左子树的左子树时:
- 就是 对 当前根节点的左子树,先进行 左旋转,
- 然后, 在对当前根节点进行右旋转即可
- 否则,直接对当前节点(根节点)进行右旋转.即可.
package binaryTree.AVL; /** * @Author: 白雄雄 * @Date: 2019/9/14 16:29 */ public class AvlTreeDemo { public static void main(String[] args) { int[] arrays = {4,3,6,5,7,8}; AvlTree avlTree = new AvlTree(); for (int i = 0; i < arrays.length; i++) { avlTree.addNode(new Node(arrays[i])); } avlTree.infixOrder(); int height = avlTree.getRoot().height(); System.out.println(height); int leftHeight = avlTree.getRoot().leftHeight(); int rightHeight = avlTree.getRoot().rightHeight(); System.out.println(leftHeight+" "+rightHeight); } } /** * 二叉排序树 */ class AvlTree{ private Node root; public Node getRoot() { return root; } //添加节点 public void addNode(Node node) { if (root == null) { this.root = node; } else { root.addNode(node); } } //中序遍历 public void infixOrder() { if (root != null) { root.infixOrder(); } else { System.out.println("二叉树为空"); } } //查找节点 public Node search(Node node) { if (root == null) { return null; } else { return this.root.search(node); } } //查找父节点 public Node searchParent(Node node) { if (root == null) { return null; } else { return this.root.searchParent2(node); } } public void deleteNode(Node node) { if (this.root == null) { return; } Node targetNode = search(node); //没找到 if (targetNode == null) { return; } //如果当前二叉树只有一个节点 if (root.getLeftNode() == null && root.getRightNode() == null) { this.root = null; } //找到父节点 Node parentNode = searchParent(node); //删除叶子节点 if (targetNode.getRightNode() == null && targetNode.getLeftNode() == null) { //左叶子节点 if (parentNode.getLeftNode() != null && parentNode.getLeftNode().getValue() == node.getValue()) { parentNode.setLeftNode(null); } else if (parentNode.getRightNode() != null && parentNode.getRightNode().getValue() == node.getValue()) {//右叶子节点 parentNode.setRightNode(null); } } else if (targetNode.getRightNode() != null && targetNode.getLeftNode() != null) {//删除有两颗子树的节点 Node minNode = delTargetRightTreeMin(targetNode); targetNode.setValue(minNode.getValue());//最小节点替换要删除的节点 } else {//删除有一颗子树的节点 if (targetNode.getLeftNode() != null) { if (parentNode == null) {//判断删除节点是否是父节点 this.root = targetNode.getLeftNode(); } else{ if (parentNode.getLeftNode() == node) { parentNode.setLeftNode(targetNode.getLeftNode()); } else { parentNode.setRightNode(targetNode.getLeftNode()); } } } else { if (parentNode != null) { if (parentNode.getLeftNode() == node) { parentNode.setLeftNode(targetNode.getRightNode()); } else { parentNode.setRightNode(targetNode.getRightNode()); } } else { this.root = targetNode.getRightNode(); } } } } /** * 删除以要删除节点为根节点二叉树的左子树的最小节点 * @param node * @return 返回改最小节点 */ public Node delTargetRightTreeMin(Node node) { Node target = node; while (target.getLeftNode() != null) {//找到最小节点 target = target.getRightNode(); } deleteNode(target); return target; } } //创建node节点 class Node { private int value; private Node leftNode; private Node rightNode; public Node(int value) { this.value = value; } public int getValue() { return value; } public Node getLeftNode() { return leftNode; } public Node getRightNode() { return rightNode; } public void setValue(int value) { this.value = value; } public void setLeftNode(Node leftNode) { this.leftNode = leftNode; } public void setRightNode(Node rightNode) { this.rightNode = rightNode; } /** * 当前节点的树的高度 * @return */ public int height() { //左子树的高度和右子树的高度的最大值 return Math.max(leftNode == null?0:leftNode.height(),rightNode==null?0:rightNode.height())+1; } /** * 右子树的高度 * @return */ public int leftHeight() { if (leftNode == null) { return 0; } else { return leftNode.height(); } } /** * 右子树的高度 * @return */ public int rightHeight() { if (rightNode == null) { return 0; } else { return rightNode.height(); } } /** * 左旋转BST */ private void leftRotate() { //创建一个新的节点 newNode (以4这个值创建) //,创建一个新的节点,值等于当前根节点的值 Node newLeft = new Node(value); //把新节点的左子树设置了当前节点的左子树 newLeft.leftNode=leftNode; //把新节点的右子树设置为当前节点的右子树的左子树 newLeft.rightNode=rightNode.leftNode; //把当前节点的值换为右子节点的值 value=rightNode.value; //把当前节点的右子树设置成右子树的右子树 rightNode=rightNode.rightNode; //把当前节点的左子树设置为新节点 leftNode=newLeft; } /** * 右旋转 */ public void rightRotate() { Node newNode = new Node(value); newNode.rightNode = rightNode; newNode.leftNode = leftNode.rightNode; value = leftNode.value; leftNode = leftNode.leftNode; rightNode = newNode; } /** * 递归的形式添加节点,要满足二叉排序树的要求 * @param node */ public void addNode(Node node) { if (node == null) { return; } //节点的值大于当前节点的值 if (node.getValue() > this.value) { //当前节点的右子树为空直接挂上 if (this.rightNode == null) { this.rightNode = node; } else { //否则递归 this.rightNode.addNode(node); } } else {//把大于等于当前节点的挂到左子树 if (this.leftNode == null) { this.leftNode = node; } else { this.leftNode.addNode(node); } } //添加节点的时候判断是否需要左旋转 if (rightHeight()-leftHeight()>1) { //如果在左旋转的时候,当前节点的右子树的右子树的高度大于右子树的左子树的高度 if (rightNode != null && rightNode.leftHeight() > rightNode.rightHeight()) { //先对当前节点的右子树进行左旋转 rightNode.rightRotate(); //然后对当前节点进行右旋转 leftRotate(); } else { //否则只对当前节点进行右旋转 leftRotate(); } return; } if (leftHeight() - rightHeight() > 1) { if (leftNode != null && leftNode.rightHeight() > leftNode.leftHeight()) { leftNode.leftRotate(); rightRotate(); } else { rightRotate(); } } } /** * 中序遍历二叉树 */ public void infixOrder() { if (this.getLeftNode() != null) { this.getLeftNode().infixOrder(); } //输出当前节点 System.out.println(this.getValue()); if (this.getRightNode() != null) { this.getRightNode().infixOrder(); } } /** * 查找要删除的节点 * @param node 要查找的节点 * @return 如果找到返回该节点 */ public Node search(Node node) { if (node == null) { return null; } if (node.getValue() == this.value) { return this; } else if (node.getValue() < this.value) {//当前节点大于查找的节点,向左子树递归查找 if (this.getLeftNode() == null) { return null; } return this.leftNode.search(node); } else { if (this.rightNode == null) { return null; } return this.rightNode.search(node); } } /** * 查找删除节点的父节 * @param node * @return 返回当前节点的父节点 */ public Node searchParent(Node node) { Node parent = null; if (node == null) { return null; } if (this.value == node.value) { return parent; } parent = this; if (this.value > node.value) { if (this.leftNode == null) { return null; } return this.leftNode.searchParent(node); } else { if (this.rightNode == null) { return null; } return this.rightNode.searchParent(node); } } public Node searchParent2(Node node) { if ((this.getLeftNode() != null && this.getLeftNode().getValue() == node.getValue() || this.getRightNode() != null && this.getRightNode().getValue() == node.getValue())) { return this; } else { if (this.getLeftNode() != null && node.getValue() <= this.getValue()) { return this.getLeftNode().searchParent2(node); } else if (this.getRightNode() != null && node.getValue() > this.getValue()) { return this.getRightNode().searchParent2(node); } else { return null;//没有找到父节点 } } } }
avl树的增删改查和BST树是一样的,只不过在BST的操作上加上旋转操作。