Question

如何在不使用任何（额外）数据结构的情况下反向堆叠？任何建议或伪代码都可能有所帮助。我尝试并找不到任何可行的解决方案。这里的问题是我没有 - 也没有堆栈的大小。如果我知道我至少可以继续创作，请提前致谢。

Answer 1

这可以通过双递归完成，如follows:。

void insert_at_bottom(node **stack, int data)
{
     if( isempty(*stack) ){
          push(stack,data);
          return;
     }
     int temp=pop(stack);
     insert_at_bottom(stack,data);
     push(stack,temp);
}  


void rev_stack(node **stack)
{
     if( isempty(*stack) ) return;
     int temp = pop(stack);
     rev_stack(stack);
     insert_at_bottom(stack,temp);
}

Answer 2

您可以使用递归轻松完成此操作。然后，您的最大允许堆栈大小将受最大递归深度的约束。一些代码：

public void reverse(Stack st) { 
    int m = (int)st.Pop(); 
    if (st.Count != 1) {
        reverse(st); 
    }
    Push(st , m); 
  } 

public void Push(Stack st , int a) { 
   int m = (int)st.Pop(); 
   if (st.Count != 0) {
       Push(st , a); 
   }
   else {
       st.Push(a); 
       st.Push(m); 
   }
}

Answer 3

这是另一种方法。我正在尝试使用一组固定的变量（5-max，A，A1，B，B1）并重新利用这些变量，以相反的顺序重新填充堆栈。

无递归。

仅适用于整数

比方说Stack = [1,2，-3,4]，顶部有1个。

最大= 5

A =（（（（（（（1 * 5）+2）* 5）+3）* 5）+4）* 5

A1 =（（（（（（（0 + 5）* 5）+5）* 5）+6）* 5）+5）* 5

借助A和A1，您可以重新填充堆栈，但顺序相同，因此计算B和B1的顺序相反。

A1和B1要记住负整数。

在这里，+ max代表正整数，+（max + 1）代表负整数。

import java.util.Stack;
//Not ideal solution. This is only because no other data structure can be used

/*
 * 1. Find Max. Any number > max can be used for max
 * 2. Find A and A1
 * 3. Find B and B1
 * 4. Fill the Stack using B and B'
 * O( 4n ) = O( n )
 */

class Stack_Reversal_Using_Recursion { 

static Stack<Integer> stack = new Stack<>(); 

public static void main(String[] args) {

    stack.push(1);
    stack.push(8);
    stack.push(-3);
    stack.push(0);
    stack.push(4);
    System.out.println(stack);  

    better_Solution();

    System.out.println("Using mathematical approch");
    System.out.println(stack);

}
private static void better_Solution() {

    int size = stack.size();

    //Finding Max
    int max = 0;
    for(int item : stack){
        if( max < Math.abs(item) )
            max = Math.abs(item);
    }
    max = max + 1;

    //Finding A and A1
    int A = 0;
    int A1 = 0;

    while( stack.size() > 0 )
    {
        int x = stack.pop();
        A += Math.abs(x);
        A *= max;

        if( x < 0 )
            A1 += (max+1);
        else
            A1 += max;
        A1 *= max;
    }
    //A and A' hold single sum total value from which using max we can find out entire stack but in same order so we find out B and B1

    int B = 0;
    int B1 = 0;

    for( int i = 0; i < size; i++)
    {
        A = A / max;
        A1 = A1/ max;

        int A_mdl = A % max;
        A -= A_mdl;

        int A1_mdl = A1 % max;
        if( A1_mdl == 0 )
            A1_mdl = max;
        else
            A1_mdl = max + 1;
        A1 -= A1_mdl;

        B += A_mdl;
        B *= max;

        B1 += A1_mdl;
        B1 *= max;

    }

    //Now that we have B and B1 in desired order let's re-populate the Stack
    for( int i = 0; i < size; i++)
    {
        B = B / max;
        B1 = B1/ max;

        int B_mdl = B % max;
        B -= B_mdl;

        int B1_mdl = B1 % max;
        if( B1_mdl != 0 )
            B_mdl = -B_mdl;
        if( B1_mdl ==0 )
            B1 -= max;
        else
            B1 -= (max+1);

        stack.push( B_mdl );

    }

}

}

如前所述，这种方法仅适用于Integer，并且人们总是可以争论如果数字变化很大！在这种情况下，As和Bs可以是大整数。

不使用任何数据结构反向堆栈

3 个答案: