本身動手擼一個LinkedList

本身動手擼一個LinkedList

1. 原理

LinkedList是基於雙鏈表的動態數組，數據添加刪除效率高，只須要改變指針指向便可，可是訪問數據的平均效率低，須要對鏈表進行遍歷。所以，LinkedList善於進行一些插入、刪除操做，不利於進行檢索操做。LinkedList和ArrayList這兩個list在咱們代碼裏會常常用到，所以，小編自定義實現LinkedList的簡易版--MyLinkedList。

2. public API

void clear()                     --> 置空
boolean isEmpty()                --> 判空
int size()                       --> 返回鏈表的長度
AnyType get(int idx)             --> 根據索引檢索元素
AnyType set(int idx)             --> 根據索引跟新元素
boolean add(AnyType x)           --> 添加元素x
boolean add(AnyType x，int idx)  --> 根據索引添加元素x
AnyType remove(int idx)          --> 根據索引刪除元素x
String toString()                --> 打印鏈表

3. 圖解核心操做

• 一個節點Node類的數據結構

• doClear( ) 方法，初始化一個雙鏈表，先定義一個頭結點beginMarker，而後定義一個尾結點endMarker，前驅指向頭結點，最後頭結點的後繼指向尾結點。

• 添加元素，先定義一個被添加元素x的節點，使它前驅指向被插入位置的前一個，後繼指向被插入位置的節點，這是第一步，而後將被插入的前一個節點的next指向此節點，被插入位置的節點的prev指向此節點。

  Node<AnyType> newNode = new Node<>(x, p.prev, p);  // ①②
  newNode.prev.next = newNode;       // ③
  p.prev = newNode;          // ④

  固然，第三步和第四步能夠合併：

  Node<AnyType> newNode = new Node<>(x, p.prev, p);  // ①②
  p.prev = p.prev.next = newNode;       // ③④

  沒想到以上4步全能夠合併爲：

  p.prev = p.prev.next = new Node<>(x, p.prev, p);  // ①②③④

  精闢！

• 刪除元素，根據索引找到對應的節點p，將p的後繼的prev指向p的前驅，將p的前驅的next指向p的後繼。

  p.next.prev = p.prev;
  p.prev.next = p.next;

• 檢索節點getNode，LinkedList能夠很快很方便地插入和刪除元素，可是對於檢索元素則就慢了，咱們能夠將索引分爲前半部分和後半部分，若是索引在前半部分，咱們就向後的方向遍歷該鏈表；一樣的道理，若是索引在後半部分，咱們就從終端開始往回走，向前遍歷該鏈表，這樣能夠提升一下檢索速度吧。

  // 從頭結點開始向後找
  if (idx < size() / 2) {
   p = beginMarker.next;
   for (int i = 0; i < idx; i++) {
    p = p.next;
   }
  }
  // 從尾節點開始向前找
  else {
   p = endMarker;
      for (int i = size(); i > idx; i--) {
      p = p.prev;
     }
  }

