有人可以解釋我在Java中使用鏈接列表堆棧的以下實現嗎？

Question

有人可以解釋我在Java中使用鏈接列表堆棧的以下實現嗎？這個鏈接是這樣的：http://algs4.cs.princeton.edu/13stacks/LinkedStack.java.html這是代碼：

 public class LinkedStack<Item> implements Iterable<Item> { 
    private int N;   // size of the stack 
    private Node first;  // top of stack 

    // helper linked list class 
    private class Node { 
     private Item item; 
     private Node next; 
    } 

    /** 
    * Initializes an empty stack. 
    */ 
    public LinkedStack() { 
     first = null; 
     N = 0; 
     assert check(); 
    } 

    /** 
    * Is this stack empty? 
    * @return true if this stack is empty; false otherwise 
    */ 
    public boolean isEmpty() { 
     return first == null; 
    } 

    /** 
    * Returns the number of items in the stack. 
    * @return the number of items in the stack 
    */ 
    public int size() { 
     return N; 
    } 

    /** 
    * Adds the item to this stack. 
    * @param item the item to add 
    */ 
    public void push(Item item) { 
     Node oldfirst = first; 
     first = new Node(); 
     first.item = item; 
     first.next = oldfirst; 
     N++; 
     assert check(); 
    } 

    /** 
    * Removes and returns the item most recently added to this stack. 
    * @return the item most recently added 
    * @throws java.util.NoSuchElementException if this stack is empty 
    */ 
    public Item pop() { 
     if (isEmpty()) throw new NoSuchElementException("Stack underflow"); 
     Item item = first.item;  // save item to return 
     first = first.next;   // delete first node 
     N--; 
     assert check(); 
     return item;     // return the saved item 
    } 


    /** 
    * Returns (but does not remove) the item most recently added to this stack. 
    * @return the item most recently added to this stack 
    * @throws java.util.NoSuchElementException if this stack is empty 
    */ 
    public Item peek() { 
     if (isEmpty()) throw new NoSuchElementException("Stack underflow"); 
     return first.item; 
    } 

    /** 
    * Returns a string representation of this stack. 
    * @return the sequence of items in the stack in LIFO order, separated by spaces 
    */ 
    public String toString() { 
     StringBuilder s = new StringBuilder(); 
     for (Item item : this) 
      s.append(item + " "); 
     return s.toString(); 
    } 

    /** 
    * Returns an iterator to this stack that iterates through the items in LIFO order. 
    * @return an iterator to this stack that iterates through the items in LIFO order. 
    */ 
    public Iterator<Item> iterator() { return new ListIterator(); } 

    // an iterator, doesn't implement remove() since it's optional 
    private class ListIterator implements Iterator<Item> { 
     private Node current = first; 
     public boolean hasNext() { return current != null;      } 
     public void remove()  { throw new UnsupportedOperationException(); } 

     public Item next() { 
      if (!hasNext()) throw new NoSuchElementException(); 
      Item item = current.item; 
      current = current.next; 
      return item; 
     } 
    } 


    // check internal invariants 
    private boolean check() { 
     if (N == 0) { 
      if (first != null) return false; 
     } 
     else if (N == 1) { 
      if (first == null)  return false; 
      if (first.next != null) return false; 
     } 
     else { 
      if (first.next == null) return false; 
     } 

     // check internal consistency of instance variable N 
     int numberOfNodes = 0; 
     for (Node x = first; x != null; x = x.next) { 
      numberOfNodes++; 
     } 
     if (numberOfNodes != N) return false; 

     return true; 
    } 

    /** 
    * Unit tests the <tt>LinkedStack</tt> data type. 
    */ 
    public static void main(String[] args) { 
     LinkedStack<String> s = new LinkedStack<String>(); 
     while (!StdIn.isEmpty()) { 
      String item = StdIn.readString(); 
      if (!item.equals("-")) s.push(item); 
      else if (!s.isEmpty()) StdOut.print(s.pop() + " "); 
     } 
     StdOut.println("(" + s.size() + " left on stack)"); 
    } 
} 

一切除了需要check()方法的明確。我不明白的是，爲什麼在每次操作後（即pop,peek），我們需要檢查堆棧中元素的數量和變量N（堆棧的大小）是否一致。我們不是始終保持這兩個值一致嗎？我真的不知道check()方法有什麼用處？

Answer 1

上述check()方法僅用於assertions。

斷言可以提供預期不變量的實時檢查。它們默認是禁用的。

您可以通過enable assertions來檢測錯誤或調試，通常在開發環境中。