java中的链表栈答案

【问题标题】：linked list stack in javajava中的链表栈
【发布时间】：2013-11-22 19:46:18
【问题描述】：

我正在尝试在 Java 中实现一个链表样式堆栈（不使用内置的明显方式）。 push 操作很简单，但是 pop 操作很麻烦。我很清楚，将“弹出”值返回给调用者，并同时调整链表会很有用，但这似乎不起作用。

public class ListElement {

/* constructor */
public ListElement(Integer data) {
    value = data;
}

/* next pointer and the data */
private ListElement next;
private Integer value;

/* gets the next element */
public ListElement getNext() {
    return next;
}

/* gets the data */
public Integer getValue() {
    return value;
}

/* sets the next element */
public void setNext(ListElement elem) {
    next = elem;
}

/* sets the data */
public void setValue(Integer data) {
    value = data;
}

/* prints out the list */
public void printList(ListElement head) {
    String listString = "";
    ListElement elem = head;
    while (elem != null) {
        listString = listString + elem.getValue().toString() + " ";
        elem = elem.getNext();
    }
    System.out.println(listString);
}

/* inserting at the front */
public ListElement push(ListElement head, Integer data) {
    ListElement elem = new ListElement(data);
    elem.setNext(head);
    return elem;
}

/* pop the first element */
public Integer pop (ListElement head){
    Integer popped = head.getValue();
    head = head.getNext();

    return popped;
}

 public static void main(String[] args) {



    System.out.println("Constructing List with 2 ...");
    ListElement myList = new ListElement(2);
    myList.printList(myList);

    System.out.println("Adding 1 to beginning ...");
    myList = myList.push(myList, 1);
    myList.printList(myList);

    System.out.println("Adding 0 to beginning ...");
    myList = myList.push(myList, 0);
    myList.printList(myList);

    System.out.println("Pop ...");
    Integer popped =  myList.pop(myList);
    System.out.println("Value is " + popped);
    myList.printList(myList);
      }

 }

【问题讨论】：

什么不起作用？你能具体说一下吗？
pop 函数不起作用，它从头节点返回值，但如下所述，我显然只是修改了“头”的局部变量，因此第一个节点不会被删除。它可以在我想象的两个函数中完成，这样第一个函数“获取”值，第二个函数在保存值后“删除”第一个节点，但这并不像我那样优雅想要。
以下所有四个答案都正是我们所需要的。将元素与堆栈/列表对象分离解决了所有问题并使实现变得非常容易。

标签： java linked-list stack

【解决方案1】：

您可以找到正确的实现here。

你的代码有什么问题：

/* pop the first element */
public Integer pop (ListElement head){
    Integer popped = head.getValue();
    head = head.getNext();
    return popped;
}

您修改了仅在您的函数本地的head 元素。

您需要将代码分成两个类：

ListElement：将只包含值/下一个信息，

public class ListElement {
     ListElement next;
     Integer value;
}

LinkedStack：将至少包含堆栈函数（push/pop），以及对堆栈的第一个 ListElement 的引用。调用pop函数时需要更新的是这个引用。

public class LinkedStack {

     private ListElement first;

     public void push(Integer item) {
         ListElement oldfirst = first;
         first = new ListElement();
         first.value= item;
         first.next = oldfirst;
     }


     public Integer pop() {
         Integer item = first.value;      
         first = first.next;           
         return item;                 
     }
}

【讨论】：

【解决方案2】：

通常在像您这样的结构中，您有两个类，一个是ListElement，另一个是List。我认为名称 StackElement 和 Stack 会更好，但是，继续前进....

问题在于 Java 在您的 pop 方法中，正如您所怀疑的那样：

/* pop the first element */
public Integer pop (ListElement head){
    Integer popped = head.getValue();
    head = head.getNext();
    return popped;
}

还要在main方法中：

System.out.println("Pop ...");
Integer popped =  myList.pop(myList);

这里的问题是您希望 myList 使用 pop() 方法中修改后的值 head.getNext() 进行更新。

这不会发生....当您调用 pop() 并且 head = head.getNext() 行不会更改 myList 我们旁边的 pop() 时，Java 会创建对 myList 的不同“引用”。

这种情况通常通过第二个类来解决，称之为“列表”（或者如我所说，应该是Stack）...

public class Stack() {
    private StackElement head = null;
    public push(Integer value) {
        StackElement topush = new StackElement(value);
        topush.setNext(head);
        head = topush;
    }
    public Integer pop() {
        StackElement topop = head;
        if (head != null) {
            head = topop.getNext();
            return topop.getValue();
        }
        return null;
    }
}

然后，在你的 main 方法中，你应该使用这个新的 Stack 类：

Stack stack = new Stack();
stack.push(2);
....

【讨论】：

【解决方案3】：

你说的不是在修改 myList

head = head.getNext();

你只是在 pop 方法中修改一个局部变量。

我最喜欢的解决方案是将“列表”和“元素”完全分开，就像两个单独的文件一样。那么事情应该开始变得更有意义了。

列表

头部（元素类型）

元素

下一个（元素类型）
值（整数类型）

【讨论】：

【解决方案4】：

通常对于这样的链接列表，您需要一个包含对堆栈顶部的引用的 Header 或 LinkedList 类。

它将有一个字段ListElement top 和函数pop 和push。

push 正如您所料，只需将 start 设置为新的 ListElement 并且该元素的 next 等于旧的 start。

pop 只是返回 start 元素的值并设置 start = start.getNext() 从而移除顶部。

【讨论】：