Write a method that takes a stack of integers as a parameter and that switches successive pairs of numbers starting at the bottom of the stack

Question

If there are an odd number of values in the stack, the value at the top of the stack is not moved.

What's wrong..?

public static void switchPairs(Stack<Integer> st){
    Queue<Integer> q = new LinkedList<Integer>();
    int size = st.size();
    
    for(int i = 0; i < size; i++){
        
        int a = st.pop();
        int b = st.pop();
        q.add(a);
        q.add(b);
    }
}

What do you think is wrong? You are always operating with pairs, where should the last value go? This should give you exceptions because the stack is empty after a few iterations. — Sotirios Delimanolis, Feb 25 '14 at 23:28

score 1 · Answer 1 · edited May 23 '17 at 12:10

1

I think there are several problems with your code:

You should go until size/2. You're pop-ing twice in each iteration. Then check if the length was odd and just add the last remaining element if so.
I think that your code only reverses your stack.

This is not tested but i think it should look something like this (also took the liberty to get rid of some useless variables - performance probably isnt an issue in this case).

Make your method return a stack and use it like this:

st = switchPairs(st);

And the method's body:

public Stack<Integer> switchPairs(Stack<Integer> st){
        Stack<Integer> q = new Stack<Integer>();   
        for(int i = 0; i < st.size()-1; i++){        
            q.push(st.elementAt(i+1));
            q.push(st.elementAt(i++)));
         }
         if(st.size()%2==1){
            q.push(st.pop());
         }
         return q;
}

To keep it void (usage taken from Here)

AtomicReference<Stack<Integer>> ref = new AtomicReference<Stack<Integer>>(st);
switchPairs(ref);
st = ref.get();

And the method's body:

public void switchPairs(AtomicReference<Stack<Integer>> ref){
        Stack<Integer> q = new Stack<Integer>();   
        for(int i = 0; i < ref.get().size()-1; i++){        
            q.push(ref.get().elementAt(i+1));
            q.push(ref.get().elementAt(i++)));
         }
         if(ref.get().size()%2==1){
            q.push(ref.get().pop());
         }
         ref.set(q);
}

edited May 23 '17 at 12:10

Community

1
1

answered Feb 25 '14 at 23:29

Florin Bombeanu

850
2
11
23

This doesn't work, I tested it and it returns the first half of the original stack....? – bazookyelmo Feb 25 '14 at 23:58
I think it leaves it as a queue, i;m trying to change the original stack – bazookyelmo Feb 26 '14 at 00:07
I gave it another try. Sorry, I can't test java code. Tried the current implementation in C# and it works. – Florin Bombeanu Feb 26 '14 at 00:20
This works, but how would I write it as a void method? – bazookyelmo Feb 26 '14 at 00:26
Try making it void and instead of 'return q' try 'st = q'. I think Java only passes as value so this might work. I'm not sure though... – Florin Bombeanu Feb 26 '14 at 00:32
AtomicReference> ref = new AtomicReference>(st); switchPairs(ref); Change the method to get an AtomicReference> parameter and get the object with the get() method on that reference. Right at the end do a 'parameter.set(q); – Florin Bombeanu Feb 26 '14 at 00:40
This is beyond what we've studied, i can't really understand or use it – bazookyelmo Feb 26 '14 at 00:41
I've updated the answer, maybe it makes it a bit more clear. You can also find the link that explains the AtomicReference<>. I'm afraid I can't help you with more than this. – Florin Bombeanu Feb 26 '14 at 00:48

Write a method that takes a stack of integers as a parameter and that switches successive pairs of numbers starting at the bottom of the stack

1 Answers1