c语言队列请教大佬我这是哪里的问题

Gnglas 2020-01-13 05:49:08
不好意思代码改了好几次了，有点乱
/*************************************************************************

	> File Name: queue2.c

	> Author: Gnglas

	> Mail: 2254228017@qq.com

	> Created Time: 2020年01月13日 星期一 11时46分58秒

 ************************************************************************/

 /*

  1初始化队列

  2确定队列为空

  3确定队列已满

  4确定队列中的项数

  5插入队列

  6删除队列

  7清空队列

  8遍历队列

 */

#include<stdio.h>

#include<malloc.h>



typedef struct FIFO

{

	int man;// nuber

	int Qsize;// sizeof FIFO

	struct FIFO* next; // next &

}NewQueue;

// Nuber one	初始化

NewQueue* InitQueue(NewQueue* queue);

// Nuber two	确定是否为空

int JudegQueue(NewQueue* queue);

// Nuber three	确定是否已满

//int FullQueue(NewQueue *queue);

// Nuber four	确定队列中的项数

int TailForNuber(NewQueue* queue);

// Nuber five	插入队列

NewQueue* PushQueue(NewQueue* queue, int nuber);

// Nuber six	删除队列

NewQueue* DelQueue(NewQueue* queue);

// Nuber seven	清空队列

NewQueue* ClearQueue(NewQueue* queue);

// Nuber eight	遍历队列

void ErgoQueue(NewQueue* queue);

int main()

{

	int Nuber;

	NewQueue* head =NULL, * tail=NULL;

	printf(" Nuber one	初始化.........\t");

	printf("成功!\n");

	for (Nuber = 0; Nuber < 5; Nuber++)

	{

		tail = InitQueue(tail);

		if (head->next = NULL)

			head->next = tail;

		printf("插入%d......\t", Nuber);

		PushQueue(tail, Nuber);

		printf("成功!\n");

	}

		printf("删除头结点.....\t");

		DelQueue(head);

		printf("成功!\n");

		printf("删除了头结点数值　%d\n",head->next->man);

	printf("遍历队列．．．．\t");

	ErgoQueue(head);

	printf("成功!\n");

	printf("清空队列.......\t");

	head = ClearQueue(head);

	printf("成功!\n");





	return 0;

}

NewQueue* InitQueue(NewQueue* queue)

{

	queue = (NewQueue*)malloc(sizeof(NewQueue));

	queue->man = 0;

	queue->Qsize = 0;

	queue->next = NULL;

	return queue;

}

int JudegQueue(NewQueue* queue)

{

	if (queue->next == NULL)

	{

		printf("无人排队!\t 可以休息了....\n");

		return 1;



	}

	else

		return 0;

}

int TailForNuber(NewQueue* queue)

{

	return queue->Qsize;

}

NewQueue* PushQueue(NewQueue* queue, int nuber)

{

	queue->man = nuber;

	queue->Qsize++;

	queue->next = NULL;

	return queue;

}

NewQueue* DelQueue(NewQueue* queue)

{

	printf("开始清理！\n");

	if (!JudegQueue(queue))

	{

		NewQueue* net;

		net = queue->next;

		queue->next = net->next;

		free(net);

		printf("清理结束！\t");

	}

	printf("成功!\n");

	return queue;

}

NewQueue* ClearQueue(NewQueue* queue)

{

	while (!JudegQueue(queue))

	{

		DelQueue(queue);

	}

	return queue;

}

void ErgoQueue(NewQueue* queue)

{

	NewQueue* head = queue->next;

	while (!JudegQueue(queue))

	{

		printf("第%d位\t 变量为%d\n", head->Qsize, head->man);

		head = head->next;

	}

}

...全文
100 9 打赏 收藏 转发到动态 举报
写回复
用AI写文章
9 条回复
切换为时间正序
请发表友善的回复…
发表回复
Gnglas 2020-01-14
  • 打赏
  • 举报
 回复
引用 6 楼 寻开心的回复:
函数名字都是怪怪的， 最好还是改成常用的队列操作
push， pop等这种命令， isEmpty，

