C++ 使用2个队列实现堆栈

此代码为何有效：

#include <cstdio>
#include <cstdlib>

#define N n *
#define Q q *
#define S s *

typedef struct n
{
    int data;
    struct N nxt;
}n;

typedef struct q
{
    N f;
    N r;
}q;

typedef struct stack
{
    Q q1;
    Q q2;
}s;
Q Createq()
{
    Q qq = (Q)malloc(sizeof(q));
    qq->f = qq->r  = 0;
    return qq;
}

S CreateStk()
{
    S stk = (S)malloc(sizeof(s));
    stk->q1 = Createq();
    stk->q2 = Createq();
    return stk;
}

int Deq(Q qq)
{
    if(qq->f == 0 && qq->r == 0) return -1;
    N nn = qq->r;
    int data = nn->data;
    qq->r = qq->r->nxt;
    free(nn);
    if(!qq->r)
        qq->f = 0;
    return data;
}

void Enq(Q qq, int data)
{
    if(!qq->f)
    {
        N nn = (N)malloc(sizeof(n));
        nn->data = data;
        nn->nxt = 0;
        qq->f = qq->r = nn;
    }
    else
    {
        N nn = (N)malloc(sizeof(n));
        nn->data = data;
        nn->nxt = 0;
        qq->f->nxt = nn;
        qq->f = nn;
    }
}

void Push(S stk, int data)
{
    Enq(stk->q2,data);

    while(stk->q1->f)
    {
        Enq(stk->q2,Deq(stk->q1));
    }

    Q t = stk->q1;
    stk->q1 = stk->q2;
    stk->q2 = t;
}

int Pop(S stk)
{
    return Deq(stk->q1);
}
int main() 
{
    S stk = CreateStk();
    Push(stk,10);
    Push(stk,30);
    Push(stk,40);
    Push(stk,50);
    printf("\nPopped: %d.", Pop(stk));
    printf("\nPopped: %d.", Pop(stk));
    printf("\nPopped: %d.", Pop(stk));
    printf("\nPopped: %d.", Pop(stk));
    return 0;
    return 0;
}

但这并不是：

#include <cstdio>
#include <cstdlib>

#define N n *
#define Q q *

typedef struct n
{
    int data;
    struct N nxt;
}n;

typedef struct q
{
    N f;
    N r;
}q;

Q Createq()
{
    Q qq = (Q)malloc(sizeof(q));
    qq->f = qq->r  = 0;
    return qq;
}

int Deq(Q qq)
{
    if(qq->f == 0 && qq->r == 0) return -1;
    N nn = qq->r;
    int data = nn->data;
    qq->r = qq->r->nxt;
    free(nn);
    if(!qq->r)
        qq->f = 0;
    return data;
}

void Enq(Q qq, int data)
{
    if(!qq->f)
    {
        N nn = (N)malloc(sizeof(n));
        nn->data = data;
        nn->nxt = 0;
        qq->f = qq->r = nn;
    }
    else
    {
        N nn = (N)malloc(sizeof(n));
        nn->data = data;
        nn->nxt = 0;
        qq->f->nxt = nn;
        qq->f = nn;
    }
}

void Push(Q qq1, Q qq2, int data)
{
    Enq(qq2,data);

    while(qq1->f)
    {
        Enq(qq2,Deq(qq1));
    }

    Q t = qq1;
    qq1 = qq2;
    qq2 = t;
}

int Pop(Q qq1)
{
    return Deq(qq1);
}

int main() {
    // your code goes here
    Q qq1 = Createq();
    Q qq2 = Createq();
    Push(qq1,qq2,10);
    Push(qq1,qq2,30);
    Push(qq1,qq2,40);
    Push(qq1,qq2,50);
    printf("\nPopped: %d.", Pop(qq1));
    printf("\nPopped: %d.", Pop(qq1));
    printf("\nPopped: %d.", Pop(qq1));
    printf("\nPopped: %d.", Pop(qq1));
    return 0;
}

#包括
#包括
#定义*
#定义Q*
类型定义结构
{
int数据；
结构nxt；
}n；
类型定义结构q
{
N-f；
nR；
}q；
Q Createq（）
{
qq=（Q）malloc（sizeof（Q））；
qq->f=qq->r=0；
返回qq；
}
int Deq（Q qq）
{
如果（qq->f==0&&qq->r==0）返回-1；
N nn=qq->r；
int data=nn->data；
qq->r=qq->r->nxt；
免费（nn）；
如果（！qq->r）
qq->f=0；
返回数据；
}
无效Enq（Q qq，整数数据）
{
如果（！qq->f）
{
N nn=（N）malloc（sizeof（N））；
nn->data=数据；
nn->nxt=0；
qq->f=qq->r=nn；
}
其他的
{
N nn=（N）malloc（sizeof（N））；
nn->data=数据；
nn->nxt=0；
qq->f->nxt=nn；
qq->f=nn；
}
}
无效推送（qq1、qq2、int数据）
{
Enq（第二季度，数据）；
而（qq1->f）
{
Enq（qq2，Deq（qq1））；
}
qt=qq1；
qq1=qq2；
qq2=t；
}
int Pop（Q qq1）
{
返回Deq（qq1）；
}
int main（）{
//你的密码在这里
qqq1=Createq（）；
Q qq2=Createq（）；
推（qq1，qq2,10）；
推（qq1，qq2,30）；
推（qq1，qq2,40）；
推（qq1，qq2,50）；
printf（“\n映射：%d.”，Pop（qq1））；
printf（“\n映射：%d.”，Pop（qq1））；
printf（“\n映射：%d.”，Pop（qq1））；
printf（“\n映射：%d.”，Pop（qq1））；
返回0；
}

输出：

弹出：-1。 弹出：-1。 弹出：-1。 弹出：-1

预期输出是第一个输出，这一点在问题标题中很明显。然而，我不理解第二个示例中，当我没有将两个队列封装在一个结构中时，为什么代码不起作用的血淋淋的细节

---

PS：我认为问题在于

Push

方法，但不确定出了什么问题。

除了非常难以阅读之外，问题在于您的第二个

Push

函数更改了以下代码行中的参数值

Q t = qq1;
qq1 = qq2;
qq2 = t;

qq1

和

qq2

是函数的参数，因此新值不会在调用函数（

main

）中更新

解决此问题的一种方法是通过引用传递参数：

void Push(Q &qq1, Q &qq2, int data)

---

这样，对

qq1

和

qq2

的更改也会更改调用函数中的值。

Upticked。这段代码不仅读起来很可怕。你可能会失去“阅读”功能，它甚至更准确。如果一个人试图用一种效率较低的方法实现堆栈，那么他将很难击败这种算法@WhozCraig：这从来都不是关于效率的问题，在我的问题中，我问了任何关于效率的问题？这只是我试图解决的一个难题。有时，不必要的专家建议和这些谜题一样无用。@The Dark:+1。此外，您不认为在结构中打包队列实际上比传递引用或双指针更好吗？您的回答解释了出错的原因，但我会选择OP的第一种编码方式。@al Acme我同意，第一种方式可以更好地封装代码，使调用更容易。代码应该始终检查调用malloc（）返回的值，以确保操作成功

void Push(Q &qq1, Q &qq2, int data)