隊列(queue),也是一種特殊的線性表，使用固定的一端來插入數據，另一端用于刪除數據

先進先出，就像火車站排隊買票一樣！??！，整個隊伍向前面移動。

分為順序隊列結構和鏈式隊列結構

從JDK 5 開始，Java集合框架提供了Queue接口，實現該接口的類可以當成隊列使用，如LinkedBlockingQueue，PriorityBlockingQueue。

可以通過輪詢和等待-通知機制實現阻塞隊列。

具體Queue實現：

import java.util.*;

public class SimpleQueue implements Iterable {
    private LinkedList storage = new LinkedList();
    public void add(T t){
        storage.offer(t);
    }
    public T get() {
        return storage.poll();
    }
    public Iterator iterator() {
        return storage.iterator();
    }

    public static void main(String[] args) {
        SimpleQueue queue = new SimpleQueue();
        queue.add(8);
        System.out.println(queue.get());
    }
}

我們在來看看用Stack如何實現Queue，非常不錯，《Java編程思想》

import java.util.Stack;

 public class MyQueue{
    Stack stack = new Stack();
    Stack stackTmp = new Stack();

    //Push element X to the back of queue
    public void push(int x) {
        stack.push(x);
    }

    //Removes the element form in front of queue
    public void pop() {
        if (stackTmp.isEmpty()) {
            while (!stack.isEmpty()) {
                int tmp = stack.peek();
                stackTmp.push(tmp);
                stack.pop();
            }
        }
        else {
            stackTmp.pop();
        }
    }

    //Get the front element
    public int peek() {
        if (!stackTmp.isEmpty()) {
            int tmp = stack.peek();
            stackTmp.push(tmp);
        }
        return stackTmp.peek();
    }

    //Return whether the queueis empty
    public boolean empty() {
        if (stackTmp.isEmpty() && stack.isEmpty()) {
            return true;
        }else {
            return false;
        }
    }

    public static void main(String[] args) {
        MyQueue queue = new MyQueue();
        queue.push(8);
        System.out.println(queue.empty());     //false
    }
}

樹，也是一種數據結構，非線性的，這種結構內的元素存在一對多的關系。

樹，尤其是二叉樹應用很廣泛，排序二叉樹，平衡二叉樹，紅黑樹。

二叉樹，在普通的樹的基礎上，讓一顆樹中每個節點最多只能包含兩個子節點，且嚴格區分左子節點和右子節點(位置不能變化)
-遍歷二叉樹，考慮深讀，優先遍歷。(先序遍歷、中序遍歷、后續遍歷)和廣度優先遍歷。

哈夫曼樹，一種帶權路徑最短的二叉樹，在信息檢索中非常有用

哈夫曼編碼，假設需要對一個字符串如“abcabcabc”進行編碼，將它轉化為唯一的二進制碼，同時要求轉換出來的二進制碼的長度最小。可以采用哈夫曼樹來解決報文編碼問題

排序二叉樹：一種特殊的二叉樹，可以非常方便的對樹中的所有節點進行排序和檢索。

二叉樹，這里采用遞歸和內部類的思想。

public class BinaryTree {
    private Node root;

    //添加節點
    public void add(int data) {
        if (root ==null) {
            root = new Node(data);
        }else {
            root.addNode(data);
        }
    }
    //打印節點
    public void print() {
        root.printNode();
    }

    private class Node {
        private int data;
        private Node left;
        private Node right;

        public Node(int data) {
            this.data = data;
        }

        public void addNode(int data) {
            //核心思想就是進來先個當前節點比，如果如果小于則在左邊添加，如果左邊沒子節點，則創建，如果有添加
            if (this.data > data) {
                if (this.left == null) {
                    this.left = new Node(data);
                }else {
                    this.addNode(data);    //這里應該是采用遞歸。
                }
            }else {
                if (this.right == null) {
                    this.right = new Node(data);
                }else {
                    this.right.addNode(data);
                }
            }
        }

