1.概念的引入

相信大家都使用過各種集合來進行開發,但是較少的人會去研究其內部的儲存原理和呼叫方法,今天我就來帶大家一起學習資料結構演算法:雙向連結串列

首先我們先來了解什麼是快取,以及資料在記憶體中的儲存方式.

1.快取是什麼

如果cup讀取資料時,每次讀取都是從記憶體再到硬碟讀取,那麼效率就太低了.
所以可以預先把資料存到記憶體,然後cup下次從記憶體讀取即可.

2.資料在記憶體中的儲存方式

第1種.線性

    所謂線性,就是記憶體是連續的
    舉例ArrayList或者陣列:我們知道,陣列儲存資料的時候,當你申請100個大小,但是記憶體不足的時候就會導致記憶體不足而失敗,或者即使你請求到了100個,但是你只存3個數據,那麼就浪費記憶體了
    =>優點:查詢資料快(好比幾個好朋友乘火車,車票都連在一起就好找了)
      缺點:1,記憶體不足就失敗;2.浪費記憶體(買了10張火車票,但是隻有3個人乘車,那麼就浪費了7張)
 

第2種.連結

    記憶體是連結的(用於解決記憶體不足,解決線性(上面)問題的不足),比如不連續的空間也能存資料,比如買火車票,有火車票就賣給你,要幾張賣幾張,不連續位置的也賣.
    =>優點:解決記憶體不足,解決記憶體浪費
      缺點:找人比較慢(票不連續,不一定在一個車廂)

節點的屬性:

多個節點的內部構造:

程式碼思路

一.新增節點add(Object obj)

1.Node節點屬性:
    prev:存放前節點(相當於地址,地址就是指標,指標就是地址)
    data:Object各種資料
    next:存放下節點
2.定義head,rear節點,當只有一個節點,那麼head和rear同指一個節點
3.節點新增的方法add(Object obj)
    1.建立節點new Node(),即每加一個數據就創一個節點
    2.放資料
    3.把節點放入連結串列中
        1.如果頭結點為空,那麼頭結點和尾節點都指向該節點
        2.如果頭節點不為空
            1.往尾部新增
                原來的next指向新節點
                rear.next = note;
                新節點pre指向原節點,新節點也變成尾節點
                note.pre = rear
            (ps,有需求再設定往頭部新增)
4.toString方法[元素1,元素2,元素3] while(head!=null)  if(head!=rear)append(head.data+","),***同temp代替head,否則會破壞head,影響後面的remove時head變才null了
 

新增節點過程圖

二.刪除節點資料remove(Object obj)

注意判斷該節點:1.是head 2.還是 rear 3.還是中間某值

1.查詢資料所在節點find(Object obj)
    1.從頭結點開始遍歷Note temp = head
    2.while迴圈(temp!=null) 如果找到是資料相同就停止
        判斷資料相同的兩標準 equals 和hashCode()
        否則temp = temp.next,下一個
    3.返回節點

2. 確實找到一個有該資料的節點if(delete!=null),然後有4種情況如果刪的是以下的
    1.只有一個節點->既是頭又是尾=>頭尾都設空
    2.是頭結點=>新節點變頭節點,新節點的pre變null
    3.是尾節點=>新節點變尾節點,新節點的next變null
    4.是其他
        =>前一個節點的next=該節點的next
          後一個節點的pre = 該節點的pre;
 

刪除節點過程圖

三.修改資料update(Object oldData,Object newData)

1.找到data所在的節點find(oldData);
2.如果找到的節點不為空,就把data變成newData.

四.容器中是否包含資料contains(Object data)

1.同理根據find(data)
2.返回 !note==null即可,不為空就是有包含

五.可以改成增強泛型版,把所有的Object改成T,就可以增強為選擇和泛型非泛型了

雙向連結串列的迭代器

直接增強for迴圈或者迭代就報錯,因為沒實現介面iterable,該介面是所有集合的頂級介面.
1.實現iterable
2.重寫iterator方法
    1.返回new Iterator()
        1.hasNext()方法
            返回是否有資料 Note temp = head
            temp==null;
        2.next()方法
            1.返回temp.data
            2.temp指向下一個.temp = temp.next
        3.remove()方法-不改變
