Question

我正在为我的考试练习解决一些问题。我的教科书中的问题要求我反向打印圆形链表中的内容。所以我的想法是创建一个堆栈，将东西移动到堆栈然后弹出它。

这就是我所做的：

    public void reversePrint() {
   Stack stack = new Stack();

   Node<E> temp = list;
   do {
   stack.push(temp);
   temp = temp.getNext();
   } while (temp != list);

   while (!stack.empty()) {
   System.out.print(stack.pop());
   }
   }

circularlist.java

    public class CircularList<E> implements List<E> {

  Node<E> list;
  int size;

  public CircularList() {
    list = new Node(null);
    list.setNext(list);
    size = 0;
  }

  @Override
  public void add(E element) {
    Node<E> newNode = new Node(element);
    newNode.setNext(list.getNext());
    list.setNext(newNode);
    size++;
  }

  @Override
  public boolean remove(E element) {
    Node<E> location = find(element);
    if (location != null) {
      location.setNext(location.getNext().getNext());
      size--;
    }
    return location != null;
  }

  @Override
  public E get(E element) {
    Node<E> location = find(element);
    if (location != null) {
      return (E) location.getNext().getInfo();
    }
    return null;
  }

  @Override
  public boolean contains(E element) {
    return find(element) != null;
  }

  @Override
  public int size() {
    return size;
  }

  @Override
  public Iterator<E> iterator() {
    return new Iterator<E>() {
      Node<E> tmp = list.getNext();

      @Override
      public boolean hasNext() {
        return tmp != list;
      }

      @Override
      public E next() {
        E info = tmp.getInfo();
        tmp = tmp.getNext();
        return info;
      }

      @Override
      public void remove() {
        throw new UnsupportedOperationException("Not supported yet.");
      }
    };
  }

  protected Node<E> find(E element) {
    Node<E> tmp = list;
    while (tmp.getNext() != list && !tmp.getNext().getInfo().equals(element)) {
      tmp = tmp.getNext();
    }

    if (tmp.getNext() == list) {
      return null;
    } else {
      return tmp;
    }

}

Node.java

public class Node<E> {

  E info;
  Node<E> next;

  public Node(E element) {
    info = element;
    next = null;
  }

  public void setInfo(E element) {
    info = element;
  }

  public E getInfo() {
    return info;
  }

  public void setNext(Node<E> next) {
    this.next = next;
  }

  public Node<E> getNext() {
    return next;
  }
}

我的问题是我不能用。我需要一个不同的解决方案。有什么帮助吗？

Answer 1

我假设您自己编写了LinkedList（使用Node<T>类）。

如果列表是双重链接的：

从列表中的最后一个元素开始（如果你没有存储对尾部的引用迭代节点直到到达最后一个）并使用getPrevious()遍历列表（与{{1相反）被命名）。

如果列表是单链接的：

您可以递归遍历列表并在展开时打印元素，而不是使用堆栈。

getNext()

这很简单，但效率不高。如果列表包含太多元素，您甚至可能会遇到递归深度太深的问题。

*编辑：固定终止条件

Answer 2

如果您“被允许”使用while循环，则可以使用do将break循环转换为该循环：

while (true) {
    stack.push(temp);
    temp = temp.getNext();
    // If we're back to the beginning, we're done
    if (temp == list) {
        break;
    }
}

或者如果你可以使用size，那就更容易了：

Node<E> temp = list;
for (int i = 0; i < size; i++) {
    stack.push(temp);
    temp = temp.getNext();
}

从循环链表创建堆栈以反向打印列表

2 个答案: