資料結構在Android中也有著大量的運用，這裡採用資料結構與原始碼分析相結合，來認識Android的資料結構

線性表

線性表可分為順序儲存結構和鏈式儲存結構

順序儲存結構-ArrayList

通過對原始碼的產看得知，ArrayList繼承自AbstractList，實現了多個介面，其中List裡面就實現了常用的一些操作，包括增刪改查清除大小等等

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    ···
}
 

ArrayList的實現其實就是基於陣列，而且可以得知ArrayList的初始長度為10，資料進行了反序列化：transient

private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
transient Object[] elementData;
private int size;

可以知道，ArrayList的資料初始化是在構造方法中完成的

public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
}

public ArrayList() {
    super();
    this.elementData = EMPTY_ELEMENTDATA;
}

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    size = elementData.length;
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
}
 

首先看一看add方法

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

這裡的ensureCapacityInternal()方法比較重要，來看看這個方法都做了什麼

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}
 

這裡得到了最小需要的ArrayList大小，然後呼叫了ensureExplicitCapacity()，這裡有一個modCount變數，用來記錄元素的情況

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

這裡做了判斷，如果當前大小小於所需大小，那麼就呼叫grow()方法，ArrayList之所以能到增長，其實現位置就在這裡

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

這裡獲取了元素的個數，然後計算新的個數，其增量是原個數的一半，然後得到其符合的值，如果需要的個數大於規定的最大值(Integer.MAX_VALUE - 8)，那麼就將其大小設定為Integer.MAX_VALUE或者Integer.MAX_VALUE - 8，

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

到這裡就已經將其長度增大了，再將原資料複製到新的陣列，然後回到add方法，得知這時候將新增的元素放到之前最後面的位置elementData[size++] = e;，這樣就實現了ArrayList資料的新增
其餘方法和add方法類似，比如remove就是將元素置空，然後讓GC去回收

public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

ArrayList的迭代器，用來遍歷元素，迭代器裡面的增加刪除操作也和ArrayList的增加刪除一樣，需要對size進行操作
至此，ArrayList的簡單解讀就完成了

鏈式儲存結構-LinkedList

在Android中的鏈式儲存結構，就是使用雙向連結串列實現的，有一個內部類Node，用來定義節點，初始化的時候是頭節點指向尾節點，尾節點指向頭節點

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

其繼承了AbstractSequentialList，並實現了一系列介面，可以看到不僅實現了List還實現了Deque雙端佇列

public class LinkedList<E> extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
    ···
}

定義的變數主要有三個，首節點，尾節點和大小

transient int size = 0;
transient Node<E> first;
transient Node<E> last;

首先依舊是檢視add方法的操作

public boolean add(E e) {
    linkLast(e);
    return true;
}

這裡呼叫了linkLast()方法，而這個方法是從尾部新增元素

void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

還可以在指定位置新增元素，首先會檢查新增位置是否合法，合法的意思就是index >= 0 && index <= size，如果插入的位置是末尾，那麼就是尾插法，如果不是末尾，就呼叫linkBefore()

public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

會先呼叫node方法，得到指定位置的node，這裡從中間開始查詢，使得效率得到提高
這個思想在remove，set等裡面都有使用到，這也是使用雙向連結串列的原因，LinkedHashMap也是採用的雙向連結串列

Node<E> node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

然後在指定node位置之前插入元素

void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

其他的方法與add類似，主要就是後繼和前驅的指向，以及插入位置的考量

ArrayList與LinkedList比較

ArrayList屬於順序儲存，LinkedList屬於鏈式儲存
ArrayList的刪除和插入效率低，查詢效率高，而LinkedList則剛好相反
在實際使用中要根據具體使用情況選擇

棧和佇列

棧和佇列是兩種不同讀取方式的資料結構，棧屬於先進後出，而佇列屬於先進先出，要比喻的話，棧好比一個瓶子，先放進去的要最後才能取出來，佇列還比就是一根管子，先進去的先出來，在Android中有著這兩種資料結構思想的實現類

棧

這裡就是Stack這個類，由於程式碼不多，直接全部貼出來

public
class Stack<E> extends Vector<E> {

    public Stack() {
    }

    public E push(E item) {
        addElement(item);

        return item;
    }

    public synchronized E pop() {
        E       obj;
        int     len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }

    public synchronized E peek() {
        int     len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

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

    public synchronized int search(Object o) {
        int i = lastIndexOf(o);

        if (i >= 0) {
            return size() - i;
        }
        return -1;
    }

    private static final long serialVersionUID = 1224463164541339165L;
}

可以看到有push()，pop()，peek()，empty()，search()方法，其中pop和peek的區別在於前者會刪除元素，而後者不會，後者只是檢視元素，那麼其具體實現是怎麼樣的呢，這就在其父類Vextor中有所體現，檢視原始碼，其實和ArrayList基本上是一致的，無論是思想還是實現，在細微處有小區別，Vextor的擴容方式允許單個擴容，所以說Android中的棧實現是基於順序連結串列的，push是新增元素，search是查詢元素，從棧頂向棧底查詢，一旦找到返回位置，pop和peek都是檢視元素
另外，LinkedList也實現了棧結構

public void push(E e) {
    addFirst(e);
}

而addFirst()則是呼叫了linkFirst()方法，也就是採用了頭插法

public void addFirst(E e) {
    linkFirst(e);
}

那麼pop也應該是使用頭部刪除，果不其然

public E pop() {
    return removeFirst();
}

佇列

佇列也分為順序結構實現和鏈式結構實現，但前者由於出隊複雜度高0(n)，容易假溢位，雖然可以通過首尾相連解決假溢位，這也就是迴圈佇列，但實際中，基本是使用鏈式儲存實現的，有一個介面就是佇列的模型

public interface Queue<E> extends Collection<E> {
    boolean add(E e);
    boolean offer(E e);
    E remove();
    E poll();
    E element();
    E peek();
}

而在LinkedList實現了Deque介面，而Deque又是Queue的子類，故而之前的分析已經包含了佇列
那麼這次聚焦在Queue上，看看其都多是怎麼做的
前面的分析我們已經知道了add方法呼叫的是linkLast()，也就是使用尾插法，那麼offer方法呢

public boolean offer(E e) {
    return add(e);
}

可以看到offer()呼叫了add()，再看看剩下的方法，主要是remove方法

public E remove() {
    return removeFirst();
}

移除的是首位置，而新增的是尾（與佇列隊尾插入一致）

public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

public E peek() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}

