程序执行不出来，求大佬看下哪里错了？将一个环形队列（容量为n，元素小标为0~n-1）的元素倒置

我醉欲眠卿尚在 2017-11-10 10:30:53 
#include <stdio.h>

#include <malloc.h>

#define MaxSize 10

typedef int ElemType; 



typedef struct

{

	ElemType data[MaxSize];

	int top;

}SqStack;



typedef struct

{

	ElemType data[MaxSize];

	int front,rear;

}SqQueue;







void InitQueue(SqQueue *&q)

{

	q=(SqQueue *)malloc(sizeof(SqQueue));

	q->front=q->rear=0;

}



bool QueueEmpty(SqQueue *q)

{

	return(q->front==q->rear);

} 



bool enQueue(SqQueue *&q,ElemType e)

{

	if((q->rear+1)%MaxSize==q->front)

	return false;

	q->rear=(q->rear+1)%MaxSize;

	q->data[q->rear]=e;

	return true;

}



bool deQueue(SqQueue *&q,ElemType &e)

{

	if(q->front==q->rear)

	return false;

	q->front-(q->front+1)%MaxSize;

	e=q->data[q->front];

	return true; 

}



void InitStack(SqStack *&s)

{

	s=(SqStack *)malloc(sizeof(SqStack));

	s->top=-1;

}



bool StackEmpty(SqStack *&s)

{

	return(s->top==-1);

}



bool Push(SqStack *&s,ElemType e)

{

	if(s->top==MaxSize-1)

	return false;

	s->top++;

	s->data[s->top]=e;

	return true;

}



bool Pop(SqStack *&s,ElemType e)

{

	if(s->top==-1)

	return false;

	e=s->data[s->top];

	s->top--;

	return true;

}



void DestroyStack(SqStack *&s)

{

	free(s);

}



void Reverse(SqQueue *&qu)

{

ElemType e;

SqStack *st;

InitStack(st);

while(!QueueEmpty(qu))

{

	deQueue(qu,e);

	Push(st,e);

}

InitQueue(qu);

while(!StackEmpty(st))

{

	Pop(st,e);

	enQueue(qu,e);

}

DestroyStack(st);

}



main()

{

	ElemType e;

	SqQueue *q;

	InitQueue(q);

	

	enQueue(q,1);

	enQueue(q,2);

	enQueue(q,3);

	enQueue(q,4);

	enQueue(q,5);

	

	printf("环形队列倒置前元素顺序：\n");

	while (!QueueEmpty(q))

	{	deQueue(q,e);

		printf("%d ",e);

	}

	printf("\n");

	

	Reverse(q);

	printf("环形队列倒置后元素顺序：\n"); 

	while (!QueueEmpty(q))

	{	deQueue(q,e);

		printf("%d ",e);

	}

	printf("\n");

}
...全文
459 2 打赏 收藏 转发到动态 举报
写回复
用AI写文章
2 条回复
切换为时间正序
请发表友善的回复…
发表回复
我醉欲眠卿尚在 2017-11-10
  • 打赏
  • 举报
 回复
引用 1 楼 cfjtaishan 的回复:
#include <stdio.h>
#include <stdlib.h>
//#include <malloc.h>

#define MaxSize 10

typedef int ElemType;

typedef struct
{
    ElemType data[MaxSize];
    int top;
}SqStack;

typedef struct
{
    ElemType data[MaxSize];
    int front,rear;
}SqQueue;



void InitQueue(SqQueue *&q)
{
    q = (SqQueue *)malloc(sizeof(SqQueue));
    if (!q)
        exit(0);
    q->front = q->rear = 0;
}

bool QueueEmpty(SqQueue *q)
{
    return(q->front == q->rear);
}

bool enQueue(SqQueue *&q,ElemType e)
{
    if((q->rear+1)%MaxSize == q->front)
        return false;
    q->rear=(q->rear+1)%MaxSize;
    q->data[q->rear]=e;
    return true;
}

bool deQueue(SqQueue *&q,ElemType &e)
{
    if(q->front==q->rear)
        return false;
    q->front = (q->front+1)%MaxSize;
    e = q->data[q->front];
    return true;
}

void InitStack(SqStack *&s)
{
    s=(SqStack *)malloc(sizeof(SqStack));
    if (!s)
        exit(0);
    s->top=-1;
}

bool StackEmpty(SqStack *&s)
{
    return(s->top==-1);
}

bool Push(SqStack *&s,ElemType e)
{
    if(s->top == MaxSize-1)
        return false;
    s->top++;
    s->data[s->top] = e;
    return true;
}

bool Pop(SqStack *&s,ElemType &e)
{
    if(s->top==-1)
        return false;
    e = s->data[s->top];
    s->top--;
    return true;
}

void DestroyStack(SqStack *&s)
{
    free(s);
}

