Question

我应该将元素从堆栈复制到队列中。

我无法想出一种方法来保持堆栈的方式，并仍然将其元素复制到队列中。

我最终使用此方法从堆栈中完全删除元素并将它们添加到队列中：

public void CopyFromStack(){
E t;
int c = w.size();
while(c != 0){
t = w.pop();
enqueue(t);
c--;  }}

尝试推回元素不是一种选择，因为它会向后执行。

编辑：这是包含我的方法的类，它是我的队列类：

public class Queue<E> {
protected int size;
protected Node<E> head;
protected Node<E> tail;
NodeStack<E> w = new NodeStack<E>();
NodeStack<E> w2 = new NodeStack<E>();

public Queue(){
    size = 0;
    head = tail = null;}

public boolean isEmpty(){
    return size==0;}

public void enqueue(E elem) { 
Node<E> node = new Node<E>(); 
node.setElement(elem); 
node.setNext(null); 
if (size == 0) head = node; 
else tail.setNext(node);
tail = node; 
size++;  }

public E dequeue() {
if (size == 0) System.out.print("Queue is empty."); 
E tmp = head.getElement(); 
head = head.getNext(); 
size--;
if (size == 0) tail = null; 
return tmp; } 

public String toString(){
    String s = "";
    E t;
    int c = size;
    while(c != 0){
        t = dequeue();
        s += t + " ";
        enqueue(t);
        c--; }
    return s;}

public int FindItem(E elem){
    int index=0;
    int c = size;
    E t;
while(c != 0){
t = dequeue();
if (t == elem)
return index;
else index++;
c--;}
System.out.print("Not found!");
return -1;}

public void CopyToStack(){
System.out.print("Elements copied to the stack are: ");
E t;
int c = size;
while(c != 0){
t = dequeue();        
w.push(t);
enqueue(t);
c--;
System.out.print(w.pop()+" "); }}

public void CopyFromStack(){
E t;
int c = w.size();
while(c != 0){
t = w.pop();
enqueue(t);
c--;  }}

Answer 1

问：我还没有想过一种方法来保持堆栈的方式A：

答：那是因为从经典＆＃34;经典＆＃34;堆栈是破坏性的。＆＃34;读＆＃34;元素== 从堆栈中删除该元素。

两个解决方案：

1）修改你的堆栈实现，以便你可以偷看＆＃34;每个元素

......或......

2）创建一个包含第一个元素的新堆栈。

问：我最终得到了这种方法......试图推回元素不是一种选择，因为它会向后做。

＆＃34;答：这是＆＃34;选项2）的变体：上面。

解决方案：只需创建一个 new 堆栈对象，并在排队元素的同时推送每个元素。

PS：

Stack的标准JRE实施包括peek()和search()方法。但我不认为他们会帮助你。如果您想要＆＃34;选项1）＆＃34;，您必须实现自己的自定义堆栈。

==================更新==================

请注意：

你应该总是缩进你的方法，并缩进你的＆＃34;如果＆＃34;和＆＃34;循环＆＃34;方法中的块。
你应该使用＆＃34; camel-case＆＃34; （方法名称小写的第一个字母）。

以下是＆＃34;官方＆＃34; Java编码约定。它们在1995年很有用;他们今天很有用：

http://www.oracle.com/technetwork/java/index-135089.html

实际上是第三个选项：Java＆＃34; Stack＆＃34;碰巧实现＆＃34; iterator＆＃34;。这是一个例子：

示例代码：

package com.testcopy;

import java.util.ArrayDeque;
import java.util.Iterator;
import java.util.Queue;
import java.util.Stack;

public class TestCopy {

    public static void main (String[] args) {

        TestCopy app = new TestCopy ();
        app.run ();
    }

    public void run () {
        // Create and populate stack
        Stack<String> myStack = new Stack<String> ();
        mkData(myStack);

        // Copy to queue
        Queue<String> myQueue = new ArrayDeque<String> ();
        copyFromStack (myStack, myQueue);

        // Print 
        int i=0;
        for (String s : myQueue) {
            System.out.println ("myQueue[" + i++ + "]: " + s);
        }
    }

    @SuppressWarnings("unchecked")
    public void mkData (Stack stack) {
        stack.push("A");
        stack.push("B");
        stack.push("C");
        // Stack should now contain C, B, A
    }

    public void copyFromStack (Stack stack, Queue queue) {
        @SuppressWarnings("rawtypes")
        Iterator it = stack.iterator ();
        while (it.hasNext()) {
            queue.add(it.next());
        }
    }
}

示例输出：

myQueue[0]: A
myQueue[1]: B
myQueue[2]: C

将元素从堆栈复制到队列

1 个答案: