平衡二叉树-Java

AVL是最先发明的自平衡二叉查找树算法。在AVL中任何节点的两个儿子子树的高度最大差别为一，所以它也被称为高度平衡树，n个结点的AVL树最大深度约1.44log2n。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

package com.gloomy.Tree;

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Stack;

/**
* 平衡二叉树
*
* @author 过路的守望
*
*/
public class AVLTree {

/*
* 平衡二叉树的更
*/
private Node root;

public AVLTree(Node root) {
this.root = root;
}

public static void main(String[] args) {
Node A = new Node(1);
Node B = new Node(2);
Node C = new Node(3);
Node D = new Node(4);
Node E = new Node(5);
Node F = new Node(6);
Node G = new Node(7);
Node H = new Node(8);
Node I = new Node(9);
Node J = new Node(10);
Node K = new Node(11);
Node L = new Node(12);
Node M = new Node(13);
Node N = new Node(14);
AVLTree avlTree = new AVLTree(C);
avlTree.insert(D);
avlTree.insert(E);
avlTree.insert(A);
avlTree.insert(B);
avlTree.insert(F);
avlTree.insert(G);
avlTree.insert(M);
avlTree.insert(N);
avlTree.insert(J);
avlTree.insert(H);
avlTree.insert(I);
avlTree.insert(K);
avlTree.insert(L);
avlTree.remove(G);
avlTree.remove(M);
avlTree.remove(E);
avlTree.remove(F);
avlTree.remove(D);
avlTree.remove(I);
avlTree.remove(J);
System.out.println(avlTree.findMax().val);
System.out.println(avlTree.findMin().val);
avlTree.levelOrder(avlTree.root);
avlTree.preOrder(avlTree.root);
avlTree.inOrder(avlTree.root);
avlTree.postOrder(avlTree.root);
}

/**
* 平衡二叉树中是否包含节点node
*
* @param node
* @return
*/
public boolean contains(Node node) {
/*
* 平衡二叉树为空，自然不包含
*/
if (root == null) {
return false;
}
Node currentNode = root;
/*
* 标记node是否大于当前节点
*/
int flag = node.compareTo(currentNode);
/*
* 检查平衡二叉树中是否包含节点node
*/
while (flag != 0) {
if (flag > 0) {
currentNode = currentNode.right;
} else {
currentNode = currentNode.left;
}
/*
* 平衡二叉树树中为找到节点node，放回false。
*/
if (currentNode == null) {
return false;
}
flag = node.compareTo(currentNode);
}
return true;
}

/**
* 递归检查平衡二叉树中root是否包含node节点
*
* @param node
* @param root
*/
public boolean contains(Node node, Node root) {
/*
* root为空显然不包含节点node
*/
if (root == null) {
return false;
}
int flag = node.compareTo(root);
/*
* 在root的右子树中检查是否含有node节点
*/
if (flag > 0) {
return contains(node, root.right);
}
/*
* 在root的左子树中检查是否含有node节点
*/
if (flag < 0) {
return contains(node, root.left);
}
/*
* root中含有此节点,返回true
*/
return true;
}

/**
* 返回平衡二叉树中的最大节点
*
* @return
*/
public Node findMax() {

return findMax(root);
}

/**
* 返回平衡二叉树中的最小节点
*
* @return
*/
public Node findMin() {
return findMin(root);
}

/**
* 找到平衡二叉树root中的最大节点
*
* @param root
* @return
*/
private Node findMax(Node root) {
/**
* root节点为空
*/
if (root == null) {
return null;
}
/*
* 找到右子树中的最大元素节点
*/
Node currentNode = root;
while (currentNode.right != null) {
currentNode = currentNode.right;
}
return currentNode;
}

/**
* 递归查找平衡二叉树中的最大节点
*
* @param root
* @return
*/
private Node findMaxRec(Node root) {
if (root == null) {
return null;
}
if (root.right != null) {
return findMaxRec(root.right);
}
return root;
}

/**
* 查找平衡二叉树root中的最小节点
*
* @param node
* @param root
* @return
*/
private Node findMin(Node root) {
/*
* root为空
*/
if (root == null) {

}
/*
* 在左子树中寻找最小节点元素
*/
Node currentNode = root;
while (currentNode.left != null) {
currentNode = currentNode.left;
}
return currentNode;
}

/**
* 递归查找平衡二叉树中的最小元素
*
* @param root
* @return
*/
private Node findMinRec(Node root) {
/*
* root 为空
*/
if (root == null) {
return root;
}
if (root.left != null) {
return findMinRec(root.left);
}
return root;
}

/**
* 返回节点node的高度，node如果为null，则高度为-1
*
* @param node
* @return
*/
private int getHeight(Node node) {
return node == null ? -1 : node.hight;
}

/**
* 单旋转-右旋
*
* @param node
* @return
*/
private Node rolateWithLeftChild(Node node) {
Node leftChild = node.left;
node.left = leftChild.right;
leftChild.right = node;
/*
* 更新节点高度
*/
node.hight = 1 + Math.max(getHeight(node.left), getHeight(node.right));
leftChild.hight = 1 + Math.max(getHeight(leftChild.left),
getHeight(leftChild.right));
return leftChild;

}

/**
* 单旋转-左旋
*
* @param node
* @return
*/
private Node rolateWithRightChild(Node node) {
Node rightChild = node.right;
node.right = rightChild.left;
rightChild.left = node;
/*
* 更新节点高度
*/
node.hight = 1 + Math.max(getHeight(node.left), getHeight(node.right));
rightChild.hight = 1 + Math.max(getHeight(rightChild.left),
getHeight(rightChild.right));
return rightChild;
}

/**
* 双旋转-RL
*
* @param node
* @return
*/
private Node doubleWithLeftChild(Node node) {
node.left = rolateWithRightChild(node.left);
return rolateWithLeftChild(node);
}

/**
* 双旋转-LR
*
* @param node
* @return
*/
private Node doubleWithRightChild(Node node) {
node.right = rolateWithLeftChild(node.right);
return rolateWithRightChild(node);
}

/**
* 向平衡二叉树中插入节点node
*
* @param node
*/
public void insert(Node node) {
/*
* 更新引用(传值)
*/
root = insert(node, root);
}

/**
* 删除平衡二叉树中的节点node
*
* @param node
*/
public void remove(Node node) {
root = remove(node, root);
}

/**
* 递归实现向root平衡二叉树中插入元素node
*
* @param node
* @param root
* @return
*/
private Node insert(Node node, Node root) {
if (root == null) {
root = new Node(node.val);
}
int flag = node.compareTo(root);
if (flag > 0) {
root.right = insert(node, root.right);
/*
* 左右子树高度差
*/
flag = Math.abs(getHeight(root.left) - getHeight(root.right));
if (flag == 2) {
/*
* RR型
*/
if (getHeight(root.right.right) > getHeight(root.right.left)) {
root = rolateWithRightChild(root);
}
/*
* RL型
*/
else {
root = doubleWithRightChild(root);
}
}
} else if (flag < 0) {
root.left = insert(node, root.left);
/*
* 左右子树高度差
*/
flag = Math.abs(getHeight(root.left) - getHeight(root.right));
if (flag == 2) {
/*
* LL型
*/
if (getHeight(root.left.left) > getHeight(root.left.right)) {
root = rolateWithLeftChild(root);
}
/*
* LR型
*/
else {
root = doubleWithLeftChild(root);
}
}
}
/*
* 更新root的高度 上层的高度由子树的高度决定
*/
root.hight = 1 + Math.max(getHeight(root.left), getHeight(root.right));
return root;
}

/**
* 递归删除二叉平衡树root中的节点node
*
* @param node
* @param root
* @return
*/
private Node remove(Node node, Node root) {
/*
* root为空
*/
if (root == null) {
return null;
}
int flag = node.compareTo(root);
/*
* 待删除节点在右子树上
*/
if (flag > 0) {
root.right = remove(node, root.right);
}
/*
* 待删除节点在左子树上
*/
if (flag < 0) {
root.left = remove(node, root.left);
}
/*
* 找到待删除节点
*/
if (flag == 0) {
if (root.left != null && root.right != null) {
/*
* 用待删除节点右子树上的最小节点的与待删除节点交换，然后问题变为删除节点replaceNode
*/
Node replaceNode = findMin(root.right);
root.val = replaceNode.val;
root.right = remove(replaceNode, root.right);
} else {
root = root.right == null ? root.left : root.right;
}
}
if (root != null) {
flag = Math.abs(getHeight(root.left) - getHeight(root.right));
} else {
flag = 0;
}
if (flag == 2) {
if (getHeight(root.left) > getHeight(root.right)) {
/*
* LL型旋转
*/
if (getHeight(root.left.left) > getHeight(root.left.right)) {
root = rolateWithLeftChild(root);
}
/*
* LR型旋转
*/
else {
root = doubleWithLeftChild(root);
}
} else {
/*
* RR型旋转
*/
if (getHeight(root.right.right) > getHeight(root.right.left)) {
root = rolateWithRightChild(root);
}
/*
* RL型旋转
*/
else {
root = doubleWithRightChild(root);
}
}
}
/*
* 更新root的高度
*/
if (root != null) {
root.hight = 1 + Math.max(getHeight(root.left),
getHeight(root.right));
}
return root;
}

/**
* 非递归先序遍历
*
* @param node
*/
public void preOrder(Node node) {
if (node == null) {
return;
}
System.out.println("先序遍历：");
Stack<Node> stack = new Stack<Node>();
stack.push(node);
while (!stack.isEmpty()) {
node = stack.pop();
System.out.print(node.val + " ");
/*
* 先加入右儿子
*/
if (node.right != null) {
stack.push(node.right);
}
if (node.left != null) {
stack.push(node.left);
}
}
System.out.println();
}

/**
* 非递归中序遍历
*
* @param node
*/
public void inOrder(Node node) {
if (node == null) {
return;
}
System.out.println("中序遍历：");
Stack<Node> stack = new Stack<Node>();
while (node != null || !stack.isEmpty()) {
while (node != null) {
stack.push(node);
node = node.left;
}
/*
* 处理完左子树，根节点，处理右子树。
*/
node = stack.pop();
System.out.print(node.val + " ");
node = node.right;
}
System.out.println();
}

/**
* 非递归后序遍历
*
* @param node
*/
public void postOrder(Node node) {
if (node == null) {
return;
}
System.out.println("后序遍历：");
Stack<Node> stack = new Stack<Node>();
/*
* preNode记录前一个出栈的节点
*/
Node preNode = null;
while (node != null || !stack.isEmpty()) {
while (node != null) {
stack.push(node);
node = node.left;
}
node = stack.peek();
/*
* 处理完左子树，在处理右子树，最后处理根节点。
*/
while (node.right == null || node.right == preNode) {
System.out.print(node.val + " ");
stack.pop();
preNode = node;
if (stack.isEmpty()) {
System.out.println();
return;
}
node = stack.peek();
}
node = node.right;
}
}

public void levelOrder(Node node) {
if (node == null) {
return;
}
System.out.println("层序遍历：");
Queue<Node> queue = new ArrayDeque<Node>();
queue.offer(node);
/*
* 处理完上一层厚再处理下一层
*/
while (!queue.isEmpty()) {
node = queue.poll();
System.out.print(node.val + " ");
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
System.out.println();
}

}

/**
* 平衡二叉树节点类
*
* @author 过路的守望
*/
class Node implements Comparable<Node> {
/*
* val 节点值 height 节点高度
*/
int val;
Node left;
Node right;
int hight;

public Node(int val) {
this.val = val;
}

@Override
public int compareTo(Node o) {
return this.val - o.val;
}

}