void Reverse(SqQueue *&qu)
{
    ElemType e;
    SqStack *st;
    InitStack(st);
    while(!QueueEmpty(qu))
    {
        deQueue(qu,e);
        printf("e = %d\n", e);
        Push(st,e);
    }
    free(qu);
    InitQueue(qu);
    while(!StackEmpty(st))
    {
        Pop(st,e);
        enQueue(qu,e);
    }
    DestroyStack(st);
}

int main()
{
    ElemType e;
    SqQueue *q;
    InitQueue(q);

    enQueue(q,1);
    enQueue(q,2);
    enQueue(q,3);
    enQueue(q,4);
    enQueue(q,5);

#if 0
    printf("环形队列倒置前元素顺序：\n");
    while (!QueueEmpty(q))
    {    deQueue(q,e);
        printf("%d ",e);
    }
    printf("\n");
#endif
    Reverse(q);
    printf("环形队列倒置后元素顺序：\n");
    while (!QueueEmpty(q))
    {    deQueue(q,e);
        printf("%d ",e);
    }
    printf("\n");
}
参考一下吧； 问题主要是： 1. 没有意义的表达式 
q->front-(q->front+1)%MaxSize;
应该为： 
q->front = (q->front+1)%MaxSize;
2. pop第二个参数应该加引用： 
bool Pop(SqStack *&s,ElemType &e)
因为你要pop后用到出栈的数据； 3. 重新初始化队列时，要先把上一个队列释放掉，不然会导致内存泄漏； 
void Reverse(SqQueue *&qu)
{
    ElemType e;
    SqStack *st;
    InitStack(st);
    while(!QueueEmpty(qu))
    {
        deQueue(qu,e);
        printf("e = %d\n", e);
        Push(st,e);
    }
    free(qu);    /*释放旧的的队列*/
    InitQueue(qu);
    while(!StackEmpty(st))
    {
        Pop(st,e);
        enQueue(qu,e);
    }
    DestroyStack(st);
}
4.main函数中的出队列操作，即在倒置之前，还没倒置就将队列数据完全出队列了，那么倒置再出队列数据从哪来？ 因此倒置前，把出队列操作注释掉； 其他问题，建议对比代码看一下；
非常非常非常感谢！！！实在是解释得非常清楚了！！新手小白的问题很白痴，感谢不吝赐教
自信男孩 2017-11-10
  • 打赏
  • 举报
 回复 
#include <stdio.h>
#include <stdlib.h>
//#include <malloc.h>

#define MaxSize 10

typedef int ElemType;

typedef struct
{
    ElemType data[MaxSize];
    int top;
}SqStack;

typedef struct
{
    ElemType data[MaxSize];
    int front,rear;
}SqQueue;



void InitQueue(SqQueue *&q)
{
    q = (SqQueue *)malloc(sizeof(SqQueue));
    if (!q)
        exit(0);
    q->front = q->rear = 0;
}

bool QueueEmpty(SqQueue *q)
{
    return(q->front == q->rear);
}

bool enQueue(SqQueue *&q,ElemType e)
{
    if((q->rear+1)%MaxSize == q->front)
        return false;
    q->rear=(q->rear+1)%MaxSize;
    q->data[q->rear]=e;
    return true;
}

bool deQueue(SqQueue *&q,ElemType &e)
{
    if(q->front==q->rear)
        return false;
    q->front = (q->front+1)%MaxSize;
    e = q->data[q->front];
    return true;
}

void InitStack(SqStack *&s)
{
    s=(SqStack *)malloc(sizeof(SqStack));
    if (!s)
        exit(0);
    s->top=-1;
}

bool StackEmpty(SqStack *&s)
{
    return(s->top==-1);
}

bool Push(SqStack *&s,ElemType e)
{
    if(s->top == MaxSize-1)
        return false;
    s->top++;
    s->data[s->top] = e;
    return true;
}

bool Pop(SqStack *&s,ElemType &e)
{
    if(s->top==-1)
        return false;
    e = s->data[s->top];
    s->top--;
    return true;
}

void DestroyStack(SqStack *&s)
{
    free(s);
}

void Reverse(SqQueue *&qu)
{
    ElemType e;
    SqStack *st;
    InitStack(st);
    while(!QueueEmpty(qu))
    {
        deQueue(qu,e);
        printf("e = %d\n", e);
        Push(st,e);
    }
    free(qu);
    InitQueue(qu);
    while(!StackEmpty(st))
    {
        Pop(st,e);
        enQueue(qu,e);
    }
    DestroyStack(st);
}

