数据结构之平衡二叉树

树结构简介
树结构本身是一种天然的组织结构，将数据使用树结构存储后，会大幅高效率。

什么是二叉树

• 和链表一样，动态数据结构

class Node{
	E e;
	Node left;	//左孩子
	Node right;	//右孩子
}

多叉树（多个子结点）

• 二叉树具有唯一根节点
• 二叉树中每个结点最多有两个孩子，没有孩子的结点称之为叶子结点
• 二叉树中每个结点最多有一个父亲结点，根节点没有父亲结点
• 二叉树具有天然递归结构，每个结点的左子树或右子树，也是一个二叉树

平衡二叉树

平衡二叉搜索树（Self-balancing binary search
tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一
棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

• 二叉树不一定是“满”的

• 极端的左或右都是二叉树，只不过退化成了线性表，这种情况称之为不平衡二叉树

• 一个结点也叫二叉树，无非左右孩子都为null，null 空也是二叉树
  
• 什么是完全二叉树，什么是满二叉树，二叉树中层数与结点个数的关系？

完全二叉树：如果一棵具有n个结点的深度为k的二叉树，它的每一个结点都与深度为k的满二叉树中编号为1~n的结点一一对应，这棵二叉树称为完全二叉树。

满二叉树：除最后一层无任何子节点外，每一层上的所有结点都有两个子结点二叉树。

每一层最多几个节点 2^(h-1)

如果用动态数组存一个深度为h的二叉树 最多需要 2^h-1

- 什么是二分搜索树（Binary Search Tree）

• 二分搜索树是二叉树
• 对于二分搜索树的每个结点的值而言

-大于其左子树的所有结点的值-
-小于其右子树的所有结点的值-

• 其每一个子树也是二分搜索树

二分搜索树中所存储的元素必须具有可比较性！实现Comparable接口
不包含重复元素
.
.
.

二分搜索树的实现
1.定义类

public class BinarySearchTree<E extends Comparable<E>>

2. 定义结点（内部类）

private class Node{
	public E e; 
	public Node left;
	public Node right; 
	public Node(E e) {
		this.e=e; 
		left=null;
 		right=null;
	 }
}

3. 定义成员变量

private Node root;
private int size;

4. 定义构造函数

public BinarySearchTree(){ 
	root=null;
	size=0;
}

5. 获取树中元素的个数

public int size(){
	return size;
}

6. 判断树是否为空

public boolean isEmpty(){
	return size==0;
}

7. 添加元素

public void add(E e){
	root=add(root,e);
}
//以node为当前树的根节点，添加元素e并返回该树的根 此处递归实现 如何循环实现？
private Node add(Node node,E e){
  if(node==null){
   size++;
   return new Node(e);
  }
  if(e.compareTo(node.e)>0){
   node.right=add(node.right,e);
  }else if(e.compareTo(node.e)<0){
   node.left=add(node.left, e);
  }
  return node;
 }

8.查找元素e是否存在于树中

   public boolean contains(E e){
 	 return contains(root,e); 
  }
  private boolean contains(Node node,E e){
 if(node==null){
	return false;
  }
  if(e.compareTo(node.e)>0){
	 return contains(node.left,e);
  }else if(e.compareTo(node.e)<0){
  	 return contains(node.right,e);
  }else{
 	 return true;
  }
 }

9.中序遍历

public void inOrder(){
  ArrayList<E> list=new ArrayList<E>();
  inOrder(root,list);
  System.out.println(list);
 }
 //中序遍历
 private void inOrder(BinarySearchTree<E>.Node node, ArrayList<E> list) {
  if(node==null){
   return;
  }
  inOrder(node.left,list);
  list.add(node.e);
  inOrder(node.right, list);
 }

10.层序遍历/广度优先遍历

  public void levelOrder(){
   ArrayList<E> list=new ArrayList<E>();
   //用辅助队列实现层序遍历
   Queue<Node> queue=new LinkedList<Node>();
   queue.add(root);
   while(!queue.isEmpty()){
    Node cur=queue.poll();
    list.add(cur.e);
    if(cur.left!=null){
     queue.add(cur.left);
    }
    if(cur.right!=null){
     queue.add(cur.right);
    }
   }
   System.out.println(list);
  }
  @Override
  public String toString() {
   StringBuilder sb=new StringBuilder();
   generateBSTString(root,0,sb);
   return sb.toString();
  }
  private void generateBSTString(BinarySearchTree<E>.Node node, int level,
    StringBuilder sb) {
   if(node==null){
    sb.append(generateDepthString(level)+"null\n");
    return;
   }
   generateBSTString(node.left, level+1, sb);
   sb.append(generateDepthString(level)+node.e+"\n");
   generateBSTString(node.right, level+1, sb);
  }
  private String generateDepthString(int level) {
   StringBuilder sb=new StringBuilder();
   for(int i=0;i<level;i++){
    sb.append("  ");
   }
   return sb.toString();
  }

11.获取最小值

public E minmum(){
   if(size()==0){
    throw new IllegalArgumentException("Tree is empty!");
   }
   return minmun(root).e;
  }
  //以Node为根节点，查找该数中的最小值
  private Node minmun(Node node){
   if(node.left==null){
    return node;
   }
   return minmun(node.left);
  }

12.获取最大值

public E maxmun(){
   if(size()==0){
    throw new IllegalArgumentException("Tree is empty!");
   }
   return maxmum(root).e;
  }
  private Node maxmum(BinarySearchTree<E>.Node node) {
   if(node.right==null){
    return node;
   }
   return maxmum(node.right);
  }

13.删除最小值

public E removeMin(){
   E e=minmum();
   root=removeMin(root);
   return e;
  }
  //以node为根节点的二分搜索树，在删除最小值之后并返回新树的根
  private BinarySearchTree<E>.Node removeMin(
    BinarySearchTree<E>.Node node) {
   if(node.left==null){
    Node rightNode=node.right;
    node.right=null;
    size--;
    return rightNode;
   }
   node.left=removeMin(node.left);
   return node;
  }

14.删除最大值

public E removeMax(){
   E e=maxmun();
   root=removeMax(root);
   return e;
  }
  private BinarySearchTree<E>.Node removeMax(
    BinarySearchTree<E>.Node node) {
   if(node.right==null){
    Node leftNode=node.left;
    node.left=null;
    size--;
    return leftNode;
   }
   node.right=removeMax(node.right);
   return node;
  }

15.删除任意元素

public void remove(E e){
   root=remove(root,e);
  }
  //以node为根，删除指定元素e之后，返回新树的根
  private Node remove(Node node,E e){
   if(node==null){
    return null;
   }
   if(e.compareTo(node.e)>0){
    node.right=remove(node.right, e);
    return node;
   }else if(e.compareTo(node.e)<0){
    node.left=remove(node.left, e);
    return node;
   }else{
    if(node.left==null){
     Node rightNode=node.right;
     node.right=null;
     size--;
     return rightNode;
    }
    if(node.right==null){
     Node leftNode=node.left;
     node.left=null;
     size--;
     return leftNode;
    }
    Node successor=minmun(node.right);
    successor.right=removeMin(node.right);
    successor.left=node.left;
    node.left=node.right=null;
    return successor;
   }
  }