4. MyLinkedList代碼實現

  1 package com.hx.list;
  2 
  3 /**
  4  * @author: wenhx
  5  * @date: Created in 2019/10/17 16:11
  6  * @description: 用雙鏈表實現MyLinkedList
  7  */
  8 public class MyLinkedList<AnyType> implements Iterable<AnyType> {
  9 
 10 
 11     private int theSize;
 12     private int modCount = 0;
 13     private Node<AnyType> beginMarker;
 14     private Node<AnyType> endMarker;
 15 
 16     /**
 17      * 內部類，定義鏈表的節點
 18      */
 19     private static class Node<AnyType> {
 20 
 21         public AnyType data;
 22         public Node<AnyType> prev;
 23         public Node<AnyType> next;
 24 
 25         public Node(AnyType d, Node<AnyType> p, Node<AnyType> n) {
 26             data = d;
 27             prev = p;
 28             next = n;
 29         }
 30     }
 31 
 32     /**
 33      * 構造器
 34      */
 35     public MyLinkedList() {
 36         doClear();
 37     }
 38 
 39     /**
 40      * 判空
 41      */
 42     public boolean isEmpty() {
 43         return size() == 0;
 44     }
 45 
 46     /**
 47      * 清空
 48      */
 49     public void clear() {
 50         doClear();
 51     }
 52 
 53 
 54     /**
 55      * 返回鏈表的長度
 56      */
 57     public int size() {
 58         return theSize;
 59     }
 60 
 61     /**
 62      * 根據索引檢索元素
 63      */
 64     public AnyType get(int idx) {
 65         return getNode(idx).data;
 66     }
 67 
 68     /**
 69      * 根據索引跟新元素
 70      */
 71     public AnyType set(int idx, AnyType newVal) {
 72         Node<AnyType> p = getNode(idx);
 73         AnyType oldVal = p.data;
 74         p.data = newVal;
 75         return oldVal;
 76     }
 77 
 78     /**
 79      * 添加元素x
 80      */
 81     public boolean add(AnyType x) {
 82         add(size(), x);
 83         return true;
 84     }
 85 
 86     /**
 87      * 根據索引添加元素
 88      */
 89     public void add(int idx, AnyType x) {
 90         addBefore(getNode(idx, 0, size()), x);
 91     }
 92 
 93     /**
 94      * 根據索引刪除元素
 95      */
 96     public AnyType remove(int idx) {
 97         return remove(getNode(idx));
 98     }
 99 
100     /**
101      * 打印鏈表
102      */
103     public String toString() {
104         StringBuilder sb = new StringBuilder("[ ");
105 
106         for (AnyType x : this) {
107             sb.append(x + " ");
108         }
109         sb.append("]");
110 
111         return new String(sb);
112     }
113 
114     /**
115      * 清空鏈表（實現）
116      */
117     private void doClear() {
118         beginMarker = new Node<>(null, null, null);
119         endMarker = new Node<>(null, beginMarker, null);
120         beginMarker.next = endMarker;
121         theSize = 0;
122         modCount++;
123     }
124 
125     /**
126      * 根據索引檢索節點
127      */
128     private Node<AnyType> getNode(int idx) {
129         return getNode(idx, 0, size() - 1);
130     }
131 
132     /**
133      * 檢索節點
134      */
135     private Node<AnyType> getNode(int idx, int lower, int upper) {
136         Node<AnyType> p;
137 
138         if (idx < lower || idx > upper) {
139             throw new IndexOutOfBoundsException("getNode index: " + idx + "; size: " + size());
140         }
141 
142         if (idx < size() / 2) {
143             p = beginMarker.next;
144             for (int i = 0; i < idx; i++) {
145                 p = p.next;
146             }
147         } else {
148             p = endMarker;
149             for (int i = size(); i > idx; i--) {
150                 p = p.prev;
151             }
152         }
153 
154         return p;
155     }
156 
157     /**
158      * 插入節點
159      */
160     private void addBefore(Node<AnyType> p, AnyType x) {
161         Node<AnyType> newNode = new Node<>(x, p.prev, p);
162         newNode.prev.next = newNode;
163         p.prev = newNode;
164         theSize++;
165         modCount++;
166     }
167 
168     /**
169      * 刪除節點p
170      */
171     private AnyType remove(Node<AnyType> p) {
172         p.next.prev = p.prev;
173         p.prev.next = p.next;
174         theSize--;
175         modCount++;
176 
177         return p.data;
178     }
179 
180 
181     /**
182      * 返回一個迭代器對象，用於遍歷鏈表
183      */
184     public java.util.Iterator<AnyType> iterator() {
185         return new LinkedListIterator();
186     }
187 
188     /**
189      * LinkedListIterator迭代器的實現
190      */
191     private class LinkedListIterator implements java.util.Iterator<AnyType> {
192 
193         private Node<AnyType> current = beginMarker.next;
194         private int expectedModCount = modCount;
195         private boolean okToRemove = false;
196 
197         public boolean hasNext() {
198             return current != endMarker;
199         }
200 
201         public AnyType next() {
202             if (modCount != expectedModCount) {
203                 throw new java.util.ConcurrentModificationException();
204             }
205             if (!hasNext()) {
206                 throw new java.util.NoSuchElementException();
207             }
208 
209             AnyType nextItem = current.data;
210             current = current.next;
211             okToRemove = true;
212             return nextItem;
213         }
214 
215         public void remove() {
216             if (modCount != expectedModCount) {
217                 throw new java.util.ConcurrentModificationException();
218             }
219             if (!okToRemove) {
220                 throw new IllegalStateException();
221             }
222 
223             MyLinkedList.this.remove(current.prev);
224             expectedModCount++;
225             okToRemove = false;
226         }
227     }
228 
229 
230     /**
231      * 主方法：用來測試MyLinkedList
232      */
233     public static void main(String[] args) {
234         MyLinkedList<Integer> myLinkedList = new MyLinkedList<>();
235 
236         for (int i = 0; i < 10; i++) {
237             myLinkedList.add(i);
238         }
239         for (int i = 20; i < 30; i++) {
240             myLinkedList.add(0, i);
241         }
242 
243         System.out.println(myLinkedList.toString());
244         System.out.println("----------");
245         myLinkedList.remove(0);
246         myLinkedList.remove(myLinkedList.size() - 1);
247         System.out.println(myLinkedList);
248         System.out.println("----------");
249         java.util.Iterator<Integer> itr = myLinkedList.iterator();
250         while (itr.hasNext()) {
251             itr.next();
252             itr.remove();
253             System.out.println(myLinkedList);
254         }
255     }
256 }

 

完成，撒花，一個迷你版的LinkedList就寫好啦，下次有空再寫一個迷你版的ArrayList...

後記：

如有不當之處，可向小編反饋，一塊兒交流學習，共同進步。

我的博客地址：https://www.cnblogs.com/q964024886/

GitHub地址：https://github.com/wenhaixiong