poll返回的也是首位置，peek也是（與佇列隊頭取出一致）

public E element() {
    return getFirst();
}

element()返回首節點

HashMap與LinkedHashMap

這兩個嚴格來說不算資料結構，這裡將其提取出來，是因為這兩個在Android中有著廣泛運用

HashMap

首先看一下繼承類和實現介面，AbstractMap實現了Map裡面的絕大部分方法，只有eq沒有實現

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    ···
}

大概看一下其結構，依舊是掃一眼內部類，其主要包括以下四類
HashMapEntry：一個個的鍵值對，其在Android中為hide，提供了包括Key的獲取，Value的設定獲取，比較等方法，注意這是一個節點，也就是說這也是通過連結串列組織起來的，不過這個連結串列屬於雜湊連結串列
XxxIterator：HashIterator，ValueIterator，KeyIterator，EntryIterator，今三個迭代器繼承自第一個，用來獲取相應的值
XxxSpliterator：HashMapSpliterator，KeySpliterator，ValueSpliterator，EntrySpliterator
XxxSet：KeySet，EntrySet，另外Value類也與其類似，不過沒有使用Set，這也就是為何value可以重複而key不能重複的原因，這是用來記錄值的集合

大致知道內部類的功能及其作用以後，就該看一看其成員變量了

static final int DEFAULT_INITIAL_CAPACITY = 4;
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final HashMapEntry<?,?>[] EMPTY_TABLE = {};
transient HashMapEntry<K,V>[] table = (HashMapEntry<K,V>[]) EMPTY_TABLE;
transient int size;
int threshold;
final float loadFactor = DEFAULT_LOAD_FACTOR;
transient int modCount;

首先是初始化大小為4，也就是說HashMap自建立開始就有4的容量，其最大容量為2³⁰，預設增長係數為0.75，也就是說其儲存容量達到總容量的75%時候，會自動擴容另外還定義了鍵值對，大小等

那麼接下來輪到構造方法了

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY) {
        initialCapacity = MAXIMUM_CAPACITY;
    } else if (initialCapacity < DEFAULT_INITIAL_CAPACITY) {
        initialCapacity = DEFAULT_INITIAL_CAPACITY;
    }

    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    threshold = initialCapacity;
    init();
}

public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}

public HashMap(Map<? extends K, ? extends V> m) {
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                  DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
    inflateTable(threshold);

    putAllForCreate(m);
}

簡單來說就是將設定的成員變數初始化，這裡的init()為一個空方法

與上面分析線性表的思路一樣，我們先看新增元素的方法put()

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key);
    int i = indexFor(hash, table.length);
    for (HashMapEntry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

我們來詳細分析一下在這裡面到底做了啥，首先要保證table不為空，然後如果key為空，那麼就儲存NullKey的value，那麼這是怎麼操作的呢，在putForNullKey()我們可以看到，這裡使用了addEntry(0, null, value, 0);，也就是說在HashMap裡面是可以存null鍵的，不過最多隻能存一個，後面的會覆蓋掉前面的，就下來計算了hash值，在indexFor()裡面就一句話return h & (length-1);，這裡是獲取到其索引值，這個索引值用來建立散列表的索引，關於散列表，使用一張百度百科的圖來說明

for迴圈裡面，會遍歷整個table，如果hash值和key都相同，那麼會覆蓋之前的key，並返回那個key所對應的值，也就是說此時是沒有新增成功的，那麼在hash值不等或者key不等的情況下，會呼叫addEntry()方法，向散列表中新增，然後返回null

那麼在addEntry()裡面也就是新增元素的方法了

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? sun.misc.Hashing.singleWordWangJenkinsHash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }

    createEntry(hash, key, value, bucketIndex);
}

在這裡，計算了大小，如果容量不足，那麼容量變為原來的兩倍，也就是說HashMap的大小為2的整次冪，同時重新計算hash和index，那麼接下來就是真正新增元素的地方了

那麼我們繼續看元素是怎麼被新增的吧

void createEntry(int hash, K key, V value, int bucketIndex) {
    HashMapEntry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new HashMapEntry<>(hash, key, value, e);
    size++;
}

這裡傳入新值，並且完成了連結串列的指向，增加了size的大小，整個新增的流程就完成了
這是插在陣列元素位置的，後面連線起來

接下來看一看get()方法

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    Entry<K,V> entry = getEntry(key);

    return null == entry ? null : entry.getValue();
}

這裡可以看出，可以取key為null的value，然後呼叫getEntry()查詢Entry

