add avltree algorithm

Author: robert

README.md

@@ -1 +1 @@
-[欢迎访问我的博客](http://blog.csdn.net/robertcpp)<br>[算法系列（一）基本概念](http://blog.csdn.net/robertcpp/article/details/51530518)<br>[算法系列（二）查找算法--基本查找和二分查找](http://blog.csdn.net/robertcpp/article/details/51532593)<br>[算法系列（三）排序算法上篇--冒泡排序插入排序和选择排序](http://blog.csdn.net/robertcpp/article/details/51534034)<br>[算法系列（四）排序算法中篇--归并排序和快速排序](http://blog.csdn.net/robertcpp/article/details/51540976)<br>[算法系列（五）排序算法下篇--如何超越排序算法下界](http://blog.csdn.net/robertcpp/article/details/51559333)<br># simplealgorithm##com.algorithm.math PrimeNumber 素数打表，快速判断一个数是不是素数<br>##com.algorithm.thread TestAsynTreadXunlei 开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。<br>##com.algorithm.beanPerson 实现Comparable接口的一个类<br>##com.algorithm.cacheIcache 缓存接口<br>BaseCache 缓存基类<br>FIFOCache FIFO缓存算法实现<br>LRUCache LRU缓存算法实现<br>LFUCache LFU缓存算法实现<br>CacheTest 缓存测试类<br>##com.algorithm.digestDigestUtil 快速计算文件MD5信息，通用获取MD 5文件信息的封装<br>DigestMain MD5测试类<br>##com.algorithm.list MyArrayList 数组线性表的实现<br>MyLinkedList 链表的实现<br>Permutation 简单的组合算法<br>ArrayStack 栈的数组实现<br>LinkedStack 栈的链表实现<br>LinkedQueue 队列的链表实现<br>CircularArrayQueue 队列的循环数组实现<br>##com.algorithm.treeBinarySearch 二分查找的递归实现和非递归实现方式<br>FindAllFile 查找某一目录下的所有文件TreeNode 基本树结构BinaryTree二叉树实现和二叉树的遍历BinarySeachTree 二叉查找树BSTBinarySearchTreeTest 二叉查找树测试##com.algorithm.sortJavaSort Java Collections.sort的两种排序方式<br>Bubblesort 冒泡排序<br>SelectionSort 选择排序<br>InsertionSort 插入排序<br>MergeSort 归并排序<br>QuickSort 快速排序<br>CountSort 计数排序<br>##com.algorithm.graphicsUnionFind   并查集算法<br>关注我的微信公众号，获取更多技术分享，扫一扫下方二维码或搜索微信号le_coding即可关注![我的微信公众号](http://img.my.csdn.net/uploads/201605/08/1462674108_9582.jpg)
+[欢迎访问我的博客](http://blog.csdn.net/robertcpp)<br>[算法系列（一）基本概念](http://blog.csdn.net/robertcpp/article/details/51530518)<br>[算法系列（二）查找算法--基本查找和二分查找](http://blog.csdn.net/robertcpp/article/details/51532593)<br>[算法系列（三）排序算法上篇--冒泡排序插入排序和选择排序](http://blog.csdn.net/robertcpp/article/details/51534034)<br>[算法系列（四）排序算法中篇--归并排序和快速排序](http://blog.csdn.net/robertcpp/article/details/51540976)<br>[算法系列（五）排序算法下篇--如何超越排序算法下界](http://blog.csdn.net/robertcpp/article/details/51559333)<br># simplealgorithm##com.algorithm.math PrimeNumber 素数打表，快速判断一个数是不是素数<br>##com.algorithm.thread TestAsynTreadXunlei 开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。<br>##com.algorithm.beanPerson 实现Comparable接口的一个类<br>##com.algorithm.cacheIcache 缓存接口<br>BaseCache 缓存基类<br>FIFOCache FIFO缓存算法实现<br>LRUCache LRU缓存算法实现<br>LFUCache LFU缓存算法实现<br>CacheTest 缓存测试类<br>##com.algorithm.digestDigestUtil 快速计算文件MD5信息，通用获取MD 5文件信息的封装<br>DigestMain MD5测试类<br>##com.algorithm.list MyArrayList 数组线性表的实现<br>MyLinkedList 链表的实现<br>Permutation 简单的组合算法<br>ArrayStack 栈的数组实现<br>LinkedStack 栈的链表实现<br>LinkedQueue 队列的链表实现<br>CircularArrayQueue 队列的循环数组实现<br>##com.algorithm.treeBinarySearch 二分查找的递归实现和非递归实现方式<br>FindAllFile 查找某一目录下的所有文件TreeNode 基本树结构BinaryTree二叉树实现和二叉树的遍历BinarySeachTree 二叉查找树BSTAVLTree AVL平衡二叉树BinarySearchTreeTest 二叉查找树测试##com.algorithm.sortJavaSort Java Collections.sort的两种排序方式<br>Bubblesort 冒泡排序<br>SelectionSort 选择排序<br>InsertionSort 插入排序<br>MergeSort 归并排序<br>QuickSort 快速排序<br>CountSort 计数排序<br>##com.algorithm.graphicsUnionFind   并查集算法<br>关注我的微信公众号，获取更多技术分享，扫一扫下方二维码或搜索微信号le_coding即可关注![我的微信公众号](http://img.my.csdn.net/uploads/201605/08/1462674108_9582.jpg)

src/com/algorithm/tree/AVLTree.java

@@ -0,0 +1,101 @@
+package com.algorithm.tree;
+
+import java.util.Comparator;
+
+/**
+ * AVL树
+ * 
+ * @author chao
+ *
+ * @param <T>
+ */
+public class AVLTree<T> extends BinarySeachTree<T> {
+
+	public AVLTree(T root) {
+		super(root);
+	}
+
+	public AVLTree(T root, Comparator<T> comparator) {
+		super(root, comparator);
+	}
+
+	@Override
+	protected BinaryTreeNode<T> insert(BinaryTreeNode<T> cur, BinaryTreeNode<T> x) {
+		if (cur == null) {
+			return x;
+		}
+		int compareresult = compare(cur, x);
+		if (compareresult < 0) {
+			cur.right = insert(cur.right, x);
+			if (getHeight(cur.right) - getHeight(cur.left) == 2) {
+				if (compare(x, cur.right) > 0) {
+					cur = roateWithRightChild(cur);
+				} else {
+					cur = doubleWithRightChild(cur);
+				}
+			}
+		} else if (compareresult > 0) {
+			cur.left = insert(cur.left, x);
+			if (getHeight(cur.left) - getHeight(cur.right) == 2) {
+				if (compare(x, cur.left) < 0) {
+					cur = roateWithLeftChild(cur);
+				} else {
+					cur = doubleWithLeftChild(cur);
+				}
+			}
+		} else {
+			cur.hintcount++;
+		}
+		return cur;
+	}
+
+	/**
+	 * 左子树单旋转
+	 * 
+	 * @param node
+	 * @return
+	 */
+	protected BinaryTreeNode<T> roateWithLeftChild(BinaryTreeNode<T> k2) {
+		BinaryTreeNode<T> k1 = k2.left;
+		k2.left = k1.right;
+		k1.right = k2;
+		return k1;
+
+	}
+
+	/**
+	 * 右子树单旋转
+	 * 
+	 * @param node
+	 * @return
+	 */
+	protected BinaryTreeNode<T> roateWithRightChild(BinaryTreeNode<T> k2) {
+		BinaryTreeNode<T> k1 = k2.right;
+		k2.right = k1.left;
+		k1.left = k2;
+		return k1;
+	}
+
+	/**
+	 * 左子树双旋转
+	 * 
+	 * @param node
+	 * @return
+	 */
+	protected BinaryTreeNode<T> doubleWithLeftChild(BinaryTreeNode<T> k3) {
+		k3.left = roateWithRightChild(k3.left);
+		return roateWithLeftChild(k3);
+
+	}
+
+	/**
+	 * 右子树双旋转
+	 * 
+	 * @param node
+	 * @return
+	 */
+	protected BinaryTreeNode<T> doubleWithRightChild(BinaryTreeNode<T> k3) {
+		k3.right = roateWithLeftChild(k3.right);
+		return roateWithRightChild(k3);
+	}
+}

src/com/algorithm/tree/BinarySeachTree.java

@@ -12,24 +12,33 @@
 public class BinarySeachTree<T> extends BinaryTree<T> {
 	private Comparator<T> comparator;
 
-	public BinarySeachTree(BinarySeachTree.BinaryTreeNode<T> root) {
+	public BinarySeachTree(T root) {
 		this(root, null);
 	}
 
-	public BinarySeachTree(BinarySeachTree.BinaryTreeNode<T> root, Comparator<T> comparator) {
+	public BinarySeachTree(T root, Comparator<T> comparator) {
 		super(root);
 		this.comparator = comparator;
 	}
 
-	private int compare(BinarySeachTree.BinaryTreeNode<T> a, BinarySeachTree.BinaryTreeNode<T> b) {
+	protected int compare(BinarySeachTree.BinaryTreeNode<T> a, BinarySeachTree.BinaryTreeNode<T> b) {
 		if (comparator != null) {
 			return comparator.compare(a.element, b.element);
 		} else if (a.element instanceof Comparable && b.element instanceof Comparable) {
 			return ((Comparable) a.element).compareTo(b.element);
 		} else {
 			throw new RuntimeException("can't compare " + a.element.getClass());
 		}
+	}
 
+	protected int compare(T a, T b) {
+		if (comparator != null) {
+			return comparator.compare(a, b);
+		} else if (a instanceof Comparable && b instanceof Comparable) {
+			return ((Comparable) a).compareTo(b);
+		} else {
+			throw new RuntimeException("can't compare " + a.getClass() + " " + b.getClass());
+		}
 	}
 
 	/**
@@ -38,8 +47,8 @@ private int compare(BinarySeachTree.BinaryTreeNode<T> a, BinarySeachTree.BinaryT
 	 * @param x
 	 * @return
 	 */
-	public boolean contains(BinaryTreeNode<T> x) {
-		return contains(root, x);
+	public boolean contains(T x) {
+		return contains(root, new BinaryTreeNode<T>(x));
 	}
 
 	/**
@@ -49,8 +58,8 @@ public boolean contains(BinaryTreeNode<T> x) {
 	 * @param x
 	 * @return
 	 */
-	public boolean contains(BinaryTreeNode<T> cur, BinaryTreeNode<T> x) {
-		if (x == null || cur == null) {
+	protected boolean contains(BinaryTreeNode<T> cur, BinaryTreeNode<T> x) {
+		if (x == null || cur == null || cur.hintcount < 0) {
 			return false;
 		}
 		int compareresult = compare(cur, x);
@@ -63,14 +72,38 @@ public boolean contains(BinaryTreeNode<T> cur, BinaryTreeNode<T> x) {
 		}
 	}
 
+	/**
+	 * 查找节点
+	 * 
+	 * @param cur
+	 * @param x
+	 * @return
+	 */
+	protected BinaryTreeNode<T> findNode(BinaryTreeNode<T> cur, T x) {
+		if (x == null || cur == null || cur.hintcount < 0) {
+			return null;
+		}
+		int compareresult = compare(cur.element, x);
+		if (compareresult == 0) {
+			return cur;
+		} else if (compareresult < 0) {
+			return findNode(cur.right, x);
+		} else {
+			return findNode(cur.left, x);
+		}
+	}
+
 	/**
 	 * 从根节点插入一个新数据
 	 * 
 	 * @param x
 	 * @return
 	 */
-	public BinaryTreeNode<T> insert(BinaryTreeNode<T> x) {
-		return insert(root, x);
+	public void insert(T x) {
+		if (x == null) {
+			return;
+		}
+		insert(root, new BinaryTreeNode<T>(x));
 	}
 
 	/**
@@ -89,6 +122,8 @@ protected BinaryTreeNode<T> insert(BinaryTreeNode<T> cur, BinaryTreeNode<T> x) {
 			cur.right = insert(cur.right, x);
 		} else if (compareresult > 0) {
 			cur.left = insert(cur.left, x);
+		} else {
+			cur.hintcount++;
 		}
 		return cur;
 	}
@@ -98,8 +133,8 @@ protected BinaryTreeNode<T> insert(BinaryTreeNode<T> cur, BinaryTreeNode<T> x) {
 	 * 
 	 * @return
 	 */
-	public BinaryTreeNode<T> findMin() {
-		return findMin(root);
+	public T findMin() {
+		return findMin(root).element;
 	}
 
 	/**
@@ -108,7 +143,7 @@ public BinaryTreeNode<T> findMin() {
 	 * @param node
 	 * @return
 	 */
-	public BinaryTreeNode<T> findMin(BinaryTreeNode<T> node) {
+	protected BinaryTreeNode<T> findMin(BinaryTreeNode<T> node) {
 		if (node == null) {
 			return null;
 		} else if (node.left == null) {
@@ -122,8 +157,8 @@ public BinaryTreeNode<T> findMin(BinaryTreeNode<T> node) {
 	 * 
 	 * @return
 	 */
-	public BinaryTreeNode<T> findMax() {
-		return findMax(root);
+	public T findMax() {
+		return findMax(root).element;
 	}
 
 	/**
@@ -132,7 +167,7 @@ public BinaryTreeNode<T> findMax() {
 	 * @param node
 	 * @return
 	 */
-	public BinaryTreeNode<T> findMax(BinaryTreeNode<T> node) {
+	protected BinaryTreeNode<T> findMax(BinaryTreeNode<T> node) {
 		if (node == null) {
 			return null;
 		} else if (node.right == null) {
@@ -147,8 +182,26 @@ public BinaryTreeNode<T> findMax(BinaryTreeNode<T> node) {
 	 * @param x
 	 * @return
 	 */
-	public BinaryTreeNode<T> remove(BinaryTreeNode<T> x) {
-		return remove(root, x);
+	public void remove(T x) {
+		BinaryTreeNode<T> node = findNode(root, x);
+		if (node == null) {
+			return;
+		} else if (node.hintcount <= 0) {
+			remove(root, new BinaryTreeNode<T>(x));
+		} else {
+			lazyRemove(node);
+		}
+	}
+
+	public void lazyRemove(T x) {
+		BinaryTreeNode<T> node = findNode(root, x);
+		if (node != null) {
+			node.hintcount--;
+		}
+	}
+
+	protected void lazyRemove(BinaryTreeNode<T> x) {
+		x.hintcount--;
 	}
 
 	/**
@@ -158,7 +211,7 @@ public BinaryTreeNode<T> remove(BinaryTreeNode<T> x) {
 	 * @param x
 	 * @return
 	 */
-	public BinaryTreeNode<T> remove(BinaryTreeNode<T> cur, BinaryTreeNode<T> x) {
+	protected BinaryTreeNode<T> remove(BinaryTreeNode<T> cur, BinaryTreeNode<T> x) {
 		if (cur == null || x == null) {
 			return cur;
 		}