2015-08-09 46 views
0

我在完全实现入队和出队部分时遇到了问题。这里的结果,我试图让:Java中的离队

DEQUE TESTING 

The size of the deque is: 3 

The deque contains: 

4 9 8 

4 

8 

9 

1 

11 

The size of the deque is: 2 

The deque contains: 


11 1 

,但是这是我得到:

DEQUE TESTING 
The size of the deque is: 3 
The deque contains: 
4 9 8 
4 
null 
null 
null 
null 
The size of the deque is: 0 
The deque contains: 

所以,它只能打印速度达到某个点。为了纠正这个问题,我已经多次尝试了我的代码(实际上很多),但我无法确定问题出在哪里。我有一种感觉,它需要改变一些微小的东西。

这里是我的代码:

public class Murray_A06Q3 { 
    public static void main(String[] args) { 

     LinkedDeque<Integer> deque = new LinkedDeque<Integer>(); 

     System.out.println("DEQUE TESTING"); 

     deque.enqueueBack(3); 
     deque.enqueueBack(7); 
     deque.enqueueBack(4); 
     deque.dequeueFront();   
     deque.enqueueBack(9); 
     deque.enqueueBack(8); 
     deque.dequeueFront(); 

     System.out.println("The size of the deque is: " + deque.size()); 
     System.out.println("The deque contains:\n" + deque.toString()); 

     System.out.println(deque.dequeueFront());   

     deque.enqueueFront(1); 
     deque.enqueueFront(11);       
     deque.enqueueFront(3);     
     deque.enqueueFront(5);   

     System.out.println(deque.dequeueBack()); 
     System.out.println(deque.dequeueBack());   
     System.out.println(deque.last());     

     deque.dequeueFront(); 
     deque.dequeueFront();   

     System.out.println(deque.first());   
     System.out.println("The size of the deque is: " + deque.size()); 
     System.out.println("The deque contains:\n" + deque.toString());    

    } // End of main method 

public static class LinkedDeque<T> implements DequeADT<T> { 

    private int count; 
    private LinearDoubleNode<T> firstNode, lastNode; 

// constructor 
    public LinkedDeque(){ 

     count = 0; 
     firstNode = null; 
     lastNode = null; 

    } // end of constructor 

// Beginning of enqueueFront 
    public void enqueueFront(T element) { 
     LinearDoubleNode newNode = new LinearDoubleNode(); 

     if(isEmpty()){ 
      lastNode = newNode; 
      count++; 
     } 
     else 
      firstNode.setPrev(newNode); 
     firstNode = newNode; 
     count--; 

    } // end of enqueFront 

// Beginning of enqueueBack 
    public void enqueueBack(T element) { 
     LinearDoubleNode<T> node = new LinearDoubleNode<T>(element); 

     if (isEmpty()) 
      firstNode = node; 
     else 
      lastNode.setNext(node); 

     lastNode = node; 
     count++; 

    } // end of enqueueBack 

// Beginning of dequeueFront 
    public T dequeueFront() { 

     T front = null; 
     if (!isEmpty()) { 
      front = firstNode.getElement(); 
      firstNode = firstNode.getNext(); 
      count--; 

      if (firstNode == null) { 
       lastNode = null; 
      } 
      else 
       firstNode.setPrev(firstNode); 
     } 
     return front; 

    } // end of dequeueFront 

// Beginning of dequeueBack 
    public T dequeueBack() { 

     T back = null; 
     if (!isEmpty()) { 
      back = lastNode.getElement(); 
      lastNode = lastNode.getPrev(); 

      if (lastNode == null) { 
       firstNode = null; 
      } 
      else 
       lastNode.setNext(null); 
     } 
     return back; 

    } // end of dequeueBack() 

    public T first() { 
     return firstNode.getElement(); 
    } 

    public T last() { 
     return lastNode.getElement(); 
    } 

// Beginning of isEmpty()   
    public boolean isEmpty() { 

     if (count == 0) { 
      return true; 
     }  
     else 
      return false; 

    } // End of isEmpty() 

// Beginning of size()   
    public int size() { 
     return count; 
    } 

// Begin of toString() method   
    public String toString() { 

     if (isEmpty()) { 
      return " "; 
     } 

     StringBuilder sb = new StringBuilder(); 
     LinearDoubleNode<T> next = firstNode; 

     while(next != null){ 
      sb.append(" ").append(next.getElement()); 
      next = next.getNext(); 
     } 

     return sb.toString(); 

    } // End of toString() 

    } // End of LinkedDeque 

} // End of class header 
+0

提示:(1)'count - '在'enqueueFront'没有任何意义。 (2)在两个'enqueue'中,你都需要调用'setPrev'和'setNext',因为它是一个双向链表。 – dejvuth

回答

1

您忘了设置上一个元素和元素。当你增加计数时你也有一些错误。关注一些不被抛出的异常。尽管如此,它现在应该是直截了当的。你有下面的工作代码与所需的输出:

public static class LinkedDeque<T> { 

