双链表遍历问题

普林斯顿算法week2的deque实现 check iterator() 这个test搞了我一整天 没解决 想问问大家问题出在哪里？
题目是这样的：

Dequeue. A double-ended queue or deque (pronounced "deck") is a generalization of a stack and a queue that supports adding and removing items from either the front or the back of the data structure. Create a generic data type Deque that implements the following API:

public class Deque<Item> implements Iterable<Item> {   public Deque()                           // construct an empty deque   public boolean isEmpty()                 // is the deque empty?   public int size()                        // return the number of items on the deque   public void addFirst(Item item)          // add the item to the front   public void addLast(Item item)           // add the item to the end   public Item removeFirst()                // remove and return the item from the front   public Item removeLast()                 // remove and return the item from the end   public Iterator<Item> iterator()         // return an iterator over items in order from front to end   public static void main(String[] args)   // unit testing}我打算用双链表做，coursera上其他函数检测都正常，唯独Iterator函数通不过 我的代码是这样的：

1. import java.util.Iterator;
   
2. 
   
3. public class Deque<Item> implements Iterable<Item> {
   
4.        
   
5.         public Deque() {
   
6.                
   
7.                 first = null;
   
8.                 last = null;
   
9.         }
   
10.        
    
11.         public boolean isEmpty() {
    
12.                
    
13.                 return (first == null);
    
14.         }
    
15.        
    
16.         public int size() {
    
17.                
    
18.                 if (this.isEmpty()) {
    
19.                        
    
20.                         return 0;
    
21.                 }
    
22.                
    
23.                 Node current = first;
    
24.                 int i = 1;
    
25.                
    
26.                 while (true) {
    
27.                        
    
28.                         if (current == last) {
    
29.                                
    
30.                                 return i;
    
31.                         }
    
32.                        
    
33.                         current = current.next;
    
34.                         i++;
    
35.                 }
    
36.         }
    
37.        
    
38.         public void addFirst(Item item) {
    
39.                
    
40.                 if (item == null) {
    
41.                        
    
42.                         throw new java.lang.NullPointerException();
    
43.                 }
    
44.                
    
45.                 Node toAdd = new Node();
    
46.                 toAdd.item = item;
    
47.                
    
48.                 if (this.isEmpty()) {
    
49.                        
    
50.                         toAdd.next = null;
    
51.                         toAdd.previous = null;
    
52.                         first = toAdd;
    
53.                         last = toAdd;
    
54.                 }
    
55.                
    
56.                 Node oldFirst = first;
    
57.                 oldFirst.previous = toAdd;
    
58.                 toAdd.next = oldFirst;
    
59.                 toAdd.previous = null;
    
60.                 first = toAdd;
    
61.         }
    
62.        
    
63.         public void addLast(Item item) {
    
64.                
    
65.                 if (item == null) {
    
66.                        
    
67.                         throw new java.lang.NullPointerException();
    
68.                 }
    
69.                
    
70.                 Node toAdd = new Node();
    
71.                 toAdd.item = item;
    
72.                
    
73.                 if (this.isEmpty()) {
    
74.                        
    
75.                         toAdd.next = null;
    
76.                         toAdd.previous = null;
    
77.                         first = toAdd;
    
78.                         last = toAdd;
    
79.                 }
    
80.                
    
81.                 Node oldLast = last;
    
82.                 oldLast.next = toAdd;
    
83.                 toAdd.next = null;
    
84.                 toAdd.previous = oldLast;
    
85.                 last = toAdd;
    
86.         }
    
87.        
    
88.         public Item removeFirst() {
    
89.                
    
90.                 Item item;
    
91.                
    
92.                 if (this.isEmpty()) {
    
93.                        
    
94.                         throw new java.util.NoSuchElementException();
    
95.                 }
    
96.                
    
97.                 else {
    
98.                
    
99.                         if (first.equals(last)) {
    
100.                                
     
101.                                 item = first.item;
     
102.                                
     
103.                                 first = null;
     
104.                                 last = null;
     
105.                         }
     
106.                        
     
107.                         else {
     
108.                        
     
109.                                 Node oldFirst = first;
     
110.                                
     
111.                                 item = oldFirst.item;
     
112.                                 first = oldFirst.next;
     
113.                                 first.previous = null;
     
114.                                 oldFirst = null;
     
115.                         }
     
116.                        
     
117.                         return item;
     
118.                 }
     
119.         }
     
120.        
     
121.         public Item removeLast() {
     
122.                
     
123.                 Item item;
     
124.                
     
125.                 if (this.isEmpty()) {
     
126.                        
     
127.                         throw new java.util.NoSuchElementException();
     
128.                 }
     
129.                
     
130.                 else {
     
131. 
     
132.                         if (first.equals(last)) {
     
133.                                
     
134.                                 item = last.item;
     
135.                                
     
136.                                 first = null;
     
137.                                 last = null;
     
138.                         }
     
139.                        
     
140.                         else {
     
141.                                
     
142.                                 Node oldLast = last;
     
143.                                 item = oldLast.item;
     
144.                                 last = oldLast.previous;
     
145.                                 last.next = null;
     
146.                                 oldLast = null;
     
147.                         }
     
148.                        
     
149.                         return item;
     
150.                 }
     
151.         }
     
152.        
     
153.         @Override
     
154.         public Iterator<Item> iterator() {
     
155.                
     
156.                 return new ListIterator();
     
157.         }
     
158.        
     
159.         public static void main(String[] args) {
     
160.                
     
161.                 Deque<String> deq = new Deque<String>();
     
162.                 deq.addFirst("world!");
     
163.                 deq.addFirst("Hello");
     
164.                 deq.iterator();
     
165.                 deq.removeFirst();
     
166.                 deq.iterator();
     
167.         }
     
168.        
     
169.         private Node first;
     
170.         private Node last;
     
171.        
     
172.         private class Node {
     
173.                
     
174.                 Item item;
     
175.                 Node next;
     
176.                 Node previous;
     
177.         }
     
178.        
     
179.         private class ListIterator implements Iterator<Item> {
     
180.                
     
181.                 private Node ptr;
     
182.                 private Item i;
     
183.                
     
184.                 public ListIterator() {
     
185.                        
     
186.                         ptr = first;
     
187.                 }
     
188.                
     
189.                 @Override
     
190.                 public boolean hasNext() {
     
191.                        
     
192.                         return (ptr != null);
     
193.                 }
     
194.                
     
195.                 @Override
     
196.                 public Item next() {
     
197.                        
     
198.                         if (!this.hasNext()) {
     
199.                                
     
200.                                 throw new java.util.NoSuchElementException();
     
201.                         }
     
202.                         else {
     
203.                        
     
204.                                 i = ptr.item;
     
205.                                 ptr = ptr.next;
     
206.                                
     
207.                                 return i;
     
208.                         }
     
209.                 }
     
210.                
     
211.                 public void remove() {
     
212.                        
     
213.                         throw new java.lang.UnsupportedOperationException();
     
214.                 }
     
215.         }
     
216. }
     

复制代码

我觉得问题是出在Iterator几个重写的函数上了。但是我看了一个通过的代码，和我的几乎是一模一样的。我百思不得其解，有会的同学请给我一些指教。

已经解决了 addFirst addLast函数少了else谢谢太阳神同志