// 定义队列里面的节点结构
typedef struct FIFO
{
int man;// nuber
int Qsize;// sizeof FIFO
struct FIFO* next; // next &
} Node;

// 这个才是队列本身
typedef struct Queue {
Node * head;
Node * tail;
} Queue;

// 下面的函授都传递指针而不是结构
void pushQ(Queue* queue, int Nuber);
int isEmptyQ(Queue* queue);
int sizeQ(Queue* queue);
void popQ(Queue* queue);
void clearQ(Queue* queue);
void printQ(Queue* queue);

int main()
{
Queue que={NULL,NULL}, *q =&que;

int Nuber;
for (Nuber = 0; Nuber < 5; Nuber++)
{
pushQ(q, Nuber);
}
printQ (q);

if ( q->head )
printf("删除头结点的man值是：%d\n", q->head->man);
popQ(q);
printQ(q);

clearQ(q);
return 0;
}

// 尾巴上增加一个
void pushQ(Queue* queue, int nuber)
{
Node* pNew = (Node*)malloc(sizeof(Node));
pNew->man = nuber;
pNew->Qsize = 0;
pNew->next = NULL;
if (queue->tail) {
pNew->Qsize = queue->tail->Qsize +1;
queue->tail->next = pNew;
queue->tail = pNew;
} else {
queue->head = queue->tail = pNew;
};
}

// 判断是否为空，完全没有必要， head是NULL才是空
int isEmptyQ(Queue* queue)
{
return queue->head==NULL;
}

// 计算队列的长度
int sizeQ(Queue* queue)
{
if ( queue->head == NULL) return 0;
return queue->tail->Qsize - queue->head->Qsize+1;
}

// 从头摘下来一个
void popQ(Queue* queue)
{
if (!isEmptyQ(queue))
{
Node* net = queue->head;
queue->head = queue->head->next;
if (isEmptyQ(queue)) queue->tail=NULL;
free(net);
} else
printf("队列是空的!\n");
}

// 整个队列全部清空
void clearQ(Queue* queue)
{
while (!isEmptyQ(queue))
{
popQ(queue);
}
}
// 输出整个队列的内容
void printQ(Queue* queue)
{
printf("总共有节点%d个：\n", sizeQ(queue));
Node* pNode = queue->head;
int n = 0;
while ( pNode )
{
printf("第%d位\t Qsize:%d,\tman:%d\n", ++n, pNode->Qsize, pNode->man);
pNode = pNode->next;
}
}
感谢大佬，谢谢，麻烦了
Gnglas 2020-01-14
  • 打赏
  • 举报
 回复
引用 8 楼 Gnglas 的回复:
[quote=引用 7 楼 Gnglas的回复:][quote=引用 6 楼 寻开心的回复:]函数名字都是怪怪的， 最好还是改成常用的队列操作
push， pop等这种命令， isEmpty，

// 定义队列里面的节点结构
typedef struct FIFO
{
int man;// nuber
int Qsize;// sizeof FIFO
struct FIFO* next; // next &
} Node;

// 这个才是队列本身
typedef struct Queue {
Node * head;
Node * tail;
} Queue;

// 下面的函授都传递指针而不是结构
void pushQ(Queue* queue, int Nuber);
int isEmptyQ(Queue* queue);
int sizeQ(Queue* queue);
void popQ(Queue* queue);
void clearQ(Queue* queue);
void printQ(Queue* queue);

int main()
{
Queue que={NULL,NULL}, *q =&que;

int Nuber;
for (Nuber = 0; Nuber < 5; Nuber++)
{
pushQ(q, Nuber);
}
printQ (q);

if ( q->head )
printf("删除头结点的man值是：%d\n", q->head->man);
popQ(q);
printQ(q);

clearQ(q);
return 0;
}

// 尾巴上增加一个
void pushQ(Queue* queue, int nuber)
{
Node* pNew = (Node*)malloc(sizeof(Node));
pNew->man = nuber;
pNew->Qsize = 0;
pNew->next = NULL;
if (queue->tail) {
pNew->Qsize = queue->tail->Qsize +1;
queue->tail->next = pNew;
queue->tail = pNew;
} else {
queue->head = queue->tail = pNew;
};
}

