如何通过将链表引用作为参数传递来反向递归打印链表[作业]

Question

对于这个分配，我需要以链表作为参数，而不是节点，以递归方式反向打印链表。

我还必须使用我的教授提供的这个 SinglyLinkedList 类：

 public class SinglyLinkedList<E> {
  private int length; // # elements in the linked list
  private SLNode<E> head; // access point to the linked list
  private SLNode<E> tail;

  public SinglyLinkedList() {
    this.length = 0;
    this.tail = new SLNode<E> (); // the tail dummy node
    this.head = new SLNode<E> ( null, this.tail ); // the head dummy node
  }

  public int getLength() {
    return this.length;
  }

  public void add( E e ) {
    SLNode<E> newnode = new SLNode<E> ( e, null );
    newnode.setSuccessor( this.head.getSuccessor() );
    this.head.setSuccessor( newnode );
    this.length++;
  }

  public void add( E e, int p ) {
    // verify that index p is valid
    if ( ( p < 0 ) || ( p > this.length ) ) {
      throw new IndexOutOfBoundsException( "index " + p
                                           + " is out of range: 0 to " +
                                           this.length );
    }
    SLNode<E> newnode = new SLNode<E> ( e, null );
    SLNode<E> cursor = this.head;
    for ( int i = 0; i < p; i++ ) {
      cursor = cursor.getSuccessor();
    }
    addAfter( cursor, newnode );
    this.length++;
  }

  public E remove( int p ) {
    if ( ( p < 0 ) || ( p >= this.length ) ) {
      throw new IndexOutOfBoundsException( "index " + p
                                           + " is out of range: 0 to " +
                                           ( this.length - 1 ) );
    }
    SLNode<E> cursor = head; // good for p == 0
    if ( p > 0 ) {
      cursor = find( p - 1 ); // get target's predecessor
    }

    SLNode<E> target = cursor.getSuccessor(); // get the node to remove

    // link target to cursor's successor
    cursor.setSuccessor( target.getSuccessor() );
    target.setSuccessor( null );
    cursor.setElement( null );
    this.length--;
    return target.getElement();
  }

  public E getElementAt( int p ) {
    SLNode<E> node = this.find( p );
    return node.getElement();
  }

  private void addAfter( SLNode<E> p, SLNode<E> newnode ) {
    newnode.setSuccessor( p.getSuccessor() );
    p.setSuccessor( newnode );
  }

  private SLNode<E> find( E target ) {
    SLNode<E> cursor = head.getSuccessor();

    while ( cursor != tail ) {
      if ( cursor.getElement().equals( target ) ) {
        return cursor; // success
      }
      else {
        cursor = cursor.getSuccessor();
      }
    }
    return null; // failure
  }

  private SLNode<E> find( int p ) {
    if ( ( p < 0 ) || ( p >= this.length ) ) {
      throw new IndexOutOfBoundsException();
    }

    SLNode<E> cursor = head.getSuccessor();
    int i = 0;

    while ( i != p ) {
      cursor = cursor.getSuccessor();
      i++;
    }

    return cursor;
  }

}

我不知道如何通过传入对单链表而不是节点的引用来编写该方法。提前感谢您的帮助！

Answer 1

基本情况是列表为空，没有可打印的内容。这就是我们首先检查的内容。如果满足基本情况，我们将返回而不打印任何内容。否则列表中还有剩余元素，因此我们从列表中取出最后一个元素（因为我们正在反向打印）并将其从列表中弹出。 remove 方法返回删除的元素，这样就可以解决问题。现在我们使用修改后的列表（减去最后一个元素）进行递归。最终列表将是空的，并且所有元素都将被反向打印。

public static <E> void printReverse(final SinglyLinkedList<E> list) {
    if(list.getLength() > 0) {
        System.out.println(list.remove(list.getLength()-1));
        printReverse(list);
    }
}

Answer 2

没有深入研究你的代码，但简单的打印应该很简单：

在伪代码中：

printLinkedListInReverse(node) {
   if (node has no next) {
       print out node itself
   } else {
       printLinkedListInReverse(node's next)
       print out node itself
   }
}

简而言之，要反向打印，您要先打印出不包括自身的剩余列表，然后打印节点本身

---

如果抓不到内部节点，对链表进行修改，方法还是类似的：

printLinkedListInReverse(list) {
   if (list is empty) {
       //do nothing
   } else {
       firstElement = list.remove(0)
       printLinkedListInReverse(list)  // print the remaining list first
       print firstElement
   }
}