3.ArrayList不給在增強for迴圈或者迭代器中做增刪改,所以自己也可用設定,根據ArrayList的設計方法,同理,設定一個變數modCount.
    1.在自己的連結串列類成員變數定義
    2.在增刪改的時候++;
    3.在迭代器裡面設定一個標記=modCount.(此時和前面的連結串列操作後的情況值的大小相同);
    4.迭代過程中,如果再做了增刪改的操作,就丟擲異常.
        寫在next()方法的首位,if(標記改變),也丟擲concurrentMotificationExaption(不能做增刪改)

經過了詳細的過程講解,下面給出詳細程式碼

3.完整程式碼:

public class DoubleLink<T> implements Iterable<T> {
    public class Note {

        Note prev;
        T data;
        Note next;
    }

    Note head;
    Note rear;
    public int modCount;

    // 預設增在後面,可相同的寫個addLast(T data);
    public void add(T data) {
        Note note = new Note();
        // 加資料
        note.data = data;
        // 無資料
        if (head == null) {// 等同head == null && rear == null,head沒有那rear肯定沒有
            head = note;
            rear = note;
        }
        // 有資料,加到後面,尾節點並變成新的節點
        else {
            note.prev = rear;
            rear.next = note;
            rear = note;
        }
        modCount++;
    }

    public void addFirst(T data) {
        Note note = new Note();
        note.data = data;
        if (head == null) {
            head = note;
            rear = note;
        } else {
            // 只改這裡即可,note的前面變成null,next變成舊頭,舊頭的pre變成note,(新頭變成了note,***比別把note變成新頭要符合)
            note.prev = null;
            note.next = head;
            head.prev = note;
            head = note;
        }
        modCount++;
    }

    // 刪
    public void remove(T data) {
        // 找到所在資料所在節點
        Note delete = find(data);
        // 如果有該節點
        if (delete != null) {
            // 1.只有一個節點(那麼該節點的pre和next都是null),都置空
            if (delete.prev == null && delete.next == null) {// 等同head==rear&&rear!=null;
                head = null;
                rear = null;
            }
            // 2.是頭
            else if (delete.prev == null) {
                // 那麼原本頭結點的下一個的pre就變成null,頭節點變成刪除節點的後一個;
                delete.next.prev = null;
                head = delete.next;// 反過來寫(delete.next=head)就不能給head賦值了,就會刪除失效
            }
            // 3.是尾
            else if (delete.next == null) {
                // 尾巴的前一個的next變成null,尾巴變成新的尾巴
                delete.prev.next = null;
                rear = delete.prev;// 同理,不能反過來
            }
            // 4.是其他
            else {
                // 刪除的前面的next指向刪除的next
                delete.prev.next = delete.next;
                // 刪除後面的pre = 刪除的pre
                delete.next.prev = delete.prev;
            }
            modCount++;
        }
    }

    // 改
    public void update(T oldData, T newData) {
        Note note = find(oldData);
        note.data = newData;
        modCount++;
    }

    // 查
    public boolean contains(T data) {
        Note note = find(data);
        return note != null;
    }

    // 大小
    public int size() {
        int count = 0;
        Note temp = head;
        while (temp != null) {

            count++;
            temp = temp.next;
        }
        return count;
    }

    // 獲取位置
    public T get(int index) {
        int size = size();// 防止超出
        if (index >= size) {
            throw new IndexOutOfBoundsException("沒有此角標");
        }
        T data = null;
        // 定義成頭
        Note temp = head;

        if (temp != null) {
            if (index == 0) {
                data = temp.data;
            } else {
                for (int i = 0; i < index; i++) {// 1的時候是第下一個,2的時候是下一個的下一個;
                    data = temp.next.data;
                }
            }
        }
        return data;
    }

    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            Note temp = head;
            int flag = modCount;

            @Override
            public boolean hasNext() {// 判斷是否有值,即判空
                return temp != null;
            }

            @Override
            public T next() {// 返回具體資料
                T data = temp.data;
                temp = temp.next;// 關鍵:取值後變成下一個節點
                // 發現迭代的過程中有改動
                if (flag != modCount) {
                    throw new ConcurrentModificationException("迭代過程不能修改");
                }
                return data;
            }