// 判断是否为空，完全没有必要， head是NULL才是空
int isEmptyQ(Queue* queue)
{
return queue->head==NULL;
}

// 计算队列的长度
int sizeQ(Queue* queue)
{
if ( queue->head == NULL) return 0;
return queue->tail->Qsize - queue->head->Qsize+1;
}

// 从头摘下来一个
void popQ(Queue* queue)
{
if (!isEmptyQ(queue))
{
Node* net = queue->head;
queue->head = queue->head->next;
if (isEmptyQ(queue)) queue->tail=NULL;
free(net);
} else
printf("队列是空的!\n");
}

// 整个队列全部清空
void clearQ(Queue* queue)
{
while (!isEmptyQ(queue))
{
popQ(queue);
}
}
// 输出整个队列的内容
void printQ(Queue* queue)
{
printf("总共有节点%d个：\n", sizeQ(queue));
Node* pNode = queue->head;
int n = 0;
while ( pNode )
{
printf("第%d位\t Qsize:%d,\tman:%d\n", ++n, pNode->Qsize, pNode->man);
pNode = pNode->next;
}
}

感谢大佬，谢谢，麻烦了[/quote]
大叔我改了之后怎么还是错的[/quote]
/*************************************************************************
> File Name: queue2.c
> Author: Gnglas
> Mail: 2254228017@qq.com
> Created Time: 2020年01月13日 星期一 11时46分58秒
************************************************************************/
/*
1初始化队列
2确定队列为空
3确定队列已满
4确定队列中的项数
5插入队列
6删除队列
7清空队列
8遍历队列
*/
#include<stdio.h>
#include<malloc.h>

typedef struct FIFO
{
int man;// nuber
int Qsize;// sizeof FIFO
struct FIFO* next; // next &
}NewQueue;
// Nuber one 初始化
NewQueue* InitQueue(NewQueue* queue,int nuber);
// Nuber two 确定是否为空
int JudegQueue(NewQueue* queue);
// Nuber three 确定是否已满
//int FullQueue(NewQueue *queue);
// Nuber four 确定队列中的项数
int TailForNuber(NewQueue* queue);
// Nuber five 插入队列
NewQueue* PushQueue(NewQueue* queue, int nuber);
// Nuber six 删除队列
NewQueue* DelQueue(NewQueue* queue);
// Nuber seven 清空队列
NewQueue* ClearQueue(NewQueue* queue);
// Nuber eight 遍历队列
void ErgoQueue(NewQueue* queue);
int main()
{
int Nuber;
NewQueue* head = NULL, * tail = NULL;
printf(" Nuber one 初始化.........\t");
printf("成功!\n");
for (Nuber = 0; Nuber < 5; Nuber++)
{
tail = InitQueue(tail,Nuber);
if (head == NULL) head = tail;
printf("插入%d......\t", Nuber);
printf("成功!\n");
}
ErgoQueue(head);
printf("删除头结点.....\t");
head = DelQueue(head);
printf("成功!\n");
printf("删除了头结点数值　%d\n", head->man);

printf("遍历队列．．．．\t");
ErgoQueue(head);
printf("成功!\n");
printf("清空队列.......\t");
head = ClearQueue(head);
printf("成功!\n");


return 0;
}
NewQueue* InitQueue(NewQueue* queue,int nuber)
{
NewQueue * not = (NewQueue*)malloc(sizeof(NewQueue));
not->man = nuber;
not->Qsize = 0;
not->next = NULL;
if (queue)
{
not->Qsize = queue->Qsize + 1;
queue->next = not;
};
return not;
}
int JudegQueue(NewQueue* queue)
{
return queue != NULL;
}
int TailForNuber(NewQueue* queue)
{
return queue->Qsize;
}

NewQueue* DelQueue(NewQueue* queue)
{
printf("开始清理！\n");
if (JudegQueue(queue))
{
NewQueue* net = queue;
queue = queue->next;
free(net);
printf("清理结束！\t");
// printf("成功!\n");
}

else
printf("队列是空的！\n");
return queue;
}
NewQueue* ClearQueue(NewQueue* queue)
{
while (JudegQueue(queue))
{
queue = DelQueue(queue);
}
return queue;
}
void ErgoQueue(NewQueue* queue)
{
NewQueue* head = queue;
while (JudegQueue(queue))
{
printf("第%d位\t 变量为%d\n", head->Qsize, head->man);
head = head->next;
}
}
Gnglas 2020-01-14
  • 打赏
  • 举报
 回复