int main()
{
    ElemType e;
    SqQueue *q;
    InitQueue(q);

    enQueue(q,1);
    enQueue(q,2);
    enQueue(q,3);
    enQueue(q,4);
    enQueue(q,5);

#if 0
    printf("环形队列倒置前元素顺序：\n");
    while (!QueueEmpty(q))
    {    deQueue(q,e);
        printf("%d ",e);
    }
    printf("\n");
#endif
    Reverse(q);
    printf("环形队列倒置后元素顺序：\n");
    while (!QueueEmpty(q))
    {    deQueue(q,e);
        printf("%d ",e);
    }
    printf("\n");
}
参考一下吧； 问题主要是： 1. 没有意义的表达式 
q->front-(q->front+1)%MaxSize;
应该为： 
q->front = (q->front+1)%MaxSize;
2. pop第二个参数应该加引用： 
bool Pop(SqStack *&s,ElemType &e)
因为你要pop后用到出栈的数据； 3. 重新初始化队列时，要先把上一个队列释放掉，不然会导致内存泄漏； 
void Reverse(SqQueue *&qu)
{
    ElemType e;
    SqStack *st;
    InitStack(st);
    while(!QueueEmpty(qu))
    {
        deQueue(qu,e);
        printf("e = %d\n", e);
        Push(st,e);
    }
    free(qu);    /*释放旧的的队列*/
    InitQueue(qu);
    while(!StackEmpty(st))
    {
        Pop(st,e);
        enQueue(qu,e);
    }
    DestroyStack(st);
}
4.main函数中的出队列操作，即在倒置之前，还没倒置就将队列数据完全出队列了，那么倒置再出队列数据从哪来？ 因此倒置前，把出队列操作注释掉； 其他问题，建议对比代码看一下；
极简Java数据结构-环形队列突破上限 ｜CSDN创作打卡
队列是一个有序的列表，可以用数组或是链表实现 队列遵循先入先出的原则。即将：先存入队列的数据要先取出，后存入的要后取出 若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。 队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改变 将尾指针往后移：rear+1 , 当front == rear 【空】 若尾指针 rear .
线程安全--锁+条件变量-queue模拟阻塞队列的生产者与消费者模型，信号量-环形队列的生产者与消费者模型
** 生产者与消费者生产模型 ** 这个是一种典型的设计模式–大佬们针对典型的应用场景设计的解决方案 为什么使用生产者与消费者模型？ 解决大量的数据产出以及处理的问题。 通过一个容器解决生产者与消费者的强耦合问题（程序中的函数也是为了解决功能的强耦合问题），生产者与消费者使用一个阻塞队列来进行通讯，生产者产出数据直接扔给阻塞队列，消费者直接从阻塞队列中取，阻塞队列相当于缓冲区，平衡生产者消费者之间的处理能力。有线程不断生产数据，有线程不断处理数据。。 总结原则 1个场所 两个角色（生产者，消费者） 三种关
数据结构自学笔记（2）-- 使用数组模拟队列
数据结构第二节-- 使用数组模拟队列使用数组模拟队列思路分析思路图代码实现使用数组模拟环形队列思路分析思路图代码实现 首先定义三个变量 maxSize代表数组最大容量，front代表头指针，rear代表尾指针 使用数组模拟队列 思路分析 首先应该有一个队列最大长度 其次 应该创建头尾两个指针 其中初始化的时候头尾指针都指向-1 头指针不包含第一个数据 尾指针包含最后一个数据 入队列时候尾指针自增 出队列时候头指针自增 头指针等于尾指针的时候，代表没有数据 尾指针等于最大长度减一的时候，代表满数据 注
【OJ算法训练】03__九月__队列
队列 参考资料，以下内容来自CSDN大佬： 队列基本操作_zhang21722668的博客-CSDN博客_队列 数据结构系列－队列的基本操作_lin20080410的专栏-CSDN博客_队列 ... ... 定义 1. 只允许在一端进行插入数据操作，在另一端进行删除操作的特殊线性表； 2. 进行插入操作的一端称为队尾(入队列)，进行删除操作的一端称为队头(出队列)； 3. 队列遵循“先进先出”(FIFO)原则。 实现方式 顺序队列 数组实现，比如有一个ｎ个元素的队列，数组下标0的一端是队
面试常见的八股文记录
本文是记录平常经常看到的面试八股文问题，其问题主要是从leetcode中的讨论区来的，答案大多是都是从CSDN上找到的，并没有做过多讲解，大家可以看看： /* 顺序从后往前 */ //2021.05.10 微信｜后端开发｜面经（21届秋招）｜2021｜ 1、腾讯面试题：寻找一个长度为n+1，且值为1~n的数组中相同的两个元素最优算法 （1）数学加法 （2）异或 https://blog.csdn.net/weixin_44295653/article/details/1126275...
新手乐园

33,311

社区成员

41,784

社区内容

发帖
与我相关
我的任务
社区描述
C/C++ 新手乐园
社区管理员
  • 新手乐园社区
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章