        //中序遍歷
        public void printNode() {
            if (this.left != null) {
                this.left.printNode();
            }
            System.out.println(this.data + "->");
            if (this.right !=null) {
                this.right.printNode();
            }
        }
    }
}
------------------------測試-----------------------------------------------
public static void main(String[] args) {

  BinaryTree bt = new BinaryTree();
  // 8、3、10、1、6、14、4、7、13
  bt.add(8);bt.add(3);bt.add(10);
  bt.add(1);bt.add(6);bt.add(14);
  bt.add(4);bt.add(7);bt.add(13);
  bt.print();
}
輸出：
1->3->4->6->7->8->10->13->14->

ArrayList因為亂碼，寫了一半，無奈啊，完全坑我，其思想就是根據索引，涉及到擴容，判斷越界了么，。這里先不管了。直接看LinkedList。

public class MyLinkedList {
    protected Node first;    // 鏈表的第一個節點
    protected Node last;    // 鏈表的最后一個節點
    private int size;    // 節點的數量

    // 鏈表中的每一個節點
    public class Node {
        public Node(Object ele) {
            this.ele = ele;
        }

        Node prev;                // 上一個節點對象
        Node next;                // 下一個節點對象
        public Object ele; // 當前節點中存儲的數據
    }

    public void addFirst(Object ele) {
        Node node = new Node(ele);      //需要保存的節點對象
        //進來一個節點，如果為空的話，它可定時第一個，也是最后一個
        if (size == 0) {
            this.first = node;
            this.last = node;
        }else {
            node.next = this.first;                // 把之前第一個作為新增節點的下一個節點，(進來一個，當前的只能當老二了。)
            this.first.prev = node;                // 把新增節點作為之前第一個節點的上一個節點
            this.first = node;                    // 把新增的節點作為第一個節點
        }
        size++;
  }
     //這里很重要，別忘記
    public void addLast(Object ele) {
        Node node = new Node(ele);
        if (size == 0) {
            this.first = node;
            this.last = node;
        }else {
            this.last.next = node;            // 新增節點作為之前最后一個節點的下一個節點(因為是加在后面，所以當前節點的下一個才是 新增節點)
            node.prev = this.last;            // 之前最后一個節點作為新增節點的上一個節點
            this.last = node;                // 把新增的節點作為最后一個節點
        }
    }
    //原諒我復制了
    public void remove(Object ele) {
        // 找到被刪除的節點
        Node current = this.first;// 確定為第一個節點,從頭到尾開始找
        for (int i = 0; i < size; i++) {
            if (!current.ele.equals(ele)) {// 當前為true !true 為false ,說明找到當前ele,輸出
                if (current.next == null) { // 續上: 如果false取反為true, 判斷是否最后一個,
                    return;
                }
                current = current.next;
            }
        }
        //刪除節點
        if(current==first){
            this.first = current.next; //當前的下一個作為第一個
            this.first.prev = null; //當前下一個對上一個的引用設置為null

        }else if(current==last){
            this.last = current.prev;
            this.last.next = null;
        }else{
            //把刪除當前節點的下一個節點作為刪除節點的上一個節點的next
            current.prev.next =current.next;
            //把刪除節點的上一個節點作為刪除節點下一個節點的prev
            current.next.prev = current.prev;

        }
        size--;
        //System.out.println("current =" + current.ele);
    }

    public String toString() {
        if (size == 0) {
            return "[]";
        }
        StringBuilder sb = new StringBuilder(size * 2 + 1);
        Node current = this.first;// 第一個節點
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(current.ele);
            if (i != size - 1) {
                sb.append(",");
            } else {
                sb.append("]");
            }
            current = current.next; // 獲取自己的下一個節點
        }
        return sb.toString();
    }
}

這個雙向列表有點難理解，還是看圖吧，

線性鏈表：

雙向鏈表：

先到這里吧，gogogo，機會是留給有準備的人，