引用 7 楼 Gnglas的回复:
[quote=引用 6 楼 寻开心的回复:]函数名字都是怪怪的， 最好还是改成常用的队列操作
push， pop等这种命令， isEmpty，

// 定义队列里面的节点结构
typedef struct FIFO
{
int man;// nuber
int Qsize;// sizeof FIFO
struct FIFO* next; // next &
} Node;

// 这个才是队列本身
typedef struct Queue {
Node * head;
Node * tail;
} Queue;

// 下面的函授都传递指针而不是结构
void pushQ(Queue* queue, int Nuber);
int isEmptyQ(Queue* queue);
int sizeQ(Queue* queue);
void popQ(Queue* queue);
void clearQ(Queue* queue);
void printQ(Queue* queue);

int main()
{
Queue que={NULL,NULL}, *q =&que;

int Nuber;
for (Nuber = 0; Nuber < 5; Nuber++)
{
pushQ(q, Nuber);
}
printQ (q);

if ( q->head )
printf("删除头结点的man值是：%d\n", q->head->man);
popQ(q);
printQ(q);

clearQ(q);
return 0;
}

// 尾巴上增加一个
void pushQ(Queue* queue, int nuber)
{
Node* pNew = (Node*)malloc(sizeof(Node));
pNew->man = nuber;
pNew->Qsize = 0;
pNew->next = NULL;
if (queue->tail) {
pNew->Qsize = queue->tail->Qsize +1;
queue->tail->next = pNew;
queue->tail = pNew;
} else {
queue->head = queue->tail = pNew;
};
}

// 判断是否为空，完全没有必要， head是NULL才是空
int isEmptyQ(Queue* queue)
{
return queue->head==NULL;
}

// 计算队列的长度
int sizeQ(Queue* queue)
{
if ( queue->head == NULL) return 0;
return queue->tail->Qsize - queue->head->Qsize+1;
}

// 从头摘下来一个
void popQ(Queue* queue)
{
if (!isEmptyQ(queue))
{
Node* net = queue->head;
queue->head = queue->head->next;
if (isEmptyQ(queue)) queue->tail=NULL;
free(net);
} else
printf("队列是空的!\n");
}

// 整个队列全部清空
void clearQ(Queue* queue)
{
while (!isEmptyQ(queue))
{
popQ(queue);
}
}
// 输出整个队列的内容
void printQ(Queue* queue)
{
printf("总共有节点%d个：\n", sizeQ(queue));
Node* pNode = queue->head;
int n = 0;
while ( pNode )
{
printf("第%d位\t Qsize:%d,\tman:%d\n", ++n, pNode->Qsize, pNode->man);
pNode = pNode->next;
}
}
感谢大佬，谢谢，麻烦了[/quote] 大叔我改了之后怎么还是错的
寻开心 2020-01-13
  • 打赏
  • 举报
 回复
函数名字都是怪怪的， 最好还是改成常用的队列操作
push， pop等这种命令， isEmpty，

// 定义队列里面的节点结构
typedef struct FIFO
{
int man;// nuber
int Qsize;// sizeof FIFO
struct FIFO* next; // next &
} Node;

// 这个才是队列本身
typedef struct Queue {
Node * head;
Node * tail;
} Queue;

// 下面的函授都传递指针而不是结构
void pushQ(Queue* queue, int Nuber);
int isEmptyQ(Queue* queue);
int sizeQ(Queue* queue);
void popQ(Queue* queue);
void clearQ(Queue* queue);
void printQ(Queue* queue);

int main()
{
Queue que={NULL,NULL}, *q =&que;

int Nuber;
for (Nuber = 0; Nuber < 5; Nuber++)
{
pushQ(q, Nuber);
}
printQ (q);

if ( q->head )
printf("删除头结点的man值是：%d\n", q->head->man);
popQ(q);
printQ(q);

clearQ(q);
return 0;
}

