双向链表

  1 public class DoubleLink<T> implements Iterable<T> {
  2     public class Note {
  3 
  4         Note prev;
  5         T data;
  6         Note next;
  7     }
  8 
  9     Note head;
 10     Note rear;
 11     public int modCount;
 12 
 13     // 默认增在后面,可相同的写个addLast(T data);
 14     public void add(T data) {
 15         Note note = new Note();
 16         // 加数据
 17         note.data = data;
 18         // 无数据
 19         if (head == null) {// 等同head == null && rear == null,head没有那rear肯定没有
 20             head = note;
 21             rear = note;
 22         }
 23         // 有数据,加到后面,尾节点并变成新的节点
 24         else {
 25             note.prev = rear;
 26             rear.next = note;
 27             rear = note;
 28         }
 29         modCount++;
 30     }
 31 
 32     public void addFirst(T data) {
 33         Note note = new Note();
 34         note.data = data;
 35         if (head == null) {
 36             head = note;
 37             rear = note;
 38         } else {
 39             // 只改这里即可,note的前面变成null,next变成旧头,旧头的pre变成note,(新头变成了note,***比别把note变成新头要符合)
 40             note.prev = null;
 41             note.next = head;
 42             head.prev = note;
 43             head = note;
 44         }
 45         modCount++;
 46     }
 47 
 48     // 删
 49     public void remove(T data) {
 50         // 找到所在数据所在节点
 51         Note delete = find(data);
 52         // 如果有该节点
 53         if (delete != null) {
 54             // 1.只有一个节点(那么该节点的pre和next都是null),都置空
 55             if (delete.prev == null && delete.next == null) {// 等同head==rear&&rear!=null;
 56                 head = null;
 57                 rear = null;
 58             }
 59             // 2.是头
 60             else if (delete.prev == null) {
 61                 // 那么原本头结点的下一个的pre就变成null,头节点变成删除节点的后一个;
 62                 delete.next.prev = null;
 63                 head = delete.next;// 反过来写(delete.next=head)就不能给head赋值了,就会删除失效
 64             }
 65             // 3.是尾
 66             else if (delete.next == null) {
 67                 // 尾巴的前一个的next变成null,尾巴变成新的尾巴
 68                 delete.prev.next = null;
 69                 rear = delete.prev;// 同理,不能反过来
 70             }
 71             // 4.是其他
 72             else {
 73                 // 删除的前面的next指向删除的next
 74                 delete.prev.next = delete.next;
 75                 // 删除后面的pre = 删除的pre
 76                 delete.next.prev = delete.prev;
 77             }
 78             modCount++;
 79         }
 80     }
 81 
 82     // 改
 83     public void update(T oldData, T newData) {
 84         Note note = find(oldData);
 85         note.data = newData;
 86         modCount++;
 87     }
 88 
 89     // 查
 90     public boolean contains(T data) {
 91         Note note = find(data);
 92         return note != null;
 93     }
 94 
 95     // 大小
 96     public int size() {
 97         int count = 0;
 98         Note temp = head;
 99         while (temp != null) {
100 
101             count++;
102             temp = temp.next;
103         }
104         return count;
105     }
106 
107     // 获取位置
108     public T get(int index) {
109         int size = size();// 防止超出
110         if (index >= size) {
111             throw new IndexOutOfBoundsException("没有此角标");
112         }
113         T data = null;
114         // 定义成头
115         Note temp = head;
116 
117         if (temp != null) {
118             if (index == 0) {
119                 data = temp.data;
120             } else {
121                 for (int i = 0; i < index; i++) {// 1的时候是第下一个,2的时候是下一个的下一个;
122                     data = temp.next.data;
123                 }
124             }
125         }
126         return data;
127     }
128 
129     @Override
130     public Iterator<T> iterator() {
131         return new Iterator<T>() {
132             Note temp = head;
133             int flag = modCount;
134 
135             @Override
136             public boolean hasNext() {// 判断是否有值,即判空
137                 return temp != null;
138             }
139 
140             @Override
141             public T next() {// 返回具体数据
142                 T data = temp.data;
143                 temp = temp.next;// 关键:取值后变成下一个节点
144                 // 发现迭代的过程中有改动
145                 if (flag != modCount) {
146                     throw new ConcurrentModificationException("迭代过程不能修改");
147                 }
148                 return data;
149             }
150 
151             @Override
152             public void remove() {
153 
154             }
155         };
156     }
157 
158     /*--------------自定义堆栈,增加一个push,和poll尾部获取并移除--------------*/
159     public void push(T data) {
160         add(data);
161     }
162     //获取并从尾部移除
163     public T poll() {
164         T data = null;
165         Note temp = rear;//从尾部拿;
166         if (temp != null) {
167             data = temp.data;
168             //移除
169             if (rear.prev != null) {
170                 //前面有节点
171                 rear.prev.next = null;
172                 rear = rear.prev;
173             } else {
174                 //前面没节点
175                 rear = null;
176                 head = null;
177             }
178         } else {
179             throw new EmptyStackException();
180         }
181         return data;
182     }
183     private Note find(T data) {
184         Note temp = head;
185         while (temp != null) {
186             // System.out.println("data = " + data);//1234
187             // System.out.println("temp.data = " + temp.data);//1234
188             // System.out.println(1234 == 1234);//true
189             // System.out.println(temp.data == data);//false ,因为data是T泛型
190             // System.out.println(temp.data.equals(1234));//true
191             // System.out.println(temp.data.equals(data));//true
192             // 等于当前,返回当前
193             if (temp.data.equals(data) && temp.data.hashCode() == data.hashCode()) {
194                 // 判断相同请用equals,发现用==有的数据居然不生效;最正规的方法是用equals+hashCode()==data.hashCode();
195                 return temp;
196             } else {
197                 // 否则往下找,找不到可能为空,即没有下一个
198                 temp = temp.next;
199             }
200             /*
201              * ==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。 equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
202              *
203              * ==比较的是2个对象的地址，而equals比较的是2个对象的内容。 显然，当equals为true时，==不一定为true；
204              */
205         }
206         return temp;
207     }
208 
209     @Override
210     public String toString() {
211         StringBuilder ms = new StringBuilder("[");
212         Note temp = head;
213         while (temp != null) {
214             if (temp != rear) {
215                 ms.append(temp.data + ",");
216             } else {
217                 ms.append(temp.data);
218             }
219             temp = temp.next;
220         }
221         return ms + "]";
222     }
223 }