Can someone help look at my code, please? Thank you so much for your help. The input stack is [5, 2, 1, 9, 0, 10], my codes gave output stack [0, 9, 1, 2, 5, 10], 9 is not i
public class ReverseStack {
public static void main(String[] args) {
Stack<Integer> stack =new Stack<Integer>();
stack.add(3);stack.add(0);stack.add(2);stack.add(1);
sortStack(stack);
System.out.println(stack.toString());
}
public static void sortStack(Stack<Integer> stack){
int tempElement=stack.pop();
if(!stack.isEmpty()){
sortStack(stack);
}
insertStack(stack,tempElement);
}
private static void insertStack(Stack<Integer> stack, int element) {
if(stack.isEmpty()){
stack.push(element);
return;
}
int temp=stack.pop();
//********* For sorting in ascending order********
if(element<temp){
insertStack(stack,element);
stack.push(temp);
}else{
stack.push(temp);
stack.push(element);
}
return;
}
}
/** the basic idea is we go on popping one one element from the original
* stack (s) and we compare it with the new stack (temp) if the popped
* element from original stack is < the peek element from new stack temp
* than we push the new stack element to original stack and recursively keep
* calling till temp is not empty and than push the element at the right
* place. else we push the element to the new stack temp if original element
* popped is > than new temp stack. Entire logic is recursive.
*/
public void sortstk( Stack s )
{
Stack<Integer> temp = new Stack<Integer>();
while( !s.isEmpty() )
{
int s1 = (int) s.pop();
while( !temp.isEmpty() && (temp.peek() > s1) )
{
s.push( temp.pop() );
}
temp.push( s1 );
}
// Print the entire sorted stack from temp stack
for( int i = 0; i < temp.size(); i++ )
{
System.out.println( temp.elementAt( i ) );
}
}
Here's my version of the code which is pretty straightforward to follow.
import java.util.Stack;
public class StackSorting {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<Integer>();
stack.push(12);
stack.push(100);
stack.push(13);
stack.push(50);
stack.push(4);
System.out.println("Elements on stack before sorting: "+ stack.toString());
stack = sort(stack);
System.out.println("Elements on stack after sorting: "+ stack.toString());
}
private static Stack<Integer> sort(Stack<Integer> stack) {
if (stack.isEmpty()) {
return null;
}
Stack<Integer> sortedStack = new Stack<Integer>();
int element = 0;
while(!stack.isEmpty()) {
if (stack.peek() <= (element = stack.pop())) {
if (sortedStack.isEmpty()) {
sortedStack.push(element);
} else {
while((!sortedStack.isEmpty()) && sortedStack.peek() > element) {
stack.push(sortedStack.pop());
}
sortedStack.push(element);
}
}
}
return sortedStack;
}
}
package TwoStackSort;
import java.util.Random;
import java.util.Stack;
public class TwoStackSort {
/**
*
* @param stack1 The stack in which the maximum number is to be found.
* @param stack2 An auxiliary stack to help.
* @return The maximum integer in that stack.
*/
private static Integer MaxInStack(Stack<Integer> stack1, Stack<Integer> stack2){
if(!stack1.empty()) {
int n = stack1.size();
int a = stack1.pop();
for (int i = 0; i < n-1; i++) {
if(a <= stack1.peek()){
stack2.push(a);
a = stack1.pop();
}
else {
stack2.push(stack1.pop());
}
}
return a;
}
return -1;
}
/**
*
* @param stack1 The original stack.
* @param stack2 The auxiliary stack.
* @param n An auxiliary parameter to keep a record of the levels of recursion.
*/
private static void StackSort(Stack<Integer> stack1, Stack<Integer> stack2, int n){
if(n==0){
return;
}
else{
int maxinS1 = MaxInStack(stack1, stack2);
StackSort(stack2, stack1, n-1);
if(n%2==0){
stack2.push(maxinS1);
}
else{stack1.push(maxinS1);}
}
}
/**
*
* @param stack1 The original stack that needs to be sorted.
* @param stack2 The auxiliary stack.
* @return The descendingly sorted stack.
*/
public static Stack<Integer> TwoStackSorter(Stack<Integer> stack1, Stack<Integer> stack2){
StackSort(stack1, stack2, stack1.size()+stack2.size());
return (stack1.empty())? stack2:stack1;
}
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
Random random = new Random();
for (int i = 0; i < 50; i++) {
stack.push(random.nextInt(51));
}
System.out.println("The original stack is: ");
System.out.print(stack);
System.out.println("\n" + "\n");
Stack<Integer> emptyStack = new Stack<>();
Stack<Integer> res = TwoStackSorter(stack, emptyStack);
System.out.println("The sorted stack is: ");
System.out.print(res);
}
}
This is a code that I came up with yesterday night after an hour of brainstorming. When I was solving a version of this problem, I had a restriction that at most only one additional stack can be used. This is an intense recursive solution to this problem. I've used 2 private methods to get me the stuff that I required from the stack. I really love the way that recursion worked here. Basically the version that I was solving required to sort a stack in ascending/descending order by using at most one additional stack. Note that no other data structures should be used.