// 尾巴上增加一个
void pushQ(Queue* queue, int nuber)
{
Node* pNew = (Node*)malloc(sizeof(Node));
pNew->man = nuber;
pNew->Qsize = 0;
pNew->next = NULL;
if (queue->tail) {
pNew->Qsize = queue->tail->Qsize +1;
queue->tail->next = pNew;
queue->tail = pNew;
} else {
queue->head = queue->tail = pNew;
};
}

// 判断是否为空，完全没有必要， head是NULL才是空
int isEmptyQ(Queue* queue)
{
return queue->head==NULL;
}

// 计算队列的长度
int sizeQ(Queue* queue)
{
if ( queue->head == NULL) return 0;
return queue->tail->Qsize - queue->head->Qsize+1;
}

// 从头摘下来一个
void popQ(Queue* queue)
{
if (!isEmptyQ(queue))
{
Node* net = queue->head;
queue->head = queue->head->next;
if (isEmptyQ(queue)) queue->tail=NULL;
free(net);
} else
printf("队列是空的!\n");
}

// 整个队列全部清空
void clearQ(Queue* queue)
{
while (!isEmptyQ(queue))
{
popQ(queue);
}
}
// 输出整个队列的内容
void printQ(Queue* queue)
{
printf("总共有节点%d个：\n", sizeQ(queue));
Node* pNode = queue->head;
int n = 0;
while ( pNode )
{
printf("第%d位\t Qsize:%d,\tman:%d\n", ++n, pNode->Qsize, pNode->man);
pNode = pNode->next;
}
}
寻开心 2020-01-13
  • 打赏
  • 举报
 回复
单向链表也可以改，这样的
typedef struct FIFO
{
int man;// nuber
int Qsize;// sizeof FIFO
struct FIFO* next; // next &
}NewQueue;
// Nuber one 初始化
NewQueue* InitQueue(NewQueue* queue, int Nuber);
// Nuber two 确定是否为空
int JudegQueue(NewQueue* queue);
// Nuber three 确定是否已满
//int FullQueue(NewQueue *queue);
// Nuber four 确定队列中的项数
int TailForNuber(NewQueue* head, NewQueue* tail);
// Nuber five 插入队列
NewQueue* PushQueue(NewQueue* queue, int nuber);
// Nuber six 删除队列
NewQueue* DelQueue(NewQueue* queue);
// Nuber seven 清空队列
NewQueue* ClearQueue(NewQueue* queue);
// Nuber eight 遍历队列
void ErgoQueue(NewQueue* queue);

int main()
{
int Nuber;
NewQueue* head =NULL, * tail=NULL;
printf(" Nuber one 初始化.........\t");
printf("成功!\n");
for (Nuber = 0; Nuber < 5; Nuber++)
{
tail = InitQueue(tail, Nuber);
if ( head == NULL ) head = tail;
printf("插入%d......\t", Nuber);
printf("成功!\n");
}
ErgoQueue(head);

printf("删除头结点.....\t");
printf("删除了头结点数值　%d\n",head->man);
head = DelQueue(head);
printf("成功!\n");
printf("遍历队列．．．．\t");
ErgoQueue(head);
printf("成功!\n");
printf("清空队列.......\t");
head = ClearQueue(head);
printf("成功!\n");
return 0;
}

// 尾巴上增加一个
NewQueue* InitQueue(NewQueue* queue, int nuber)
{
NewQueue* pNew = (NewQueue*)malloc(sizeof(NewQueue));
pNew->man = nuber;
pNew->Qsize = 0;
pNew->next = NULL;
if (queue) {
pNew->Qsize = queue->Qsize +1;
queue->next = pNew;
};
return pNew;
}

// 判断是否为空，完全没有必要， head是NULL才是空
int JudegQueue(NewQueue* queue)
{
return queue!=NULL;
}

// 计算队列的长度
int TailForNuber(NewQueue* head, NewQueue* tail)
{
if ( head == NULL) return 0;
return tail->Qsize - head->Qsize+1;
}

