Question

尝试编写一个以整数堆栈作为参数的函数。通过仅使用一个队列作为辅助存储，我需要交换每对元素的位置。

如果堆栈是奇数编号，则保留最终整数。

INPUT

[3, 8, 17, 9, 99, 9, 17, 8, 3, 1, 2, 3, 4, 14]

期望的结果

[8, 3, 9, 17, 9, 99, 8, 17, 1, 3, 3, 2, 14, 4]

当前结果

[3, 8, 17, 9, 99, 9, 17, 8, 3, 1, 2, 3, 4, 14, 8, 3, 9, 17, 9, 99, 8, 17, 1, 3]

public static void switchPairs(Stack<Integer> st){
Queue<Integer> q = new LinkedList<Integer>();   
    int size = st. size();
    for(int i = 0; i < st.size()-1; i++){        
        q.add(st.elementAt(i+1));
        q.add(st.elementAt(i++));
     }
     if(st.size()%2==1){
        q.add(st.pop());
       
     }
  
    for(int k = 0; k<size; k++){
     
        st.push(q.remove());
                st.push(q.remove());
       
    }
    
}

新版

public static void switchPairs(Stack<Integer> st){
Queue<Integer> q = new LinkedList<Integer>();   
    int a = 0;
    int b = 0;
    while(!st.isEmpty()){
        a = st.pop();
        b = st.pop();
        st.push(a);
    }
    q.add(b);
    q.add(a);
    while(!q.isEmpty()){
        st.push(q.remove());
    }
}

第三次尝试（无限循环）

public static void switchPairs(Stack<Integer> st){
Queue<Integer> q = new LinkedList<Integer>();   
    int a = 0;
    int b = 0;
    while(!st.isEmpty()){
      a = st.pop();
        if(st.isEmpty()){
            st.push(a);
        }
    }
    b = st.pop();
    q.add(a);
    q.add(b);
    while(!q.isEmpty()){
        st.push(q.remove());
    }
}

第四次尝试：仅适用于偶数个元素..

public static void switchPairs(Stack<Integer> st){
Queue<Integer> q = new LinkedList<Integer>();   
    int a = 0;
    int b = 0;
    while(st.size() > 1){
      a = st.pop();


    b = st.pop();
    q.add(b);
    q.add(a);
    }

    while(!q.isEmpty()){
        st.push(q.remove());
    }

    while(!st.isEmpty()){
        q.add(st.pop());
    }
    while(!q.isEmpty()){
        st.push(q.remove());
    }



}

第五次最终尝试：

我只需要找出如何处理奇数堆栈：

这适用于偶数堆栈;

public static void switchPairs(Stack<Integer> st){
Queue<Integer> q = new LinkedList<Integer>();   
    int a = 0;
    int b = 0;
    while(!st.isEmpty()){
      a = st.pop();
        if(st.isEmpty()){
            q.add(a);
        } 

        else {
    b = st.pop();
    q.add(b);
    q.add(a);
        }

        }

    while(!q.isEmpty()){
        st.push(q.remove());
    }
    
    while(!st.isEmpty()){
        q.add(st.pop());
    }
    while(!q.isEmpty()){
        st.push(q.remove());
    }
  
}

Answer 1

要交换元素对，这是你需要的（伪代码）：

# Transfer to a queue, swapping pairs

create empty queue

while stack not empty:
    a = stack.pop
    if stack empty:
        queue.add a
    else
        b = stack.pop
        queue.add b
        queue.add a
    endif
endwhile

# Transfer back to stack (in reverse order, unfortunately)

while queue not empty:
    stack.push queue.get
endwhile

# Re-reverse the order to fix it up

while stack not empty:
    queue.add stack.pop
endwhile
while queue not empty:
    stack.push queue.get
endwhile

这种方法的工作方式是一次弹出两个元素，交换它们并将它们添加到队列中，直到堆栈为空。如果没有一对，则需要特殊处理。在这种情况下，您只需将单个元素传输到队列。

队列的处理非常简单，因为已经交换了对。您只需从队列中提取它们并将它们推回到堆栈中即可。

不幸的是，堆栈/队列组合现在以相反的顺序将项目放在堆栈上，因此您需要执行另一个传输（但这次没有交换）以使它们返回到正确的订单。

现在请记住，解决方案只留下最早推送的元素，如果它是奇数的那么。换句话说，转换是（7先被推送）：

如果您希望从交换中排除最后推送，请执行以下操作：

您只需在进行交换之前而不是之后反转堆栈中的顺序：

# Reverse the order up-front create empty queue while stack not empty: queue.add stack.pop endwhile while queue not empty: stack.push queue.get endwhile # Transfer to a queue, swapping pairs while stack not empty: a = stack.pop if stack empty: queue.add a else b = stack.pop queue.add b queue.add a endif endwhile # Transfer back to stack, fixing up reversal in the process while queue not empty: stack.push queue.get endwhile

这种微妙的变化不会影响偶数大小的队列，但它会确保奇数队列中的独立项目位于另一端。

如何交换堆栈中的元素对？

1 个答案: