将元素从堆栈复制到队列

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：

A：那是因为从“经典”堆栈中读取是破坏性。 “读取”一个元素 == 从堆栈中移除该元素。

两种解决方案：

1) 修改您的堆栈实现，以便您可以“窥视”每个元素

...或...

2) 创建一个新堆栈，其中包含第一个堆栈中的所有元素。

问：我最终采用了这种方法...尝试将元素向后推不是一种选择，因为它会向后推。

“A：这是“选项 2）的变体：上面。

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

PS：

Stack 的标准 JRE 实现包括 peek() 和 search() 方法。但我不认为他们会在这里帮助你。如果您想要“选项 1)”，则必须实现自己的自定义堆栈。

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

请注意：

1. 您应该始终缩进您的方法，并在您的方法中缩进您的“if”和“loop”块。

2. 您应该使用“camel-case”（小写首字母）作为方法名称。

这里是“官方”Java 编码约定。它们在 1995 年很有用；它们今天很有用：

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

实际上还有一个第三个​​选项：Java 的“堆栈”恰好实现了“迭代器”。这是一个例子：

示例代码：

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