            @Override
            public void remove() {

            }
        };
    }

    /*--------------自定義堆疊,增加一個push,和poll尾部獲取並移除--------------*/
    public void push(T data) {
        add(data);
    }
    //獲取並從尾部移除
    public T poll() {
        T data = null;
        Note temp = rear;//從尾部拿;
        if (temp != null) {
            data = temp.data;
            //移除
            if (rear.prev != null) {
                //前面有節點
                rear.prev.next = null;
                rear = rear.prev;
            } else {
                //前面沒節點
                rear = null;
                head = null;
            }
        } else {
            throw new EmptyStackException();
        }
        return data;
    }
    private Note find(T data) {
        Note temp = head;
        while (temp != null) {
            // System.out.println("data = " + data);//1234
            // System.out.println("temp.data = " + temp.data);//1234
            // System.out.println(1234 == 1234);//true
            // System.out.println(temp.data == data);//false ,因為data是T泛型
            // System.out.println(temp.data.equals(1234));//true
            // System.out.println(temp.data.equals(data));//true
            // 等於當前,返回當前
            if (temp.data.equals(data) && temp.data.hashCode() == data.hashCode()) {
                // 判斷相同請用equals,發現用==有的資料居然不生效;最正規的方法是用equals+hashCode()==data.hashCode();
                return temp;
            } else {
                // 否則往下找,找不到可能為空,即沒有下一個
                temp = temp.next;
            }
            /*
             * ==操作比較的是兩個變數的值是否相等，對於引用型變量表示的是兩個變數在堆中儲存的地址是否相同，即棧中的內容是否相同。 equals操作表示的兩個變數是否是對同一個物件的引用，即堆中的內容是否相同。
             *
             * ==比較的是2個物件的地址，而equals比較的是2個物件的內容。 顯然，當equals為true時，==不一定為true；
             */
        }
        return temp;
    }

    @Override
    public String toString() {
        StringBuilder ms = new StringBuilder("[");
        Note temp = head;
        while (temp != null) {
            if (temp != rear) {
                ms.append(temp.data + ",");
            } else {
                ms.append(temp.data);
            }
            temp = temp.next;
        }
        return ms + "]";
    }
}

下面我們通過建立測試類來測試程式碼的各項功能

public class Test{
    public static void main(String[] args) {
        Demo07_DoubleLink<Integer> dl = new Demo07_DoubleLink();
        /*--------------增後add--------------*/
        dl.add(123);
        dl.add(12345);
        /*--------------增前addFirst--------------*/
        dl.addFirst(77);
        dl.addFirst(717);
        System.out.println(dl);
        /*--------------刪remvove--------------*/
        dl.remove(12345);
        dl.remove(717);
        System.out.println(dl);
        /*--------------改update--------------*/
        dl.update(77, 707);
        System.out.println(dl);
        /*--------------查contains--------------*/
        System.out.println("contains 123 ? " + dl.contains(123));
        /*--------------獲取大小size--------------*/
        int size = dl.size();
        System.out.println("size = " + size);
        /*--------------獲取元素get--------------*/
        int i0 = dl.get(1);
        int i1 = dl.get(0);
        // int i7 = dl.get(8);
        System.out.println("get : " + i0);
        System.out.println("get : " + i1);
        /*--------------迭代+增強for迴圈--------------*/
        // System.out.println("get : " + i7);
        // 迭代
        // for (Integer i : dl) {
        // System.out.println(i);
        // }
        // Iterator<Integer> iterator = dl.iterator();
        // while (iterator.hasNext()) {
        // Integer data = iterator.next();
        // if (data.equals(707)) {
        // dl.remove(data);
        // }
        // System.out.println(data);
        // }
        /*--------------自定義堆疊--------------*/
        System.out.println("----------------------自定義堆疊,並且自己加異常--------------------");
        int poll = dl.poll();
        System.out.println(poll);
        System.out.println(dl);
        System.out.println(dl.poll());
        System.out.println(dl);
    }
}

列印結果:

--------------------往後面新增--------------------
[123,12345]
--------------------往前面增加--------------------
[717,77,123,12345]
--------------------移除方法----------------------
[77,123]
--------------------修改方法----------------------
[707,123]
--------------------判斷是否包含方法---------------
contains 123 ? true
--------------------獲取大小的方法-----------------
size = 2
--------------------獲取元素----------------------
get : 123
get : 707
-------------------迭代和增強for迴圈--------------
-------------------自定義堆疊,並且自己加異常--------
123
[707]
707
[]

總結

以上就是雙鏈表的相關學習,大家只要記住一下幾點即可:

1.節點的3個屬性pre,data,next
2.頭節點和尾節點head,rear
3.要完成迭代,需要讓類繼承Iterable,仿製迭代過程不可修改