// 从头摘下来一个
NewQueue* DelQueue(NewQueue* queue)
{
if (JudegQueue(queue))
{
NewQueue* net = queue;
queue = queue->next;
free(net);
printf("摘下头节点一个！\t");
} else
printf("队列是空的!\n");
return queue;
}

// 整个队列全部清空
NewQueue* ClearQueue(NewQueue* queue)
{
while (JudegQueue(queue))
{
queue = DelQueue(queue);
}
return queue;
}
// 输出整个队列的内容
void ErgoQueue(NewQueue* queue)
{
NewQueue* pNode = queue;
while (JudegQueue(pNode))
{
printf("第%d位\t 变量为%d\n", pNode->Qsize, pNode->man);
pNode = pNode->next;
}
}
Gnglas 2020-01-13
  • 打赏
  • 举报
 回复
引用 3 楼 寻开心 的回复:
显然用单向链表做队列并不是好的选择， 要么在尾巴加的时候，要么在头上摘，必然会有一个要去遍历整个链表，这效率显然不高。
除非是题目要求，否则这里应该用双向链表来实现。
应该构造一个结构来记录当前队列当中的数据数量，头指针和尾指针
双向链表定义：
struct Link {
int data;
Link* next;
Link* pre;
}
队列的数据结构

struct queue {
int nSize;
Link * pHead;
Line * pTail;
}
这样的结构会让你的队列的操作容易的多。

好的
寻开心 2020-01-13
  • 打赏
  • 举报
 回复
显然用单向链表做队列并不是好的选择， 要么在尾巴加的时候，要么在头上摘，必然会有一个要去遍历整个链表，这效率显然不高。
除非是题目要求，否则这里应该用双向链表来实现。
应该构造一个结构来记录当前队列当中的数据数量，头指针和尾指针
双向链表定义：
struct Link {
int data;
Link* next;
Link* pre;
}
队列的数据结构
struct queue {
int nSize;
Link * pHead;
Line * pTail;
}
这样的结构会让你的队列的操作容易的多。

遇见女神 2020-01-13
  • 打赏
  • 举报
 回复
你的head是null，然后你引用head->next就报错了。
Gnglas 2020-01-13
  • 打赏
  • 举报
 回复
不好意思，错误太多了，希望大佬耐心一点
C语言数据结构与算法编程、链表、树、栈、队列、排序算法
黄老师通过对数据结构核心知识点： 顺序表、链表、栈、队列、树、二叉树、遍历、插入、删除、排序、查找算法 的细心讲解，结合生动的C语言实战代码演练、帮助学员快速掌握数据结构的核心内容、为STL、Boost标准库的...
耗时一个月我问遍了身边的大佬，零基础自学Java的路线，适用程序员入门&进阶，Java学习路线，2024新版
无论处于哪个阶段，一条明确的学习路线都至关重要，小明通过向众多行业大佬请教、反复探索和实践，总结出一套适用于零基础自学者大学四年Java学习路线，也同样适用于从初级到研发专家的学习路线。
数据结构大全(一)
链表环问题 移除链表元素 回文链表 链表表示整数，相加 LRU LFU 合并链表 反转链表 反转链表2 对链表排序 旋转链表 数组实现栈 链表实现栈 数组实现队列 链表实现队列 双栈的实现 栈/队列 互相...
大一c语言知识点总结树状图,AK宝典丨哟，写bug呐？19级数据结构满分dalao在线帮你划重点！...
这是 北航士谔书院的第 1482篇推送经过寒假的预习你一定对 春季学期的课程有了十足的底气和信心了吧？你心目中最简单的课程是哪一门呢？是不是 数据结构与程序设计？ 怎么可能…… 士小信你别着急呀，我有一个好...
初来乍到，请多关照
最后，欢迎各位小伙伴留言分享自己的学习经历，也可以来和我讨论和编程相关的问题，还请各位编程大佬多多指教｡铁铁，奥利给✧٩(ˊωˋ*)و✧！5. 学习并掌握常用的数据结构和算法，如数组、链表、栈、队列、排序...
其它技术问题

3,881

社区成员

9,054

社区内容

发帖
与我相关
我的任务
社区描述
C/C++ 其它技术问题
社区管理员
  • 其它技术问题社区
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

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

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

+ 用AI写文章