     private int count; 
     private LinearDoubleNode<T> firstNode, lastNode; 

     // constructor 
     public LinkedDeque(){ 

      count = 0; 
      firstNode = null; 
      lastNode = null; 

     } // end of constructor 

     // Beginning of enqueueFront 
     public void enqueueFront(T element) { 
      LinearDoubleNode newNode = new LinearDoubleNode(); 
      newNode.setElement(element); 
      if(isEmpty()){ 

       lastNode = newNode; 
       firstNode = newNode; 
      } 
      else { 
       LinearDoubleNode second=firstNode; 
       firstNode=newNode; 
       firstNode.setNext(second); 
       second.setPrev(firstNode); 
       // firstNode.setPrev(newNode); 

      } 

      count++; 

     } // end of enqueFront 

     // Beginning of enqueueBack 
     public void enqueueBack(T element) { 
      if (element==null) throw new NullPointerException("cannot add null to the list"); 

      LinearDoubleNode<T> node = new LinearDoubleNode<T>(element); 
      node.setElement(element); 
      if (isEmpty()){ 
       firstNode = node; 
       lastNode=node;} 
      else{ 
       LinearDoubleNode<T> before=lastNode; 
       lastNode=node; 
       before.setNext(lastNode); 
       lastNode.setPrev(before); 
      } 


      count++; 

     } // end of enqueueBack 

     // Beginning of dequeueFront 
     public T dequeueFront() { 

      T front = null; 
      if (count==1){ 
       front=firstNode.getElement(); 
       firstNode=null; 
       lastNode=null; 
       count--; 
      } 
      else if (!isEmpty()) { 
       count--; 
       front = firstNode.getElement(); 
       firstNode = firstNode.getNext(); 
      } 

      return front; 

     } // end of dequeueFront 

     // Beginning of dequeueBack 
     public T dequeueBack() { 

      T back = null; 
      if (count==1){ 
       back = lastNode.getElement(); 
       lastNode = null; 
       firstNode = null; 
       count--; 
      } 
      else if (!isEmpty()) { 
       count--; 
       back = lastNode.getElement(); 
       lastNode = lastNode.getPrev(); 
       lastNode.setNext(null); 
      } 
      return back; 

     } // end of dequeueBack() 

     public T first() { 
      return firstNode.getElement(); 
     } 

     public T last() { 
      return lastNode.getElement(); 
     } 

     // Beginning of isEmpty() 
     public boolean isEmpty() { 

      return count==0; 

     } // End of isEmpty() 

     // Beginning of size() 
     public int size() { 
      return count; 
     } 

     // Begin of toString() method 
     public String toString() { 

      if (isEmpty()) { 
       return " "; 
      } 

      StringBuilder sb = new StringBuilder(); 
      LinearDoubleNode<T> next = firstNode; 

      while(next != null){ 
       sb.append(" ").append(next.getElement()); 
       next = next.getNext(); 
      } 

      return sb.toString(); 

     } // End of toString() 

    } // End of LinkedDeque 

} // End of class header 

    DEQUE TESTING 
The size of the deque is: 3 
The deque contains: 
4 9 8 
4 
8 
9 
1 
11 
The size of the deque is: 2 
The deque contains: 
11 1 
+0

感谢您的帮助!我错了,它只是稍微调整一点而已。 – mur7ay

0

一个双向链表的第一条规则是,你必须保持链接,当你添加的元素。这是你的代码:

public void enqueueFront(T element) { 
    LinearDoubleNode newNode = new LinearDoubleNode(); 

    if(isEmpty()){ 
     lastNode = newNode; 
     count++; 
    } 
    else 
     firstNode.setPrev(newNode); 
    firstNode = newNode; 
    count--; 

} // end of enqueFront 

首先,你永远不会把你的元素的值放入新的节点。

其次,队列应该像

A ⇆ B ⇆ C 

但是让我们看看当你在队列中只有一个“B”你怎么加一个“A”。您的firstNode是“B”,并且您将它的prev设置为setPrev以指向您的“A”。

A ← B 

但是,您不要从新的“A”链接回“B”。这意味着当你需要从正面看队列时,它似乎只有一个元素--A没有“下一个”!

else条款应该是:

else { 
     firstNode.setPrev(newNode); 
     newNode.setNext(firstNode); 
    } 

然后你就可以从两侧横穿名单。同样的逻辑也应该适用于你的enqueueBack

现在,你出列的逻辑:

public T dequeueFront() { 

    T front = null; 
    if (!isEmpty()) { 
     front = firstNode.getElement(); 
     firstNode = firstNode.getNext(); 
     count--; 

     if (firstNode == null) { 
      lastNode = null; 
     } 
     else 
      firstNode.setPrev(firstNode); 
    } 
    return front; 

} 

现在,你出列后,您设置的新firstNode的本身。这意味着你可能有一个无限循环。在完成一次后,如果您尝试通过从后面出队来走“prev”链接,则只会一次又一次地获得相同的节点。反向链接应设置为null(顺便说一下,您在dequeueBack中正确执行)。