Java 不使用“复制堆栈或队列”；克隆；

复制堆栈和队列而不使用克隆。例如，当我调用一个传递堆栈的方法时，我不能修改并保持原始堆栈的传递。我需要复制/克隆传递的堆栈，以便在方法中更改/使用

我只能使用Stack.java（附件）。我创建了以下帮助器方法：

public static Stack<CalendarDate> qToS(Queue<CalendarDate> q) {
    Stack<CalendarDate> s = new Stack<CalendarDate>();
    while (!q.isEmpty()) {
       CalendarDate n = q.remove();
       s.push(n);
    }
    return s; // Return stack s
}

public static Queue<CalendarDate> sToQ(Stack<CalendarDate> s) {
    Queue<CalendarDate> q = new LinkedList<CalendarDate>();
    while (!s.empty()) {
       CalendarDate n = s.pop();
       q.add(n);
    }
    return q; // Return queue q
}

/*      
    Provided as a Stack Class alternative
    Limits user to actual Stack methods
    so Vector<E> is not available
*/
public class Stack<E> {
    // avoid blanked import of java.util
    private java.util.Stack<E> secret;

    // default constructor
    public Stack() {
        secret = new java.util.Stack<E>();
    } 

    // empty that collection
    public void clear() {
        secret.clear();
    }

    // should be order constant
    public int size() {
        return secret.size();
    }

    // simply have push call push from API
    public E push(E a) {
        secret.push(a);
        return a;
    }

    // And, empty calls empty from API
    public boolean empty() {
        return secret.empty();
    }

    // And my pop() uses pop() form JAVA API
    public E pop() {
        return secret.pop();
    }

    // My peek uses their peek
    public E peek() {
        return secret.peek();
    }

    // Following are not basic Stack operations
    // but needed to do some simple testing

    // toString is probably not O(constant)
    public String toString() {
        return secret.toString();
    }

}

公共静态堆栈QTO（队列q）{
堆栈s=新堆栈（）；
而（！q.isEmpty（））{
CalendarDate n=q.remove（）；
s、 推（n）；
}
返回s；//返回堆栈s
}
公共静态队列sToQ（堆栈s）{
队列q=新的LinkedList（）；
而（！s.empty（））{
CalendarDate n=s.pop（）；
q、 添加（n）；
}
return q；//返回队列q
}
/*      
作为堆栈类备选方案提供
将用户限制为实际堆栈方法
所以向量是不可用的
*/
公共类堆栈{
//避免java.util的空白导入
私有java.util.Stack secret；
//默认构造函数
公共堆栈（）{
secret=new java.util.Stack（）；
} 
//清空那个集合
公共空间清除（）{
secret.clear（）；
}
//应该是顺序常数
公共整数大小（）{
返回secret.size（）；
}
//只需从API中调用push
公共电子推送（EA）{
秘密推送（a）；
返回a；
}
//并且，来自API的空调用为空
公共布尔空（）{
return secret.empty（）；
}
//我的pop（）使用pop（）形式的JAVA API
公共E-pop（）{
返回secret.pop（）；
}
//我的窥视使用他们的窥视
公共E peek（）{
返回secret.peek（）；
}
//以下不是基本的堆栈操作
//但是需要做一些简单的测试
//toString可能不是O（常量）
公共字符串toString（）{
return secret.toString（）；
}
}

我的解决方案

public static Stack<CalendarDate> sToS(Stack<CalendarDate> orgin) {
        // Create a temp stack
        Stack<CalendarDate> temp = new Stack<CalendarDate>();

        // Move all values from origin
        // stack to temp stack using pop and push
        while (!orgin.empty()) {
            CalendarDate n = orgin.pop();
            temp.push(n);    // push here for the same order
        }

        // Create a copy stack
        Stack<CalendarDate> copy = new Stack<CalendarDate>();

        // Move all values from temp stack to
        // both origin and copy stacks at the same time
        while (!temp.empty()) {
            CalendarDate n = temp.pop();
            copy.push(n);    // push here for the same order
            orgin.push(n);  
        }

        return copy;
    }

公共静态堆栈STO（堆栈起始）{
//创建临时堆栈
堆栈温度=新堆栈（）；
//从原点移动所有值
//使用pop和push从堆栈到临时堆栈
而（！orgin.empty（））{
CalendarDate n=orgin.pop（）；
temp.push（n）；//按此处获得相同的订单
}
//创建一个复制堆栈
堆栈复制=新堆栈（）；
//将所有值从临时堆栈移动到
//源堆栈和副本堆栈同时存在
而（！temp.empty（））{
CalendarDate n=temp.pop（）；
copy.push（n）；//按相同的顺序到这里
原推力（n）；
}
返回副本；
}

要复制堆栈：

• 创建一个

  temp

  堆栈

• 使用

  pop

  和

  push将所有值从
  origin
  堆栈移动到
  temp
  堆栈
  

• origin

  堆栈现在为空，

  temp

  堆栈反转

• 创建一个

  副本

  堆栈

• 同时将所有值从

  temp

  堆栈移动到

  origin

  和

  copy

  堆栈

• origin

  返回原始内容，

  copy

  堆栈具有相同的内容

---

想象一个场景，其中有三个堆栈，堆栈a（要从中复制的堆栈）、堆栈B（要复制到的目标堆栈）和堆栈临时（帮助堆栈）

---

要想完全理解，最好的方法就是拿一个例子，自己尝试一下。或者你可以在编码平台上简单地搜索一种方法，比如

，那么你的问题是什么？你的代码有什么问题？我不确定你的问题到底是什么。这好像是一个家庭作业。这很好，我们可能会在某些方面帮助您，但我们不会简单地为您这样做。您已经开始了一个有效的解决方案。现在怎么办？你被封锁了？你不知道怎么做？有些东西没有按您预期的那样工作？请解释。这使得

A

为空，但问题是“我不能修改，让原始堆栈通过”，我将其解释为“我不能修改原始堆栈，即传递的堆栈必须保持不变”。感谢您指出，我在插入B时忘了将元素插入A。

Step 1: (The Initial Stack)

|1|  | |  | |
|2|  | |  | |
|3|  | |  | |

 A   TEMP  B

Step 2: (Move elements from Stack A to Temp Stack)

| |  | |  | |
|2|  | |  | |
|3|  |1|  | |

 A   TEMP  B

| |  | |  | |
| |  |2|  | |
|3|  |1|  | |

 A   TEMP  B

| |  |3|  | |
| |  |2|  | |
| |  |1|  | |

 A   TEMP  B

Step 3: (Move elements from Temp stack to Stack A & B)

| |  | |  | |
| |  |2|  | |
|3|  |1|  |3|

 A   TEMP  B

| |  | |  | |
|2|  | |  |2|
|3|  |1|  |3|

 A   TEMP  B

|1|  | |  |1|
|2|  | |  |2|
|3|  | |  |3|

 A   TEMP  B