數組、鏈表的java實現

一、數組

數組特點：查詢快，增刪慢

 

 

二、鏈表

鏈表分為單向鏈表和雙向鏈表（包括雙向循環鏈表）

鏈表特點：查詢慢，增刪快

單向鏈表：表頭為空，下一個節點是10.

 

雙向鏈表：每個節點都有前驅指針和后繼指針

 

雙向循環鏈表：表頭為空，表頭的后繼結點是10，最后一個節點的后繼結點是表頭

雙向循環鏈表的java實現,代碼如下

/**
 * Java 實現的雙向鏈表。 
 * 注：java自帶的集合包中有實現雙向鏈表，路徑是:java.util.LinkedList
 *
 */
public class DoubleLink<T> {

    // 表頭
    private DNode<T> mHead;  //表頭
    // 節點個數
    private int mCount;   //元素個數

    // 雙向鏈表“節點”對應的結構體
    private class DNode<T> {
        public DNode prev;
        public DNode next;
        public T value;

        public DNode(T value, DNode prev, DNode next) {
            this.value = value;
            this.prev = prev;
            this.next = next;
        }
    }

    // 構造函數
    public DoubleLink() {
        // 創建“表頭”。注意：表頭沒有存儲數據！
        mHead = new DNode<T>(null, null, null);
        mHead.prev = mHead.next = mHead;
        // 初始化“節點個數”為0
        mCount = 0;
    }

    // 返回節點數目
    public int size() {
        return mCount;
    }

    // 返回鏈表是否為空
    public boolean isEmpty() {
        return mCount==0;
    }

    // 獲取第index位置的節點
    private DNode<T> getNode(int index) {
        if (index<0 || index>=mCount)
            throw new IndexOutOfBoundsException();

        // 正向查找
        if (index <= mCount/2) {
            DNode<T> node = mHead.next;
            for (int i=0; i<index; i++)
                node = node.next;

            return node;
        }

        // 反向查找
        DNode<T> rnode = mHead.prev;
        int rindex = mCount - index -1;
        for (int j=0; j<rindex; j++)
            rnode = rnode.prev;

        return rnode;
    }

    // 獲取第index位置的節點的值
    public T get(int index) {
        return getNode(index).value;
    }

    // 獲取第1個節點的值
    public T getFirst() {
        return getNode(0).value;
    }

    // 獲取最后一個節點的值
    public T getLast() {
        return getNode(mCount-1).value;
    }

    // 將節點插入到第index位置之前
    public void insert(int index, T t) {
        if (index==0) {
            DNode<T> node = new DNode<T>(t, mHead, mHead.next);
            mHead.next.prev = node;
            mHead.next = node;
            mCount++;
            return ;
        }

        DNode<T> inode = getNode(index);
        DNode<T> tnode = new DNode<T>(t, inode.prev, inode);
        inode.prev.next = tnode;
        inode.next = tnode;
        mCount++;
        return ;
    }

    // 將節點插入第一個節點處。
    public void insertFirst(T t) {
        insert(0, t);
    }

    // 將節點追加到鏈表的末尾
    public void appendLast(T t) {
        DNode<T> node = new DNode<T>(t, mHead.prev, mHead);
        mHead.prev.next = node;
        mHead.prev = node;
        mCount++;
    }

    // 刪除index位置的節點
    public void del(int index) {
        DNode<T> inode = getNode(index);
        inode.prev.next = inode.next;
        inode.next.prev = inode.prev;
        inode = null;
        mCount--;
    }

    // 刪除第一個節點
    public void deleteFirst() {
        del(0);
    }

    // 刪除最后一個節點
    public void deleteLast() {
        del(mCount-1);
    }
}

 雙向鏈表中元素的增刪查改

元素的查找：只能從表頭開始按照連接關系一直找到指定位置的元素。

元素的增加：首先查找到要增加位置的元素，將要增加元素的前指針指向該位置原節點的前面節點，並將增加元素的后指針指向該位置原節點的后面節點。然后將要該位置原節點的前面節點的后指針指向要增加的元素，該位置的原節點的前指針指向要增加的元素。

 

元素的刪除：首先查找到元素，然后將該元素前一個節點的后節點的指針指向要刪除元素的后一個元素，然后將要刪除元素后一個元素的的前節點的指針指向要刪除元素的前一個元素。