将队列中元素逆序后，为何打印出来的还是原来的顺序？

Question

描述：Q是一个队列，S是一个空栈，实现将队列中的元素逆置
实现程序如下：

#include <stdio.h>
#define MaxSize 100
//定义栈结构 
typedef struct{
    int data[MaxSize];
    int top; 
}Stack;
//定义队列结构 
typedef struct {
    int data[MaxSize];
    int front, rear;
}Queue;

//初始化队列 
void InitQueue(Queue &Q) {
    Q.front = Q.rear = 0;
    printf("循环队列初始化成功\n");
}

//判空 
bool QueueEmpty(Queue Q) {
    if(Q.front == Q.rear) {
        return true;
    }else {
        return false;
    }
}
//入队
 bool EnQueue(Queue &Q, int &e) {
     //判断队列是否满，可以通过队尾指针的下一个位置就是队头来判断
     if((Q.rear + 1) % MaxSize == Q.front) {
         printf("队列已经满了，%d不能再入队\n", e);
         return false;
     }
     //在队列尾部入队
     Q.data[Q.rear] = e;
     printf("入队列的元素: %d\n", e); 
     Q.rear = (Q.rear + 1) % MaxSize;   //队尾指针加1取模
     return true; 
     
 }
  //出队
int DeQueue(Queue &Q, int &x) {
    if(Q.rear == Q.front) {
        return 0;    //队列为空，不能再出队了  
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    return x;
} 
 
 //初始化栈
void InitStack(Stack &S) {
    S.top = -1;
    printf("顺序栈初始化成功\n");
}

bool StackEmpty(Stack S) {
    if(S.top == -1) {      //判断栈空 
        return true;
    }else {
        return false;
    }
}

void Push(Stack &S, int &x) {
    if(S.top == MaxSize-1 ) {
        printf("顺序栈已经满了,无法进栈\n");
    }
    printf("\n入栈元素: %d\n", x);
    S.data[++S.top] = x;
}

int Pop(Stack &S, int &x) {
    if(S.top == -1) {
        printf("栈已经空了,不能出栈\n");
    }
    x = S.data[S.top--];
    printf("\n出栈元素: %d\n", x);
    return x;
}
//打印队列中的元素 
void printQueue(Queue Q) {
    while(!QueueEmpty(Q)) {
        printf("%3d", Q.data[Q.front]);
        Q.front = (Q.front + 1) % MaxSize;
    }
}

//逆序过程
int Inverser(Stack S, Queue Q) {
    if( Q.front == Q.rear || (Q.rear - Q.front + MaxSize) % MaxSize == 1) {    //队列中只有0或一个元素 
        printf("\n不需要逆置\n");
        return 0;
    }
    int x;
    while(!QueueEmpty(Q)) {
        DeQueue(Q, x);   //将队列中的元素依次出队 
        Push(S, x);    //再全部Push进入栈中 
    }
    while(!StackEmpty(S)) {
        Pop(S, x);      //将栈中元素全部出栈 
        EnQueue(Q, x);    //再将出栈的元素依次进队 
    }
    return 1; 
} 

int main() {
    Stack S;
    Queue Q;
    InitQueue(Q);
    InitStack(S);
    if(QueueEmpty(Q)) {  //返回true 
        printf("该循环队列为空\n");
    }else {
        printf("该循环队列不空\n");
    } 
    int e;
    printf("请输入想要入队的元素，以负数作为结束输入:  ");
    while(scanf("%d", &e)) {
        if(e < 0) {
            break;
        }
        EnQueue(Q, e);
    }
    printf("\n输入的队列元素顺序为：\n");
    printQueue(Q);
    //逆序
    if(Inverser(S, Q)) {
        printf("\n逆序后队列元素顺序为：\n");
        printQueue(Q);
    }
}

执行后的截图：

可以看到，先是1,2,3入队，然后依次出队再入栈，入栈顺序是1,2,3，然后从栈中Pop后再入队，顺序是3,2,1. 此时入队依次是：3,2,1. 队首是3，队尾是1，可是为什么再次打印出来的顺序结果依然还是：1,2,3 ？
不明白哪里出问题了，逆序后为什么打印的还是1,2,3？求帮助解答，谢谢

Answer 1

你上面的代码最后输出的只是你一开始输入的数字，Inverser(S, Q)，改变的只是形参的数值，而不是实际的
队列Q,而且形参队列Q里面的数值其实变成了 [1 2 3 3 2 1] 六个，你调试的时候可以看到，主函数执行完之
后，Q还是 [1 2 3],不会发生改变。 你可以用指针传参试试，也可以直接将Inverser方法去掉，直接写在主函
数里：如下，在定义一个队列。希望对你有帮助
#include <stdio.h>
#define MaxSize 100
//定义栈结构 
typedef struct{
    int data[MaxSize];
    int top; 
}Stack;
//定义队列结构 
typedef struct {
    int data[MaxSize];
    int front, rear;
}Queue;

//初始化队列 
void InitQueue(Queue &Q) {
    Q.front = Q.rear = 0;
    printf("循环队列初始化成功\n");
}

//判空 
bool QueueEmpty(Queue Q) {
    if(Q.front == Q.rear) {
        return true;
    }else {
        return false;
    }
}
//入队
 bool EnQueue(Queue &Q, int &e) {
     //判断队列是否满，可以通过队尾指针的下一个位置就是队头来判断
     if((Q.rear + 1) % MaxSize == Q.front) {
         printf("队列已经满了，%d不能再入队\n", e);
         return false;
     }
     //在队列尾部入队
     Q.data[Q.rear] = e;
     printf("入队列的元素: %d\n", e); 
     Q.rear = (Q.rear + 1) % MaxSize;   //队尾指针加1取模
     return true; 
     
 }
  //出队
int DeQueue(Queue &Q, int &x) {
    if(Q.rear == Q.front) {
        return 0;    //队列为空，不能再出队了  
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    return x;
} 
 
 //初始化栈
void InitStack(Stack &S) {
    S.top = -1;
    printf("顺序栈初始化成功\n");
}

bool StackEmpty(Stack S) {
    if(S.top == -1) {      //判断栈空 
        return true;
    }else {
        return false;
    }
}

void Push(Stack &S, int &x) {
    if(S.top == MaxSize-1 ) {
        printf("顺序栈已经满了,无法进栈\n");
    }
    printf("\n入栈元素: %d\n", x);
    S.data[++S.top] = x;
}

int Pop(Stack &S, int &x) {
    if(S.top == -1) {
        printf("栈已经空了,不能出栈\n");
    }
    x = S.data[S.top--];
    printf("\n出栈元素: %d\n", x);
    return x;
}
//打印队列中的元素 
void printQueue(Queue Q) {
    while(!QueueEmpty(Q)) {
        printf("%3d", Q.data[Q.front]);
        Q.front = (Q.front + 1) % MaxSize;
    }
}

int main() {
    Stack S;
    Queue Q;
    Queue InverserQ;
    InitQueue(Q);
    InitQueue(InverserQ);
    InitStack(S);
    if(QueueEmpty(Q)) {  //返回true 
        printf("该循环队列为空\n");
    }else {
        printf("该循环队列不空\n");
    } 
    int e;
    printf("请输入想要入队的元素，以负数作为结束输入:  ");
    while(scanf("%d", &e)) {
        if(e < 0) {
            break;
        }
        EnQueue(Q, e);
    }
    printf("\n输入的队列元素顺序为：\n");
    printQueue(Q);
    //逆序
    if( Q.front == Q.rear || (Q.rear - Q.front + MaxSize) % MaxSize == 1) {    
        printf("\n不需要逆置\n");
        return 0;
    }
    int x;
    while(!QueueEmpty(Q)) {
        DeQueue(Q, x);   //将队列中的元素依次出队 
        Push(S, x);    //再全部Push进入栈中 
    }

    while(!StackEmpty(S)) {
        Pop(S, x);      //将栈中元素全部出栈 
        EnQueue(InverserQ,x);    //再将出栈的元素依次进队 
    }
       printf("\n逆序后队列元素顺序为：\n");
        printQueue(InverserQ);
}