自学java数据结构，实现了AVL树

package data_structure.tree.two;

import java.util.ArrayList;
import java.util.List;

/**
 * 完全平衡二叉树
 * @author chenmingming
 *
 */
public class AVLTree <T extends Comparable<T>>{
	/**
	 * AVL树的节点
	 * @author chenmingming
	 *
	 */
	class Node <T>{
		Node<T> left;
		Node<T> right;
		T data;
		int height = 0;
		@Override
		public String toString() {
			return data+"高度"+height;
		}
	}
	/**
	 * 根节点
	 */
	private Node<T> root;
	public Node<T> getRoot() {
		return root;
	}
	/**
	 * 内部使用的方法获取指定节点的高度
	 * @param tree
	 * @return
	 */
	private int height(Node<T> tree){
		if(tree!=null)
			return tree.height;
		return 0;
	}
	/**
	 * 对外使用获取整颗树的高度
	 * @return
	 */
	public int height() {
		return root.height;
	}
	/**
	 * 获取两个中大的一个
	 * @param v1
	 * @param v2
	 * @return
	 */
	private int max(int v1,int v2) {
		if(v1>v2)
			return v1;
		else
			return v2;
	}
	
	/**************************************************************************************************/
	/**
	 * http://blog.csdn.net/coslay/article/details/46984119
	 */
	/**
	 * LL 左单旋转 
	 * @param k1 旋转前的根节点
	 * @return	旋转后的根节点
	 */
	private Node<T> LL(Node<T> k1) {
		Node<T> k2;
		
		k2 = k1.left;
		k1.left = k2.right;
		k2.right = k1;
		
		k1.height = max(this.height(k1.left),this.height(k1.right))+1;
		k2.height = max(this.height(k2.left),this.height(k2.right))+1;
		return k2;
	}
	
	/**
	 * RR 右单旋转
	 * @param k1 旋转前的根节点
	 * @return	旋转后的根节点
	 */
	private Node<T> RR(Node<T> k1){
		Node<T> k2;
		
		k2 = k1.right;
		k1.right = k2.left;
		k2.left = k1;
		
		k1.height = max(this.height(k1.left),this.height(k1.right))+1;
		k2.height = max(this.height(k2.left),this.height(k2.right))+1;
		return k2;
	}
	
	/**
	 * LR 左右双旋转
	 * @param k1 旋转前的根节点
	 * @return	旋转后的根节点
	 */
	private Node<T> LR(Node<T> k1) {
		k1.left = this.RR(k1.left);
		return this.LL(k1);
	}
	/**
	 * RL 右左双旋转
	 * @param k1 旋转前的根节点
	 * @return	旋转后的根节点
	 */
	private Node<T> RL(Node<T> k1) {
		k1.right = this.LL(k1.right);
		return this.RR(k1);
	}
/******************************************************************************************/
	/**
	 * 
	 * @param root 树的根节点
	 * @param key 树的键值
	 * @return 新的树的根节点
	 */
	private Node<T> intser(Node<T> root,T key){
		//System.out.println(key);
		if (root == null) {
			if(this.root!=null){
				root = new Node<T>();
				root.data = key;
			}else{
				this.root = new Node<T>();
				this.root.data = key;
				root = this.root;
			}
		}else {
			int flag = key.compareTo(root.data);
			//往左边插入
			if (flag<0) {
				root.left = intser(root.left, key);
				//出现不平衡的情况
				if((this.height(root.left) - this.height(root.right))>1){
					if(root.right==null){
						int j = key.compareTo(root.left.data);
						if(j<0){
							root = this.LL(root);
						}else {
							root = this.LR(root);
						}
					}else {
						int leftFlag = key.compareTo(root.left.data);
						//左边左子树插入 --LL
						if(leftFlag<0){
							root = this.LL(root);
						}else{
						//左边右子树插入 --LR	
							root = this.LR(root);
						}
					}				
				}				
			}else{
			//往右边插入
				root.right = intser(root.right, key);
				//出现不平衡的情况
				if ((this.height(root.right) - this.height(root.left))>1) {
					if(root.left==null){
						int j = key.compareTo(root.right.data);
						if(j<0){
							root = this.RL(root);
						}else {
							root = this.RR(root);
						}
					}else{
						int rightFlag = key.compareTo(root.left.data);
						//往右边右子树插入  --RR
						if(rightFlag>0){
							root = this.RR(root);
						}else {
						//往右边左子树插入  --LR
							root = this.RL(root);
						}
					}					
				}
			}
		}
		root.height = max(this.height(root.left),this.height(root.right))+1;
		this.root = root;
		return root;
	}
	/**
	 * 插入树
	 * @param key
	 */
	public void inset(T key) {
		this.intser(this.root, key);
	}
	

/**********************************************************************************/
	/**
	 * 重小到大排列（中序排列）
	 * @param list
	 * @param root
	 * @return
	 */
	private List<T> min2max(List<T> list,Node<T> root){
		if(list==null){
			list = new ArrayList<T>();
		}
		if (root == null) {
			return null;
		}else{
			min2max(list, root.left);
			if(root.data!=null){
				list.add(root.data);
			}
			min2max(list, root.right);
		}
		return list;
	}
	/**
	 * 获取重小到大排列的集合
	 * @return
	 */
	public List<T> min2max() {
		return this.min2max(null, root);
	}
/****************************************************************/
	/**
	 * 获取对应的数据
	 */
	private T getData(T t,Node<T> root) {
		if(root==null){
			System.out.println("对不起找不到对应的数据");
			return null;
		}
		int v = t.compareTo(root.data);
		T value;
		if(v>0){
			value = getData(t, root.right);
		}else if (v<0) {
			value = getData(t, root.left);
		}else {
			value = root.data;
		}
		return value;
	}
	
	public T getData(T t) {
		return this.getData(t,root);
	}
}

比较时需要对象实现Comparable接口所以int ，double等基本类型就不能使用了

下面是我的测试实体

package data_structure.tree.two;

public class TestModel implements Comparable<TestModel>{

	@Override
	public int compareTo(TestModel o) {
		int value = 0;
		if(o.getAge()<this.age){
			value = 1;
		}else if(o.getAge()>this.age){
			value = -1;
		}
		return value;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	private String name;
	private int age;
}

以及我的测试类

package data_structure.tree.two;

import java.util.List;

public class Test {
	public static void main(String[] args) {
		Integer a [] =new Integer[]{2,5,1,7,6,8,9,4,8,10,0,31};
		BRTree<Integer> tree = new BRTree<Integer>();
		for (Integer integer : a) {
			tree.insert(integer);
		}
		tree.min2max();
	}
}