final Entry<K,V> getEntry(Object key) {
    if (size == 0) {
        return null;
    }

    int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
    for (HashMapEntry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

這裡根據key計算出hash，然後再計算出index，去響應的table查詢匹配的HashMapEntry，找到則返回，沒找到返回空
然後判斷entry是否為null，為null返回null，不為空則返回value值

LinkedHashMap

LruCache類使用到了LinkedHashMap，那麼LinkedHashMap是怎麼實現知道新舊新增的元素的呢
LinkedHashMap本身繼承了HashMap，但是在資料結構上稍有不同，HashMap使用的是雜湊單向連結串列，而LinkedHashMap使用的是雜湊雙向迴圈連結串列

private static class LinkedHashMapEntry<K,V> extends HashMapEntry<K,V> {
    LinkedHashMapEntry<K,V> before, after;

    LinkedHashMapEntry(int hash, K key, V value, HashMapEntry<K,V> next) {
        super(hash, key, value, next);
    }

    private void remove() {
        before.after = after;
        after.before = before;
    }

    private void addBefore(LinkedHashMapEntry<K,V> existingEntry) {
        after  = existingEntry;
        before = existingEntry.before;
        before.after = this;
        after.before = this;
    }

    void recordAccess(HashMap<K,V> m) {
        LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
        if (lm.accessOrder) {
            lm.modCount++;
            remove();
            addBefore(lm.header);
        }
    }

    void recordRemoval(HashMap<K,V> m) {
        remove();
    }
}

這裡主要看get()方法

public V get(Object key) {
    LinkedHashMapEntry<K,V> e = (LinkedHashMapEntry<K,V>)getEntry(key);
    if (e == null)
        return null;
    e.recordAccess(this);
    return e.value;
}

注意到這裡呼叫了recordAccess()，而這個方法的實現就比較有意思了

void recordAccess(HashMap<K,V> m) {
    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
    if (lm.accessOrder) {
        lm.modCount++;
        remove();
        addBefore(lm.header);
    }
}

這裡的if判斷條件，我們回到LruCache，發現在給map初始化的時候，傳遞的引數為new LinkedHashMap<K, V>(0, 0.75f, true)，也就是說這裡的accessOrder為真，真的意思就是要按照新舊排序，這裡呼叫了remove，那麼在remove裡面做了啥呢

private void remove() {
    before.after = after;
    after.before = before;
}

可以看到，在這個方法裡面就是將當前元素斷鏈了
然後還呼叫了addBefore()方法，這又是為何

private void addBefore(LinkedHashMapEntry<K,V> existingEntry) {
    after  = existingEntry;
    before = existingEntry.before;
    before.after = this;
    after.before = this;
}

這裡將斷鏈的節點放到最末尾，然後和頭節點連起來了，那麼這樣每次get()的元素都會到最末尾，header的after就是最老的和最不常用的節點了，在LruCache自動釋放記憶體時就是從這開始釋放的，保證常用常駐
那麼接下來再看看put方法，這裡可以看到只是繼承了HashMap的get方法，那麼在哪裡修改新增的呢

void addEntry(int hash, K key, V value, int bucketIndex) {
    LinkedHashMapEntry<K,V> eldest = header.after;
    if (eldest != header) {
        boolean removeEldest;
        size++;
        try {
            removeEldest = removeEldestEntry(eldest);
        } finally {
            size--;
        }
        if (removeEldest) {
            removeEntryForKey(eldest.key);
        }
    }

    super.addEntry(hash, key, value, bucketIndex);
}

可以看見這裡重寫了addEntry()方法，但裡面並沒有具體的建立，在這裡的removeEldestEntry()也是直接返回false了
所以又重寫了createEntry()

void createEntry(int hash, K key, V value, int bucketIndex) {
    HashMapEntry<K,V> old = table[bucketIndex];
    LinkedHashMapEntry<K,V> e = new LinkedHashMapEntry<>(hash, key, value, old);
    table[bucketIndex] = e;
    e.addBefore(header);
    size++;
}

可以看到這裡也呼叫了addBefore()，也是加在了最後面，也就與header.before連線起來了
綜合分析得出結論：LinkedHashMap不斷調整元素位置，使得header.after為最不常用或者最先加入的元素，方便刪除的時候直接移除

樹

樹當中，研究最多的就是二叉樹

二叉樹

二叉樹的性質：
性質1：在二叉樹的第i層上至多有2^i-1個結點（i>=1）
性質2：深度為k的二叉樹至多有2^k-1個結點（k>=1）
性質3：對任何一顆二叉樹T，如果其終端結點數為n₀,度為2的結點數為n₂，則n₀ = n₂+1
性質4：具有n個結點的完全二叉樹深度為[log₂n]+1 ([x]表示不大於x的最大整數)
性質5：如果對一顆有n個結點的完全二叉樹（其深度為[log₂(n+1)]）的結點按層序編號（從第1層到第[log₂(n+1)]層，每層從左到右），對任意一個結點i(1<=i<=n)有：
1）.如果i=1,則結點i是二叉樹的根，無雙親；如果i>1,則其雙親是結點[i/2]
2）.如果2i>n,則結點i無左孩子（結點i為葉子結點）；否則其左孩子是結點2i
3）.如果2i+1>n,則結點i無右孩子；否則其右孩子是結點2i+1

二叉樹高度和節點數

• 二叉樹的高度

public int getHeight(){
    return getHeight(root);
}
private int getHeight(TreeNode node) {
    if(node == null){
        return 0;
    }else{
        int i = getHeight(node.leftChild);
        int j = getHeight(node.rightChild);
        return (i < j) ? j + 1 : i + 1;
    }
}

• 二叉樹的結點數

public int getSize(){
    return getSize(root);
}
private int getSize(TreeNode node) {
    if(node == null){
        return 0;
    }else{
        return 1 + getSize(node.leftChild) + getSize(node.rightChild);
    }
}

二叉樹的遍歷

• 前序遍歷
  規則是若二叉樹為空，則空操作返回，否則先訪問跟結點，然後前序遍歷左子樹，再前序遍歷右子樹

public void preOrder(TreeNode node){
    if(node == null){
        return;
    }else{
        System.out.println("preOrder data:" + node.getData());
        preOrder(node.leftChild);
        preOrder(node.rightChild);
    }
}

• 中序遍歷
  規則是若樹為空，則空操作返回，否則從根結點開始（注意並不是先訪問根結點），中序遍歷根結點的左子樹，然後是訪問根結點，最後中序遍歷右子樹

public void midOrder(TreeNode node){
    if(node == null){
        return;
    }else{
        midOrder(node.leftChild);
        System.out.println("midOrder data:" + node.getData());
        midOrder(node.rightChild);
    }
}

• 後序遍歷
  規則是若樹為空，則空操作返回，否則從左到右先葉子後結點的方式遍歷訪問左右子樹，最後是訪問根結點

public void postOrder(TreeNode node){
    if(node == null){
        return;
    }else{
        postOrder(node.leftChild);
        postOrder(node.rightChild);
        System.out.println("postOrder data:" + node.getData());
    }
}

• 層序遍歷
  規則是若樹為空，則空操作返回，否則從樹的第一層，也就是根結點開始訪問，從上而下逐層遍歷，在同一層，按從左到右的順序對結點逐個訪問

生成二叉樹

public TreeNode createBinaryTree(int size, ArrayList<String> datas) {
    if(datas.size() == 0) {
        return null;
    }
    String data = datas.get(0);
    TreeNode node;
    int index = size - datas.size();
    if(data.equals("#")) {
        node = null;
        datas.remove(0);
        return node;
    }
    node = new TreeNode(index, data);
    if(index == 0) {
        root = node;
    }
    datas.remove(0);
    node.leftChild = createBinaryTree(size, datas);
    node.rightChild = createBinaryTree(size, datas);
    return node;
}

查詢二叉樹(搜尋二叉樹)

在二叉樹中，左節點小於根節點，有節點大於根節點的的二叉樹成為查詢二叉樹，也叫做搜尋二叉樹

public class SearchBinaryTree {
    
    public static void main(String[] args) {
        SearchBinaryTree tree = new SearchBinaryTree();
        int[] intArray = new int[] {50, 27, 30, 60, 20, 40};
        for (int i = 0; i < intArray.length; i++) {
            tree.putTreeNode(intArray[i]);
        }
        tree.midOrder(root);
    }
    
    private static TreeNode root;
    public SearchBinaryTree() {}
    
    //建立查詢二叉樹，新增節點
    public TreeNode putTreeNode(int data) {
        TreeNode node = null;
        TreeNode parent = null;
        if (root == null) {
            node = new TreeNode(0, data);
            root = node;
            return root;
        }
        node = root;
        while(node != null) {
            parent = node;
            if(data > node.data) {
                node = node.rightChild;
            }else if(data < node.data) {
                node = node.leftChild;
            }else {
                return node;
            }
        }
        //將節點新增到相應位置
        node = new TreeNode(0, data);
        if(data < parent.data) {
            parent.leftChild = node;
        }else {
            parent.rightChild = node;
        }
        node.parent = parent;
        return root;
    }
    
    //驗證是否正確
    public void midOrder(TreeNode node){
        if(node == null){
            return;
        } else {
            midOrder(node.leftChild);
            System.out.println("midOrder data:" + node.getData());
            midOrder(node.rightChild);
        }
    }
    
    class TreeNode{
        private int key;
        private int data;
        private TreeNode leftChild;
        private TreeNode rightChild;
        private TreeNode parent;
        public TreeNode(int key, int data) {
            super();
            this.key = key;
            this.data = data;
            leftChild = null;
            rightChild = null;
            parent = null;
        }
        public int getKey() {
            return key;
        }
        public void setKey(int key) {
            this.key = key;
        }
        public int getData() {
            return data;
        }
        public void setData(int data) {
            this.data = data;
        }
        public TreeNode getLeftChild() {
            return leftChild;
        }
        public void setLeftChild(TreeNode leftChild) {
            this.leftChild = leftChild;
        }
        public TreeNode getRightChild() {
            return rightChild;
        }
        public void setRightChild(TreeNode rightChild) {
            this.rightChild = rightChild;
        }
        public TreeNode getParent() {
            return parent;
        }
        public void setParent(TreeNode parent) {
            this.parent = parent;
        }
    }
}

刪除節點

//刪除節點
public void deleteNode(int key) throws Exception {
    TreeNode node = searchNode(key);
    if(node == null) {
        throw new Exception("can not find node");
    }else {
        delete(node);
    }
}

private void delete(TreeNode node) throws Exception {
    if(node == null) {
        throw new Exception("node is null");
    }
    TreeNode parent = node.parent;
    //刪除的節點無左右節點
    if(node.leftChild == null && node.rightChild == null) {
        if(parent.leftChild == node) {
            parent.leftChild = null;
        }else {
            parent.rightChild = null;
        }
        return;
    }
    //被刪除的節點有左節點無右節點
    if(node.leftChild != null && node.rightChild == null) {
        if(parent.leftChild == node) {
            parent.leftChild = node.leftChild;
        }else {
            parent.rightChild = node.leftChild;
        }
        return;
    }
    //被刪除的節點無左節點有右節點
    if(node.leftChild == null && node.rightChild != null) {
        if(parent.leftChild == node) {
            parent.leftChild = node.rightChild;
        }else {
            parent.rightChild = node.rightChild;
        }
        return;
    }
    //被刪除節點既有左結點又有右節點
    TreeNode next = getNextNode(node);
    delete(next);
    node.data = next.data;
}

private TreeNode getNextNode(TreeNode node) {
    if(node == null) {
        return null;
    }
    if(node.rightChild != null) {
        return getMinTreeNode(node.rightChild);
    }else {
        TreeNode parent = node.parent;
        while(parent != null && node == parent.rightChild) {
            node = parent;
            parent = parent.parent;
        }
        return parent;
    }
}

//找某節點的最小關鍵節點
private TreeNode getMinTreeNode(TreeNode node) {
    if(node == null) {
        return null;
    }
    while(node.leftChild != null) {
        node = node.leftChild;
    }
    return node;
}

private TreeNode searchNode(int key) {
    TreeNode node = root;
    if(node == null) {
        return null;
    }
    while(node != null && key != node.data) {
        if(key < node.data) {
            node = node.leftChild;
        }else {
            node = node.rightChild;
        }
    }
    return node;
}

圖

圖(Graph)是由頂點的有窮非空集合和頂點之間邊的集合組成，通常表示為：G(V,E)，其中G表示一個圖，V是圖G中定點的集合，E是圖G中邊的集合
圖中的資料元素稱之為頂點，任意兩個頂點之間都可能有關係，頂點之間的邏輯關係用邊來表示，邊集可以為空

無向圖和有向圖

• 無向圖
  無向邊：若頂點v_i到v_j之間的邊沒有方向，則稱這條邊為無向邊(Edge)，用無序偶對(v_i,v_j)來表示，如果圖中任意兩個頂點之間的邊都是無向邊，則稱該圖為無向圖(Undirected Graphs)
  在無向圖中，如果任意兩個頂點之間的邊都存在，那麼該圖稱為無向完全圖
  
• 有向圖
  有向邊：若頂點v_i到v_j的邊有方向，則稱這條邊為有向邊，也稱之為弧(Arc)，用有序偶對<v_i,v_j>來表示，如果圖中任意兩個頂點之間的邊都是有向邊，則稱該圖為有向圖(Directed Graphs)
  在有向圖中，如果任意兩個頂點之間都存在方向互為相反的兩條弧，那麼該圖稱為有向完全圖
  

圖的權

有些圖的邊或者弧具有與他相關的數字，這種與圖的邊或弧相關的數叫做權

連通圖

在無向圖G中，如果從頂點v到頂點v^'有路徑，則稱v和v^'是連通的，如果對於圖中任意兩個頂點v_i,v_j∈E，v_i和v_j都是連通的，則稱G是連通圖(Connected Graph)

度

無向圖頂點的邊數叫度，有向圖頂點的邊數叫出度和入度

圖的儲存結構

鄰接矩陣
圖的鄰接矩陣(Adjacency Matrix)儲存方式是用兩個陣列來表示圖，一個一維陣列儲存圖中的頂點資訊，一個二維陣列(稱為鄰接矩陣)儲存圖中的-邊或弧資訊

• 鄰接矩陣
  
  
• 帶權鄰接矩陣
  
• 浪費的鄰接矩陣
  

鄰接表
講到了一種孩子表示法，將結點存入陣列，並對結點的孩子進行鏈式儲存，不管有多少孩子，也不會存在空間浪費問題，這個思路同樣適用於圖的儲存。我們把這種陣列與連結串列相結合的儲存方法稱為鄰接表

• 無向圖的鄰接表：
  
• 有向圖的鄰接表:
  
• 有向圖的逆鄰接表
  
• 帶權值鄰接表
  

鄰接矩陣的程式碼實現(Java)

public class Graph {
    private int vertexSize; //頂點數量
    private int[] vertexs; //頂點陣列
    private int[][] matrix; //邊陣列
    private static final int MAX_WEIGHT = 1000; //非連線頂點權值
    
    public Graph(int vertexSize) {
        this.vertexSize = vertexSize;
        this.vertexs = new int[vertexSize];
        this.matrix = new int[vertexSize][vertexSize];
        //頂點初始化
        for (int i = 0; i < vertexSize; i++) {
            vertexs[i]= i; 
        }
    }
    
    //計算某頂點出度
    public int getOutDegree(int index) {
        int degree = 0;
        for (int i = 0; i < matrix[index].length; i++) {
            int weight = matrix[index][i];
            if(weight != 0 && weight != MAX_WEIGHT) {
                degree++;
            }
        }
        return degree;
    }
    
    //獲取兩頂點之間的權值
    public int getWeight(int v1, int v2) {
        int weight = matrix[v1][v2];
        return weight == 0 ? 0 : (weight == MAX_WEIGHT ? -1 : weight);
    }

    public static void main(String[] args) {
        Graph graph = new Graph(5);
        int[] a1 = new int[] {0,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,6};
        int[] a2 = new int[] {9,0,3,MAX_WEIGHT,MAX_WEIGHT};
        int[] a3 = new int[] {2,MAX_WEIGHT,0,5,MAX_WEIGHT};
        int[] a4 = new int[] {MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,0,1};
        int[] a5 = new int[] {MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,0};
        graph.matrix[0] = a1;
        graph.matrix[1] = a2;
        graph.matrix[2] = a3;
        graph.matrix[3] = a4;
        graph.matrix[4] = a5;
        int degree = graph.getOutDegree(0);
        int weight = graph.getWeight(2, 0);
        System.out.println("degree:" + degree);
        System.out.println("weight:" + weight);
    }
}

圖的遍歷

圖的遍歷和樹的遍歷類似，從某一頂點出發遍歷圖中其餘頂點，且使得每個頂點有且只有一次訪問，這一過程叫做圖的遍歷

深度優先遍歷

深度優先遍歷(Depth_First_Search)，也稱為深度優先搜素，簡稱DFS

他從圖中某個頂點v出發，訪問此頂點，然後從v的未被訪問的鄰接點出發深度優先遍歷圖，直到圖中所有和v有路徑相通的頂點都被訪問到
下面是深度優先遍歷的虛擬碼(C)

typedef int Boolean;
Boolean visited[Max];
void DFS(MGraph G,int i){
    int j;
    visited[i] = TRUE;
    printf("%c", G.vexs[i]);
    for(j = 0; j < G.numVertexes; j++){
        if(G.arc[i][j] == 1&&!visited[j]){
            DFS(G,j);
        }
    }
}
void DFSTraverse(MGraph G){
    int i;
    for(i = 0 ;i<G.numVertexes;i++){
        visited[i] = FALSE;
    }
    for(i = 0; i < G.numVertexes; i++){
        if(!visited[i]){
            DFS(G,i);
        }
    }
}

有了思路就可以寫出Java程式碼了

private boolean[] isVisited; //是否遍歷過

//獲取某個頂點的連線點:其實就是遍歷一行，獲取不為零且不為MAX_WEIGHT的第一個位置
public int getFirstNeighbor(int v) {
    for (int j = 0; j < vertexSize; j++) {
        if(matrix[v][j] > 0 && matrix[v][j] < MAX_WEIGHT) {
            return j;
        }
    }
    return -1;
}

//根據前一個鄰接點的下標獲得下一個鄰接點:就是找到一行中第二個有意義的位置
//v代表要找的頂點，也就是要找的那一行，index代表從這個位置往後開始找
private int getNextNeighbor(int v, int index) {
    for (int j = index + 1; j < vertexSize; j++) {
        if(matrix[v][j] > 0 && matrix[v][j] < MAX_WEIGHT) {
            return j;
        }
    }
    return -1;
}

//圖的深度優先遍歷
private void depthFirstSearch(int v) {
    System.out.println("訪問 " + v + " 頂點");
    isVisited[v] = true;
    int w = getFirstNeighbor(v);
    while(w != -1) {
        if(!isVisited[w]) {
            //遍歷該節點
            depthFirstSearch(w);
        }
        w = getNextNeighbor(v, w);
    }
}

//深度優先遍歷呼叫:直接使用depthFirstSearch(i)會造成有些頂點可能無法被訪問
public void depthFirstSearch() {
    isVisited = new boolean[vertexSize];
    for (int i = 0; i < vertexSize; i++) {
        if(!isVisited[i]) {
            depthFirstSearch(i);
        }
    }
    isVisited = new boolean[vertexSize];
}

廣度優先遍歷

廣度優先遍歷類似於樹的層序遍歷，一級一級直到遍歷結束
廣度優先遍歷一般採用佇列儲存頂點
下面是廣度優先遍歷的虛擬碼

//鄰接矩陣的廣度遍歷演算法
void SFSTraverse(MGraph G)
{
    int i, j;
    Queue Q;
    for (int i = 0; i < G.numVertexes; i ++)
    {
        visited[i] = FALSE;
    }
    InitQueue(&Q); //初始化輔助佇列
    for (i = 0; i < G.numVertexes; i++) //對每個頂點做迴圈
    {
        if (!visited[i]) //若是為訪問過就處理
        {
            visited[i] = TRUE; //設定當前頂點已訪問過
            printf("%c", G.vexs[i]); //列印頂點
            EnQueue(&Q, i); //頂點入佇列
            while (!QueueEmpty(Q)) //佇列不為空
            {
                DeQueue(&Q, &i); //佇列元素出列，賦值給i
                for (int j = 0; j < G.numVertexes; j++)
                {
                    //判斷其他頂點若與當前頂點存在邊且未訪問過
                    if (G.arc[i][j] == 1 && !visited[j])
                    {
                        visited[j] = TRUE; //設定當前頂點已訪問過
                        printf("%c", G.vexs[j]); //列印頂點
                        EnQueue(&Q, j); //頂點入佇列
                    }
                }
            }
        }
    }
}

有了思想就很容易寫出java程式碼了

//圖的廣度優先遍歷
public void broadFirstSearch(int v) {
    int u,w;
    LinkedList<Integer> queue = new LinkedList<>();
    System.out.println("訪問 " + v + " 頂點");
    isVisited[v] = true;
    queue.add(v);
    while(!queue.isEmpty()) {
        u = (Integer)(queue.removeFirst()).intValue();
        w = getFirstNeighbor(u);
        while(w != -1) {
            if(!isVisited[w]) {
                System.out.println("訪問 " + w + " 頂點");
                isVisited[w] = true;
                queue.add(w);
            }
            w = getNextNeighbor(u, w);
        }
    }
}

//廣度優先遍歷，和深度遍歷一樣，可能存在訪問不到的位置
public void broadFirstSearch() {
    isVisited = new boolean[vertexSize];
    for (int i = 0; i < vertexSize; i++) {
        if(!isVisited[i]) {
            broadFirstSearch(i);
        }
    }
}

最小生成樹

問題引出

解決方案

一個連通圖的生成樹是一個極小的連通子圖，它含有圖中全部的頂點，但只有足以構成一棵樹的n-1條邊。我們把構造連通網的最小代價生成樹。稱為最小生成樹
找連通網的最小生成樹，經典的有兩種演算法，普里姆演算法和克魯斯卡爾演算法

普里姆演算法

先構造鄰接矩陣

普里姆演算法的C語言實現

void MiniSpanTree_Prim(MGraph G){
    int min, i, j, k;
    int adjvex[MAXVEX];  //儲存相關頂點下標
    int lowcost[MAXVEX]; //儲存相關頂點間邊的權值
    lowcost[0] = 0; //初始化第一個權值為0，既v0加入生成樹
    adjvex[0] = 0; //初始化第一個頂點下標為0
    for(i = 1; i < G.numVertexes; i++){ //迴圈除下標為0外的全部頂點
        lowcost[i] = G.arc[0][i]; //將v0頂點與之有邊的權值存入陣列
        adjvex[i] = 0; //初始化都為v0的下標
    }
    for(i = 1; i < G.numVertexes; i++){
        min = INFINITY; //初始化最小權值為無窮數，通常設定為不可能的大數字如65535等
        j = 1;
        k = 0;
        while(j < G.numVertexes){ //迴圈全部頂點
            if(lowcost[j]!=0&&lowcost[j]<min){ //如果權值不為0，且權值小於min
                min = lowcost[j];//則讓當前權值成為最小值
                k = j; //將當前最小值的下標存入k
            }
            j++;
        }
        printf("(%d,%d)", adjvex[k],k); //列印當前頂點邊中權值最小邊
        lowcost[k] = 0; //將當前頂點的權值設定為0，表示此頂點已經完成任務
        for(j = 1; j < G.numVertexes; j++){//迴圈所有頂點
            if(lowcost[j] != 0 && G.arc[k][j] < lowcost[j]){ //若下標為k頂點各邊權值小於此前這些頂點
                //未被加入生成樹權值
                lowcost[j] = G.arc[k][j]; //將較小權值存入lowcost
                adjvex[j] = k;//將下標為k的頂點存入adjvex
            }
        }
    }
}

改為Java演算法實現

//普里姆最小生成樹
public void prim() {
    int[] lowcost = new int[vertexSize]; //最小代價頂點權值的陣列,為0表示已經獲取最小權值
    int[] adjvex = new int[vertexSize]; //頂點權值下標
    int min, minId, sum = 0;
    //假定第一行距離為到任意頂點最短距離
    for (int i = 0; i < vertexSize; i++) {
        lowcost[i] = matrix[0][i];
    }
    for (int i = 1; i < vertexSize; i++) {
        min = MAX_WEIGHT;
        minId = 0;
        //迴圈查詢到一行中最小的有效權值
        for (int j = 1; j < vertexSize; j++) {
            //有效權值
            if(lowcost[j] < min && lowcost[j] > 0) {
                min = lowcost[j];
                minId = j;
            }
        }
        System.out.println("頂點:" + adjvex[minId] + ",權值:" + min);
        sum += min;
        lowcost[minId] = 0;
        for (int j = 0; j < vertexSize; j++) {
            if(lowcost[j] != 0 && matrix[minId][j] < lowcost[j]) {
                lowcost[j] = matrix[minId][j];
                adjvex[j] = minId;
            }
        }
    }
    System.out.println("sum = " + sum);
}

測試用例

public static void main(String[] args) {
    Graph graph = new Graph(9);
    int NA = MAX_WEIGHT;
    int[] a0 = new int[] {0,10,NA,NA,NA,11,NA,NA,NA};
    int[] a1 = new int[] {10,0,18,NA,NA,NA,16,NA,12};
    int[] a2 = new int[] {NA,NA,0,22,NA,NA,NA,NA,8};
    int[] a3 = new int[] {NA,NA,22,0,20,NA,NA,16,21};
    int[] a4 = new int[] {NA,NA,NA,20,0,26,NA,7,NA};
    int[] a5 = new int[] {11,NA,NA,NA,26,0,17,NA,NA};
    int[] a6 = new int[] {NA,16,NA,NA,NA,17,0,19,NA};
    int[] a7 = new int[] {NA,NA,NA,16,7,NA,19,0,NA};
    int[] a8 = new int[] {NA,12,8,21,NA,NA,NA,NA,0};
    graph.matrix[0] = a0;
    graph.matrix[1] = a1;
    graph.matrix[2] = a2;
    graph.matrix[3] = a3;
    graph.matrix[4] = a4;
    graph.matrix[5] = a5;
    graph.matrix[6] = a6;
    graph.matrix[7] = a7;
    graph.matrix[8] = a8;
    graph.prim();
}

輸出結果

頂點:0,權值:10
頂點:0,權值:11
頂點:1,權值:12
頂點:8,權值:8
頂點:1,權值:16
頂點:6,權值:19
頂點:7,權值:7
頂點:7,權值:16
sum = 99

克魯斯卡爾演算法

克魯斯卡爾演算法與普里姆演算法的區別在於，後者強調的是頂點，而前者強調的是邊

C語言實現

typedef struct{
    int begin;
    int end;
    int weight;
}Edge;
    
void MiniSpanTree_Kruskal(MGraph G){
    int i, n, m;
    Edge edges[MAXEDGE];
    int parent[MAXEDGE];
    for(i = 0; i < G.numEdges; i++){
        n = Find(parent,edges[i].begin);
        m = Find(parent,edges[i].end);
        if(n != m){
            parent[n] = m;
            printf("(%d,%d) %d",edges[i].begin,edges[i].end,edges[i].weight);
        }
    }
}

int Find(int *parent, int f){
    while(parent[f] > 0){
        f = parent[f];  
    }
    return f;
}

改為Java實現
首先要構造邊的圖實現

public class GraphKruskal {

    private Edge[] edges; //構建邊結構陣列
    private int edgeSize; //邊數量
    
    public GraphKruskal(int edgeSize) {
        this.edgeSize = edgeSize;
        edges = new Edge[edgeSize];
    }
    
    //從小到大排列
    public void createEdgeArray() {
        Edge edge0 = new Edge(4, 7, 7);
        Edge edge1 = new Edge(2, 8, 8);
        Edge edge2 = new Edge(0, 1, 10);
        Edge edge3 = new Edge(0, 5, 11);
        Edge edge4 = new Edge(1, 8, 12);
        Edge edge5 = new Edge(3, 7, 16);
        Edge edge6 = new Edge(1, 6, 16);
        Edge edge7 = new Edge(5, 6, 17);
        Edge edge8 = new Edge(1, 2, 18);
        Edge edge9 = new Edge(6, 7, 19);
        Edge edge10 = new Edge(3, 4, 20);
        Edge edge11 = new Edge(3, 8, 21);
        Edge edge12 = new Edge(2, 3, 22);
        Edge edge13 = new Edge(3, 6, 24);
        Edge edge14 = new Edge(4, 5, 26);
        edges[0] = edge0;
        edges[1] = edge1;
        edges[2] = edge2;
        edges[3] = edge3;
        edges[4] = edge4;
        edges[5] = edge5;
        edges[6] = edge6;
        edges[7] = edge7;
        edges[8] = edge8;
        edges[9] = edge9;
        edges[10] = edge10;
        edges[11] = edge11;
        edges[12] = edge12;
        edges[13] = edge13;
        edges[14] = edge14;
    }

    class Edge{
        private int begin;
        private int end;
        private int weight;
        public Edge(int begin, int end, int weight) {
            this.begin = begin;
            this.end = end;
            this.weight = weight;
        }
        public int getBegin() {
            return begin;
        }
        public void setBegin(int begin) {
            this.begin = begin;
        }
        public int getEnd() {
            return end;
        }
        public void setEnd(int end) {
            this.end = end;
        }
        public int getWeight() {
            return weight;
        }
        public void setWeight(int weight) {
            this.weight = weight;
        }
    }
}

public void miniSpanTreeKruskal() {
    int m, n, sum = 0;
    int[] parent = new int[edgeSize];//以起點為下標，值為終點的陣列
    for (int i = 0; i < edgeSize; i++) {
        parent[i] = 0;
    }
    for (int i = 0; i < edgeSize; i++) {
        n = find(parent,edges[i].begin);
        m = find(parent,edges[i].end);
        //保證不出現迴環
        if(n != m) {
            parent[n] = m;
            System.out.println("起點:" + edges[i].begin + ",終點:"
                    + edges[i].end + ",權值:" + edges[i].weight);
            sum += edges[i].weight;
        }
    }
    System.out.println("sum = " + sum);
}

//查詢陣列，獲取非迴環的值，也就是說這裡找到的是值為0的位置
private int find(int[] parent, int value) {
    while(parent[value] > 0) {
        value = parent[value];
    }
    return value;
}

測試

public static void main(String[] args) {
    GraphKruskal gKruskal = new GraphKruskal(15);
    gKruskal.createEdgeArray();
    gKruskal.miniSpanTreeKruskal();
}

輸出結果

起點:4,終點:7,權值:7
起點:2,終點:8,權值:8
起點:0,終點:1,權值:10
起點:0,終點:5,權值:11
起點:1,終點:8,權值:12
起點:3,終點:7,權值:16
起點:1,終點:6,權值:16
起點:6,終點:7,權值:19
sum = 99

最短路徑

最短路徑在路徑規劃時候是經常使用到的

網轉鄰接矩陣

計算最短路徑，採用迪傑斯特拉演算法

#define MAXVEX 9
#define INFINITY 65535
typedef int Pathmatirx[MAXVEX]; //用於儲存最短路徑下標的陣列
typedef int ShortPathTable[MAXVEX]; //用於儲存到各點最短路徑的權值和

//Dijkstra演算法，求有向網G的v0頂點到其餘頂點v最短路徑P[v]及帶權長度D[v]
//P[v]的值為前驅頂點下標，D[v]表示v0到v的最短路徑長度和
void ShortestPath_Dijkstra(MGraph G,int v0,Pathmatrix *P,ShortPathTable *D){
    int v,w,k,min;
    int final[MAXVEX]; //final[w] = 1表示求得頂點v0至vw的最短路徑
    for(v = 0; v < G.numVertexes; v++){ //初始化資料
        final[v] = 0; //全部頂點初始化為未知最短路徑狀態
        (*D)[v] = G.matirx[v0][v]; //將與v0點有連線的頂點加上權值
        (*P)[v] = 0; //初始化路徑陣列為0
    }
    (*D)[v0] = 0; //v0至v0的路徑為0
    final[v0] = 1; //v0至v0不需要求路徑
    //開始主迴圈，每次求得v0到某個v頂點的最短路徑
    for(v = 1; v < G.numVertexes; v++){
        min = INFINITY; //當前所知離v0頂點的最近距離
        for(w = 0; w < G.numVertexes; w++){ //尋找離v0最近的頂點
            if(!final[w] && (*D)[w] < min){
                k = w;
                min = (*D)[w]; //w頂點離v0頂點更近
            }
        }
        final[k] = 1; //將目前找到的最近的頂點置為1
        for(w = 0; w < G.numVertexes; w++){ //修正當前最短路徑與距離
            //如果經過v頂點的路徑比現在這條路徑的長度短的話
            if(!final[w] && (min + G.matirx[k][w] < (*D)[w])){
                //說明找到了更短的路徑，修改D[w]和P[w]
                (*D)[w] = min + G.matirx[k][w]; //修改當前路徑長度
                (*P)[w] = k;
            }
        }
    }
}

轉化為Java

public class Dijkstra {
    private int MAXVEX;
    private int MAX_WEIGHT;
    private boolean isGetPath[];
    private int shortTablePath[];
    
    public void shortesPathDijkstra(Graph graph) {
        int min, k = 0;
        MAXVEX = graph.getVertexSize();
        MAX_WEIGHT = Graph.MAX_WEIGHT;
        shortTablePath = new int[MAXVEX];
        isGetPath = new boolean[MAXVEX];
        //初始化，拿到第一行位置
        for (int v = 0; v < graph.getVertexSize(); v++) {
            shortTablePath[v] = graph.getMatrix()[0][v];
        }
        //從V0開始，自身到自身的距離為0
        shortTablePath[0] = 0;
        isGetPath[0] = true;
        for (int v = 1; v < graph.getVertexSize(); v++) {
            min = MAX_WEIGHT;
            for (int w = 0; w < graph.getVertexSize(); w++) {
                //說明v和w有焦點
                if(!isGetPath[w] && shortTablePath[w] < min) {
                    k = w;
                    min = shortTablePath[w];
                }
            }
            isGetPath[k] = true;
            for (int u = 0; u < graph.getVertexSize(); u++) {
                if(!isGetPath[u] && (min + graph.getMatrix()[k][u]) < shortTablePath[u]) {
                    shortTablePath[u] = min + graph.getMatrix()[k][u];
                }
            }
        }
        for (int i = 0; i < shortTablePath.length; i++) {
            System.out.println("V0到V" + i + "的最短路徑為:" + shortTablePath[i]);
        }
    }
    
    public static void main(String[] args) {
        Graph graph = new Graph(9);
        graph.createGraph();
        Dijkstra dijkstra = new Dijkstra();
        dijkstra.shortesPathDijkstra(graph);
    }
}

測試資料

public class Graph {
    private int vertexSize; //頂點數量
    private int[] vertexs; //頂點陣列
    private int[][] matrix; //邊陣列
    public static final int MAX_WEIGHT = 1000; //非連線頂點權值
    
    public Graph(int vertexSize) {
        this.vertexSize = vertexSize;
        this.vertexs = new int[vertexSize];
        this.matrix = new int[vertexSize][vertexSize];
        //頂點初始化
        for (int i = 0; i < vertexSize; i++) {
            vertexs[i]= i; 
        }
    }
    
    public int getVertexSize() {
        return vertexSize;
    }

    public int[][] getMatrix() {
        return matrix;
    }
    
    public void createGraph(){
        int [] a1 = new int[]{0,1,5,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT};
        int [] a2 = new int[]{1,0,3,7,5,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT};
        int [] a3 = new int[]{5,3,0,MAX_WEIGHT,1,7,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT};
        int [] a4 = new int[]{MAX_WEIGHT,7,MAX_WEIGHT,0,2,MAX_WEIGHT,3,MAX_WEIGHT,MAX_WEIGHT};
        int [] a5 = new int[]{MAX_WEIGHT,5,1,2,0,3,6,9,MAX_WEIGHT};
        int [] a6 = new int[]{MAX_WEIGHT,MAX_WEIGHT,7,MAX_WEIGHT,3,0,MAX_WEIGHT,5,MAX_WEIGHT};
        int [] a7 = new int[]{MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,3,6,MAX_WEIGHT,0,2,7};
        int [] a8 = new int[]{MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,9,5,2,0,4};
        int [] a9 = new int[]{MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,7,4,0};
        
        matrix[0] = a1;
        matrix[1] = a2;
        matrix[2] = a3;
        matrix[3] = a4;
        matrix[4] = a5;
        matrix[5] = a6;
        matrix[6] = a7;
        matrix[7] = a8;
        matrix[8] = a9;
    }
}

拓撲排序

在一個表示工程的有向圖中，用頂點表示活動，用弧表示活動之間的優先關係，這樣的有向圖為頂點表示活動的網，稱之為AOV網(Activity On Vertex Network)
設G=(V,E)是一個具有n個頂點的有向圖，V中的頂點序列v₁，v₂，···，v_n滿足若從頂點v_i到v_j有一條路徑，則在頂點序列中頂點v_i必在頂點v_j之前，則我們稱這樣的頂點序列為一個拓撲序列


實現拓撲排序

public class GraphTopologic {
    
    private int numVertexes;
    private VertexNode[] adjList;//鄰接頂點的一維陣列
    public GraphTopologic(int numVertexes){
        this.numVertexes = numVertexes;
    }
    
    //邊表頂點
    class EdgeNode{
        private int adjVert; //下標
        private EdgeNode next;
        private int weight;
        public EdgeNode(int adjVert) {
            this.adjVert = adjVert;
        }
    }
    
    //鄰接頂點
    class VertexNode{
        private int in; //入度
        private String data;
        private EdgeNode firstEdge;
        public VertexNode(int in, String data) {
            this.in = in;
            this.data = data;
        }
    }
    
    private void createGraph(){
        VertexNode node0 = new VertexNode(0,"v0");
        VertexNode node1 = new VertexNode(0,"v1");
        VertexNode node2 = new VertexNode(2,"v2");
        VertexNode node3 = new VertexNode(0,"v3");
        VertexNode node4 = new VertexNode(2,"v4");
        VertexNode node5 = new VertexNode(3,"v5");
        VertexNode node6 = new VertexNode(1,"v6");
        VertexNode node7 = new VertexNode(2,"v7");
        VertexNode node8 = new VertexNode(2,"v8");
        VertexNode node9 = new VertexNode(1,"v9");
        VertexNode node10 = new VertexNode(1,"v10");
        VertexNode node11 = new VertexNode(2,"v11");
        VertexNode node12 = new VertexNode(1,"v12");
        VertexNode node13 = new VertexNode(2,"v13");
        adjList = new VertexNode[numVertexes];
        adjList[0] =node0;
        adjList[1] =node1;
        adjList[2] =node2;
        adjList[3] =node3;
        adjList[4] =node4;
        adjList[5] =node5;
        adjList[6] =node6;
        adjList[7] =node7;
        adjList[8] =node8;
        adjList[9] =node9;
        adjList[10] =node10;
        adjList[11] =node11;
        adjList[12] =node12;
        adjList[13] =node13;
        node0.firstEdge = new EdgeNode(11);node0.firstEdge.next = new Edge