[Function add]

1.Balanced binary tree

Author: Seanforfun

Diff for: Algorithm(4th_Edition)/src/ca/mcmaster/chapter/three/bitree/BinaryTree.java renamed to Algorithm(4th_Edition)/Notes/Tree/BinaryTree.java

@@ -1,5 +1,3 @@
-package ca.mcmaster.chapter.three.bitree;
-
 public class BinaryTree<K extends Comparable<K>, V> {
 	protected class Node{
 		protected Node left, right;

Diff for: Algorithm(4th_Edition)/Notes/Tree/CompleteBinaryTree.java

@@ -0,0 +1,64 @@
+public class CompleteBinaryTree<K extends Comparable<K>> {
+	private Object[] arr;	//因为无法实现泛型数组，我们通过Object数组替代。第一个位置不存储元素
+	private int N;		//树中元素的个数。
+	public CompleteBinaryTree(int N) {
+		arr = new Object[N];
+	}
+	private void swap(int i, int j){	//交换两个元素的位置
+		Object temp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = temp;
+	}
+	@SuppressWarnings("unchecked")
+	private boolean less(Integer i, Integer j){
+		return ((K)arr[i]).compareTo(((K)arr[j])) < 0;
+	}
+	private void swin(int k){
+		while(k > 1 && less(k/2, k)){
+			swap(k/2, k);
+			k /= 2;
+		}
+	}
+	public void insert(K k){
+		arr[++N] = k;
+		swin(N);
+	}
+	public Integer size(){
+		return N;
+	}
+	@SuppressWarnings("unchecked")
+	public K get(int i){
+		return (K)arr[i];
+	}
+	private void sink(int i){
+		while(i * 2 <= N){
+			int j = i * 2;
+			if(j + 1 < N && less(j, j+1)) j++;		//取两个子结点中更大的一个。
+			swap(i, j);
+			i = j;		//在当前子树中继续进行下沉
+		}
+	}
+	
+	public K delMax(){
+		K max = (K)arr[1];
+		swap(1, N + 1);
+		arr[N + 1] = null;
+		sink(1);
+		N--;
+		return max;
+	}
+	
+	public static void main(String[] args) {
+		CompleteBinaryTree<Integer> cbtree = new CompleteBinaryTree<>(100);
+		cbtree.insert(1);
+		cbtree.insert(2);
+		cbtree.insert(3);
+		cbtree.insert(4);
+		cbtree.insert(5);
+		cbtree.insert(6);
+		cbtree.delMax();
+		for(int i = 1; i <= cbtree.size(); i++){
+			System.out.println(cbtree.get(i));
+		}
+	}
+}

Diff for: Algorithm(4th_Edition)/Notes/Tree/平衡二叉树BalancedBinaryTree.md

@@ -0,0 +1,47 @@
+# 平衡二叉树Balanced Binary Tree
+>平衡二叉树（Balanced Binary Tree）是二叉查找树的一个进化体，也是第一个引入平衡概念的二叉树。平衡二叉树要求对于每一个节点来说，它的左右子树的高度之差不能超过1，如果插入或者删除一个节点使得高度之差大于1，就要进行节点之间的旋转，将二叉树重新维持在一个平衡状态。这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。
+
+## 定义
+>平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉树：**它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1**，且它的左子树和右子树都是一颗平衡二叉树。
+
+* 旋转
+>通过对树进行简单的修复来让其重新恢复到平衡，而这样的简单操作我们就称之为旋转，当然旋转也有单旋转和双旋转之分。
+假设结点X是失衡点，它必须重新恢复平衡，由于任意结点的孩子结点最多有两个，而且导致失衡的必要条件是X结点的两棵子树高度差为2(大于1)，因此一般只有以下4种情况可能导致X点失去平衡：
+① 在结点X的左孩子结点的左子树中插入元素
+② 在结点X的左孩子结点的右子树中插入元素
+③ 在结点X的右孩子结点的左子树中插入元素
+④ 在结点X的右孩子结点的右子树中插入元素
+
+* 高度
+>高度是指当前结点到叶子结点的最长路径，如所有叶子结点的高度都为0。
+![height](https://i.imgur.com/dA8OWAs.png)
+
+* 左左单旋转(LL)情景①分析
+![LL](https://i.imgur.com/kpMVlUs.png)
+```Java
+	private AVLNode singleRotateLeft(AVLNode n){
+		AVLNode left1 = n.left;
+		n.left = left1.right;
+		left1.right = n;
+		left1.height = Math.max(left1.left.height, left1.right.height) + 1;
+		n.height = Math.max(n.left.height, n.right.height) + 1;
+		return left1;
+	}
+```
+
+* 右右单旋转(RR)情景④分析
+![RR](https://i.imgur.com/CkFlj4X.png)
+```Java
+	private AVLNode singleRotateRight(AVLNode n){
+		AVLNode right1 = n.right;
+		n.left = right1.left;
+		right1.left = n;
+		right1.height = Math.max(right1.left.height, right1.right.height) + 1;
+		n.height = Math.max(n.left.height, n.right.height) + 1;
+		return right1;
+	}
+```
+
+* 平衡二叉树的双旋转算法与实现
+* 左右双旋转(LR)情景②分析
+![LR](https://i.imgur.com/926XxBS.png)

Diff for: Algorithm(4th_Edition)/src/ca/mcmaster/chapter/three/bitree/BalancedBinaryTree.java

@@ -0,0 +1,42 @@
+package ca.mcmaster.chapter.three.bitree;
+
+public class BalancedBinaryTree<V extends Comparable<V>> {
+	private class AVLNode{
+		V v;
+		int height;	//当前节点的子树的高度
+		AVLNode left, right;
+		public AVLNode(V v, AVLNode left, AVLNode right, int height) {
+			this.v = v;
+			this.left = left;
+			this.right = right;
+			this.height = height;
+		}
+		public AVLNode(V v, AVLNode left, AVLNode right) {
+			this(v, left, right, 0);
+		}
+		public AVLNode(V v) {
+			this(v, null, null);
+		}
+	}
+	private int height(AVLNode n){
+		return n.height;
+	}
+	
+	private AVLNode singleRotateLeft(AVLNode n){
+		AVLNode left1 = n.left;
+		n.left = left1.right;
+		left1.right = n;
+		left1.height = Math.max(left1.left.height, left1.right.height) + 1;
+		n.height = Math.max(n.left.height, n.right.height) + 1;
+		return left1;
+	}
+	
+	private AVLNode singleRotateRight(AVLNode n){
+		AVLNode right1 = n.right;
+		n.left = right1.left;
+		right1.left = n;
+		right1.height = Math.max(right1.left.height, right1.right.height) + 1;
+		n.height = Math.max(n.left.height, n.right.height) + 1;
+		return right1;
+	}
+}