[Function add]

1Complete binary tree

Author: Seanforfun

Algorithm(4th_Edition)/Notes/QueueConclusion.md renamed to Algorithm(4th_Edition)/Notes/Queue/QueueConclusion.md

@@ -0,0 +1,76 @@
+# 完全二叉树 Complete Binary Tree
+* **堆**就是通过完全二叉树实现的，可以参考排序部分的堆排序。
+>当一一棵二叉树的每个结点都大于等于它的两个子结点时，被称为**堆有序**。
+
+>完全二叉树是效率很高的数据结构，堆是一种完全二叉树或者近似完全二叉树，所以效率极高，像十分常用的排序算法、Dijkstra算法、Prim算法等都要用堆才能优化，几乎每次都要考到的二叉排序树的效率也要借助平衡性来提高，而平衡性基于完全二叉树。
+
+## 判断完全二叉树
+>若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。
+
+![CompleteBinaryTree](https://i.imgur.com/YzCQuXP.jpg)
+* 对于第n行，最多有2^(n-1)个元素。
+
+## 二叉堆的实现方式
+* 通过数组实现二叉堆
+```Java
+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 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;		//在当前子树中继续进行下沉
+		}
+	}
+}
+```
+
+## 完全二叉树的增删改查
+* 增
+```Java
+	public void insert(K k){
+		arr[++N] = k;
+		swin(N);
+	}
+```
+
+* 删
+```Java
+	public K delMax(){
+		K max = (K)arr[1];
+		swap(1, N + 1);
+		arr[N + 1] = null;
+		sink(1);
+		N--;
+		return max;
+	}
+```

Algorithm(4th_Edition)/Notes/二叉树BinaryTree.md renamed to Algorithm(4th_Edition)/Notes/Tree/二叉树BinaryTree.md

@@ -0,0 +1,231 @@
+# Queue Conclusion
+
+### Queue interface
+> `boolean add(E e);`	Add and offer are used to add element into the queue.
+>
+> `boolean offer(E e);`
+>
+> `E remove();`			Retrieve and remove the head of the queue.
+> 
+> `E poll();`
+> 
+> `E element();`		Retrieves, but does not remove, the head of this queue.
+> 
+> `E peek();`
+
+### Blocking and non-blocking
+* Concurrent queue有两种实现方法，阻塞和非阻塞。
+* 阻塞队列是通过锁实现。
+* 非阻塞队列通过AQS实现。
+
+#### ArrayBlockingQueue
+* ArrayBlockingQueue ：一个由数组支持的有界队列。
+* 如果到达了上界，将无法添加新的元素进入。
+* FIFO
+>ArrayBlockingQueue在构造时需要指定容量， 并可以选择是否需要公平性，如果公平参数被设置true，等待时间最长的线程会优先得到处理（其实就是通过将ReentrantLock设置为true来 达到这种公平性的：即等待时间最长的线程会先操作）。通常，公平性会使你在性能上付出代价，只有在的确非常需要的时候再使用它。它是基于数组的阻塞循环队 列，此队列按 FIFO（先进先出）原则对元素进行排序。
+```Java
+	public boolean offer(E e) {
+        checkNotNull(e);
+        final ReentrantLock lock = this.lock;
+        lock.lock();		//在写入的过程中获取锁
+        try {
+            if (count == items.length)
+                return false;
+            else {
+                enqueue(e);	//调用私有的enqueue方法
+                return true;
+            }
+        } finally {
+            lock.unlock();	//释放锁
+        }
+    }
+```
+```Java
+    /**
+     * Inserts element at current put position, advances, and signals.
+     * Call only when holding lock.
+     */
+    private void enqueue(E x) {
+        // assert lock.getHoldCount() == 1;
+        // assert items[putIndex] == null;
+        final Object[] items = this.items;
+        items[putIndex] = x;
+        if (++putIndex == items.length)
+            putIndex = 0;
+        count++;
+        notEmpty.signal();	//取消notEmpty的await.
+    }
+```
+```Java
+    public E poll() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            return (count == 0) ? null : dequeue();	//判断当前队列有没有元素。有的话调用deqeueu方法。
+        } finally {
+            lock.unlock();
+        }
+    }
+```
+```Java
+    private E dequeue() {
+        // assert lock.getHoldCount() == 1;
+        // assert items[takeIndex] != null;
+        final Object[] items = this.items;
+        @SuppressWarnings("unchecked")
+        E x = (E) items[takeIndex];
+        items[takeIndex] = null;
+        if (++takeIndex == items.length)
+            takeIndex = 0;
+        count--;
+        if (itrs != null)
+            itrs.elementDequeued();
+        notFull.signal();
+        return x;
+    }
+```
+
+#### LinkedBlockingQueue
+* 一个由链接节点支持的可选有界队列。
+* 内部维护了一个Node类
+>LinkedBlockingQueue的容量是没有上限的（说的不准确，在不指定时容量为Integer.MAX_VALUE，不要然的话在put时怎么会受阻呢），但是也可以选择指定其最大容量，它是基于链表的队列，此队列按 FIFO（先进先出）排序元素。
+```Java
+static class Node<E> {
+        E item;
+
+        /**
+         * One of:
+         * - the real successor Node
+         * - this Node, meaning the successor is head.next
+         * - null, meaning there is no successor (this is the last node)
+         */
+        Node<E> next;
+
+        Node(E x) { item = x; }
+    }
+```
+```Java
+	public boolean offer(E e) {
+        if (e == null) throw new NullPointerException();
+        final AtomicInteger count = this.count;	//此处的count为AtomicInteger，维护了原子性
+        if (count.get() == capacity)
+            return false;
+        int c = -1;
+        Node<E> node = new Node<E>(e);
+        final ReentrantLock putLock = this.putLock;
+        putLock.lock();
+        try {
+            if (count.get() < capacity) {
+                enqueue(node);
+                c = count.getAndIncrement();	
+                if (c + 1 < capacity)
+                    notFull.signal();
+            }
+        } finally {
+            putLock.unlock();
+        }
+        if (c == 0)
+            signalNotEmpty();
+        return c >= 0;
+    }
+    
+    private void enqueue(Node<E> node) {
+        // assert putLock.isHeldByCurrentThread();
+        // assert last.next == null;
+        last = last.next = node;	//在链表的结尾，添加要插入的结点。
+    }
+```
+```Java
+	public E poll() {
+        final AtomicInteger count = this.count;
+        if (count.get() == 0)
+            return null;
+        E x = null;
+        int c = -1;
+        final ReentrantLock takeLock = this.takeLock;
+        takeLock.lock();
+        try {
+            if (count.get() > 0) {
+                x = dequeue();
+                c = count.getAndDecrement();
+                if (c > 1)
+                    notEmpty.signal();
+            }
+        } finally {
+            takeLock.unlock();
+        }
+        if (c == capacity)
+            signalNotFull();
+        return x;
+    }
+```
+
+#### PriorityBlockingQueue 
+* 一个由优先级堆支持的无界优先级队列。
+>PriorityBlockingQueue是一个带优先级的 队列，而不是先进先出队列。元素按优先级顺序被移除，该队列也没有上限（看了一下源码，PriorityBlockingQueue是对 PriorityQueue的再次包装，是基于堆数据结构的，而PriorityQueue是没有容量限制的，与ArrayList一样，所以在优先阻塞 队列上put时是不会受阻的。虽然此队列逻辑上是无界的，但是由于资源被耗尽，所以试图执行添加操作可能会导致 OutOfMemoryError），但是如果队列为空，那么取元素的操作take就会阻塞，所以它的检索操作take是受阻的。另外，往入该队列中的元 素要具有比较能力。
+```Java
+    public boolean offer(E e) {
+        if (e == null)
+            throw new NullPointerException();
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        int n, cap;
+        Object[] array;
+        while ((n = size) >= (cap = (array = queue).length))
+            tryGrow(array, cap);
+        try {
+            Comparator<? super E> cmp = comparator;
+            if (cmp == null)
+                siftUpComparable(n, e, array);
+            else
+                siftUpUsingComparator(n, e, array, cmp);
+            size = n + 1;
+            notEmpty.signal();
+        } finally {
+            lock.unlock();
+        }
+        return true;
+    }
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+