Java-我正在将堆栈链表修改为队列链表，但我的出列方法的行为仍然类似于pop

private Node back

尚未使用，并且除了重命名某些内容外，

enqueue

（推送）和

dequeue

（弹出）尚未真正修改。同样，这最初是一个堆栈，但我正试图将其修改为一个队列。我以前用

int

s做过非链表队列和堆栈，但是用对象和链表我有点迷路了

public class DogQueue 
{
    private Node front = null;
    private Node back = null;
    private Node element = null;
    private int counter = 0;

以上只是设置变量

  private class Node //This sets up the Linked List
                     //Data Structure with nodes.
  {
      private Dog doggy;
      private Node nextNode;
      private Node firstNode;

      Node(Dog newDog)
      {
          doggy = newDog;
      }    
  }

上面是我不太理解的节点内容

  public void enqueue(Dog aDog) //This should enqueue
                                //an object of type Dog.
  {       
      Node dogNode = new Node(aDog);
      dogNode.nextNode = front;
      counter++;
      front = dogNode;
  }

这里的上述内容未经push方法修改，只是重命名了

  public Dog dequeue()      //This should output
                            //the first entry in the list.
  {
      Dog firstDog = front.doggy;
      element = front.firstNode;
      counter--;
      return firstDog;
  }

以上是我遇到最多问题的地方——目前它的行为类似于pop（获取和删除列表中最后输入的元素）

我将计数器设置为刚好上升到5，这样我就可以调试isFull了

  public boolean isEmpty()  //Checks to see if List is empty
  {
      if ( counter == 0 )
        {
            return true;
        } else {
            return false;
        }
  }

这只是说，若计数器为零，则isEmpty为真（否则为假）

---

我不擅长数据结构，但我相信你的排队和出列行为仍然像pop和push一样。 前面应该指向队列的头部，后面应该指向最后一个有效对象。因此尾部最终应该指向null。。 我认为应该是这样的：

  public void enqueue(Dog aDog)
     {
         Node dogNode = new Node(aDog);

         counter++;
         if (front == null)
             front = back = dogNode;
         else
         {
             back.nextNode = dogNode;
             back = dogNode;

         }
     }
  public Node dequeue()      
  {
      if(front == null) return null;
      Dog firstDog = front ;
      front = front.nextNode;
      counter--;
      return firstDog;
  }

public void enqueue(Dog aDog) {
    if(front == null) {
        front = new Node(aDog);
        back = front; // back will move later
    } else {
        Node tmp = new Node(aDog);
        tmp.setFirstNode(back);
        back.setNextNode(tmp);
        back = tmp;
    }
}

public Dog dequeue() {
    if(head == null) {
        return null;
    } else {
        Dog tmp = front.getDoggy()
        front = front.getNextNode(); //move the front to point to the next location
        front.getFirstNode().setNextNode(null); //sever the link to the first element 
        front.setFirstNode(null); //sever the link to the first element
        return tmp;
    }
}

---

这是主要问题。队列是FIFO（先进先出），堆栈是LIFO（后进先出）。对于队列，您排队的第一个元素是您接收的第一个元素，最近推到堆栈上的元素是您接收的第一个元素

为此，让我们稍微检查一下您的代码

  public void enqueue(Dog aDog) { //This should enqueue an object of type Dog.
      Node dogNode = new Node(aDog);
      dogNode.nextNode = front;
      counter++;
      front = dogNode;
  }

您正在将新dog元素的下一个节点设置到前面。您必须转到队列的末尾，将最近的节点设置为新节点，将新节点设置为null。使用您的代码，它看起来像这样：

  public void enqueue(Dog aDog)
     {
         Node dogNode = new Node(aDog);

         counter++;
         if (front == null)
             front = back = dogNode;
         else
         {
             back.nextNode = dogNode;
             back = dogNode;

         }
     }
  public Node dequeue()      
  {
      if(front == null) return null;
      Dog firstDog = front ;
      front = front.nextNode;
      counter--;
      return firstDog;
  }

public void enqueue(Dog aDog) {
    if(front == null) {
        front = new Node(aDog);
        back = front; // back will move later
    } else {
        Node tmp = new Node(aDog);
        tmp.setFirstNode(back);
        back.setNextNode(tmp);
        back = tmp;
    }
}

public Dog dequeue() {
    if(head == null) {
        return null;
    } else {
        Dog tmp = front.getDoggy()
        front = front.getNextNode(); //move the front to point to the next location
        front.getFirstNode().setNextNode(null); //sever the link to the first element 
        front.setFirstNode(null); //sever the link to the first element
        return tmp;
    }
}

---

至少，这确实显示了队列中的第一件事。但它实际上并没有移动头部指针！使用您的代码，要做到这一点，它将如下所示：

  public void enqueue(Dog aDog)
     {
         Node dogNode = new Node(aDog);

         counter++;
         if (front == null)
             front = back = dogNode;
         else
         {
             back.nextNode = dogNode;
             back = dogNode;

         }
     }
  public Node dequeue()      
  {
      if(front == null) return null;
      Dog firstDog = front ;
      front = front.nextNode;
      counter--;
      return firstDog;
  }

public void enqueue(Dog aDog) {
    if(front == null) {
        front = new Node(aDog);
        back = front; // back will move later
    } else {
        Node tmp = new Node(aDog);
        tmp.setFirstNode(back);
        back.setNextNode(tmp);
        back = tmp;
    }
}

public Dog dequeue() {
    if(head == null) {
        return null;
    } else {
        Dog tmp = front.getDoggy()
        front = front.getNextNode(); //move the front to point to the next location
        front.getFirstNode().setNextNode(null); //sever the link to the first element 
        front.setFirstNode(null); //sever the link to the first element
        return tmp;
    }
}

---

你是对的，我以为push的行为像排队一样，但我错了。因此，是的，它们的行为就像在堆栈中一样。编辑：这段代码正确地退出队列，但当我再次尝试退出队列时，它返回一个错误。另外，非常感谢你的帮助。是的，我想你必须检查空值。我忘了。将更新答案。您的返回声明中缺少某些内容。不幸的是，我在链表中迷失了方向，无法填写。我需要花一些时间研究代码，以弄清楚到底发生了什么。return null:D我希望它能起作用：）我也讨厌数据结构：（嗯，在你发帖子逗我笑之前，我试过返回null，但它仍然不能让我第二次排队。另外，我认为“front”应该是“front.doggy”。非常感谢您的帮助，Makoto。对于我的第一篇帖子，StackOverflow非常慷慨。再次感谢。我将试用您的代码并返回。我需要在Node中定义方法getNextNode、get firstNode、setFirstNode和setNextNode，对吗？@instago:是的，您必须定义我使用的帮助器方法。它们遵循f行业中使用的吸气剂和沉降剂。