Write a program to sort a stack in ascending order

前端 未结 4 600
天涯浪人
天涯浪人 2021-01-17 06:48

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

相关标签:
4条回答
  • 2021-01-17 07:17
    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;
        }
    
    }
    
    0 讨论(0)
  • 2021-01-17 07:18
    /** 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 ) );
        }
    
    }
    
    0 讨论(0)
  • 2021-01-17 07:30

    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;
        }
    }
    
    0 讨论(0)
  • 2021-01-17 07:33
    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.

    0 讨论(0)
提交回复
热议问题