如何使用临时堆栈复制堆栈?
How can I copy a stack by using a temporary stack?
这是我作为初学者的代码,我想实现图中所示的想法。
有什么更好的方法可以改进吗?
```
Stack originalStack=new Stack();
Stack TempStack=new Stack();
Stack copiedStack=new Stack();
orginalStack.push(1);
orginalStack.push(2);
orginalStack.push(3);
orginalStack.push(9);
int StackLength=orginalStack.size();
for(int i=0;i<StackLength-1;i++)
TempStack.push(originalStack.pop());
copiedStack.push(originalStack.peek());
do
{
copiedStack.push(TempStack.peek());
originalStack.push(TempStack.peek());
TempStack.pop();
}while(TempStack.size()!=0);
System.out.println("Stack 1 "+originalStack);
System.out.println("Stack temp "+TempStack);
System.out.println("Stack 2 "+copiedStack);
```][1]
是的,这是复制堆栈的好方法。不错的解决方案!我确实认为你通过在 for
循环中迭代到 i < StackLength - 1
有一个小错误:它应该是 i < StackLength
因为正如所写的那样你不会到达 originalStack 的最后一个元素也不会将其推送到 TempStack,因此它不会出现在复制的堆栈中。您可以通过循环直到 originalStack.size() == 0
就像在 do-while
循环中所做的那样,围绕这种类型的差一错误进行更防御性的编码。
在风格方面,您可以通过包含更多空格来改进代码(似乎任何给定行中的所有内容都尽可能紧密地组合在一起,这通常不像它可能的那样可读be),并且您可能应该使用驼峰式大小写 tempStack
和 stackLength
来保持一致(您通常保留首字母大写的 类 的名称)。您甚至可以将用于将堆栈复制到函数中的代码包装起来。
这是一个单独的问题,但是对于 Java,您应该尝试使用参数化类型,例如 Stack<Integer>
或 Stack<T>
/Stack<E>
(任何 type/any 元素),因此编译器可以检查您的代码的类型安全性并帮助避免 运行-time 错误。这有点冗长,但 Java 就是这样。普通的、未参数化的集合(“原始类型”)更像是一种最好避免的遗留特性。如果那只是您还没有做到的事情,请不要担心,您很快就会做到。
所以这就是我如何美化事情
import java.util.Stack;
public class CopyStack {
public static void main(String[] args) {
Stack<Integer> originalStack = new Stack<>();
originalStack.push(1);
originalStack.push(2);
originalStack.push(3);
originalStack.push(9);
Stack<Integer> copiedStack = copyStack(originalStack);
System.out.println("Stack 1 " + originalStack);
System.out.println("Stack 2 " + copiedStack);
}
public static <T> Stack<T> copyStack(Stack<T> originalStack) {
Stack<T> tempStack = new Stack<>();
Stack<T> copiedStack = new Stack<>();
while (originalStack.size() != 0) tempStack.push(originalStack.pop());
do {
copiedStack.push(tempStack.peek());
originalStack.push(tempStack.peek());
tempStack.pop();
} while (tempStack.size() != 0);
return copiedStack;
}
}
这是我作为初学者的代码,我想实现图中所示的想法。 有什么更好的方法可以改进吗?
``` Stack originalStack=new Stack(); Stack TempStack=new Stack(); Stack copiedStack=new Stack(); orginalStack.push(1); orginalStack.push(2); orginalStack.push(3); orginalStack.push(9); int StackLength=orginalStack.size(); for(int i=0;i<StackLength-1;i++) TempStack.push(originalStack.pop()); copiedStack.push(originalStack.peek()); do { copiedStack.push(TempStack.peek()); originalStack.push(TempStack.peek()); TempStack.pop(); }while(TempStack.size()!=0); System.out.println("Stack 1 "+originalStack); System.out.println("Stack temp "+TempStack); System.out.println("Stack 2 "+copiedStack); ```][1]
是的,这是复制堆栈的好方法。不错的解决方案!我确实认为你通过在 for
循环中迭代到 i < StackLength - 1
有一个小错误:它应该是 i < StackLength
因为正如所写的那样你不会到达 originalStack 的最后一个元素也不会将其推送到 TempStack,因此它不会出现在复制的堆栈中。您可以通过循环直到 originalStack.size() == 0
就像在 do-while
循环中所做的那样,围绕这种类型的差一错误进行更防御性的编码。
在风格方面,您可以通过包含更多空格来改进代码(似乎任何给定行中的所有内容都尽可能紧密地组合在一起,这通常不像它可能的那样可读be),并且您可能应该使用驼峰式大小写 tempStack
和 stackLength
来保持一致(您通常保留首字母大写的 类 的名称)。您甚至可以将用于将堆栈复制到函数中的代码包装起来。
这是一个单独的问题,但是对于 Java,您应该尝试使用参数化类型,例如 Stack<Integer>
或 Stack<T>
/Stack<E>
(任何 type/any 元素),因此编译器可以检查您的代码的类型安全性并帮助避免 运行-time 错误。这有点冗长,但 Java 就是这样。普通的、未参数化的集合(“原始类型”)更像是一种最好避免的遗留特性。如果那只是您还没有做到的事情,请不要担心,您很快就会做到。
所以这就是我如何美化事情
import java.util.Stack;
public class CopyStack {
public static void main(String[] args) {
Stack<Integer> originalStack = new Stack<>();
originalStack.push(1);
originalStack.push(2);
originalStack.push(3);
originalStack.push(9);
Stack<Integer> copiedStack = copyStack(originalStack);
System.out.println("Stack 1 " + originalStack);
System.out.println("Stack 2 " + copiedStack);
}
public static <T> Stack<T> copyStack(Stack<T> originalStack) {
Stack<T> tempStack = new Stack<>();
Stack<T> copiedStack = new Stack<>();
while (originalStack.size() != 0) tempStack.push(originalStack.pop());
do {
copiedStack.push(tempStack.peek());
originalStack.push(tempStack.peek());
tempStack.pop();
} while (tempStack.size() != 0);
return copiedStack;
}
}