user-0 提问: c语言链式队列问题

回复:
user: user-0
content: 引用 10 楼 jsx_SEVEN的回复:[quote=引用 9 楼 qq_38780412的回复:][quote=引用 8 楼 jsx_SEVEN的回复:][quote=引用 7 楼 qq_38780412 的回复:] [quote=引用 6 楼 jsx_SEVEN的回复:][quote=引用 5 楼 qq_38780412 的回复:] [quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········ [/quote] Q->front-next不是指向第一个有元素的结点吗？ Q->rear=Q->front->next;这个不是把第一个结点Q->rear吗？[/quote] Q->front指向的是第一个结点，Q->front->next指向的是第二个结点[/quote] 你是说不带头节点的吗？还是带头节点的啊？[/quote] 不带头结点，，嗯，对，不带[/quote] 我以为是带头节点的  我再看看你你之前说的  按照有带头结点的再想想

user: user-1
content: 引用 9 楼 qq_38780412的回复:[quote=引用 8 楼 jsx_SEVEN的回复:][quote=引用 7 楼 qq_38780412 的回复:] [quote=引用 6 楼 jsx_SEVEN的回复:][quote=引用 5 楼 qq_38780412 的回复:] [quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········ [/quote] Q->front-next不是指向第一个有元素的结点吗？ Q->rear=Q->front->next;这个不是把第一个结点Q->rear吗？[/quote] Q->front指向的是第一个结点，Q->front->next指向的是第二个结点[/quote] 你是说不带头节点的吗？还是带头节点的啊？[/quote] 不带头结点，，嗯，对，不带

user: user-0
content: 引用 8 楼 jsx_SEVEN的回复:[quote=引用 7 楼 qq_38780412 的回复:] [quote=引用 6 楼 jsx_SEVEN的回复:][quote=引用 5 楼 qq_38780412 的回复:] [quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········ [/quote] Q->front-next不是指向第一个有元素的结点吗？ Q->rear=Q->front->next;这个不是把第一个结点Q->rear吗？[/quote] Q->front指向的是第一个结点，Q->front->next指向的是第二个结点[/quote] 你是说不带头节点的吗？还是带头节点的啊？

user: user-1
content: 引用 7 楼 qq_38780412 的回复:[quote=引用 6 楼 jsx_SEVEN的回复:][quote=引用 5 楼 qq_38780412 的回复:] [quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········ [/quote] Q->front-next不是指向第一个有元素的结点吗？ Q->rear=Q->front->next;这个不是把第一个结点Q->rear吗？[/quote] Q->front指向的是第一个结点，Q->front->next指向的是第二个结点

user: user-0
content: 引用 6 楼 jsx_SEVEN的回复:[quote=引用 5 楼 qq_38780412 的回复:] [quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········ [/quote] Q->front-next不是指向第一个有元素的结点吗？ Q->rear=Q->front->next;这个不是把第一个结点Q->rear吗？

user: user-1
content: 引用 5 楼 qq_38780412 的回复:[quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········

user: user-0
content: 引用 4 楼 jsx_SEVEN的回复:[quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊

user: user-1
content: 引用 3 楼 qq_38780412 的回复:[quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。

user: user-0
content: 引用 2 楼 jsx_SEVEN的回复: //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解

user: user-1
content: //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队

user: user-2
content: 看图最直接，上图，自己对比有没有必要~  理解半天不如动手画个图~~