若用单链表表示队列（《数据结构》假设用一个循环单链表来表示队列（称为循环链队），）

本文目录

• 《数据结构》假设用一个循环单链表来表示队列（称为循环链队），
• 在用单链表表示的链式队列Q中，对空条件
• 用循环单链表实现循环队列,如何写出插入和删除的算法
• 用单循环链表来表示队列（也称为循环队列），只设一个队尾指针
• C语言 用单链表实现队列
• 如果用一个循环单链表表示队列（称为循环队列），该队列只设一个尾指针rear，不设队首指针，编写程序
• 若用单链表来表示队列,应该选用（）

《数据结构》假设用一个循环单链表来表示队列（称为循环链队），

typedef int ElemType;
//定义链表
typedef struct lnode
{
ElemType data;//数据域
struct lnode *next;//后继指针
}LNode;
//定义链队列将头尾指针封装在一起的链队
typedef struct
{
LNode *rear;//对尾指针
}QueueNode;
//入对
void Insert(QueueNode *q,ElemType x)
{
LNode *s;
s=(LNode *)malloc(sizeof(LNode));
if(s==NULL)
exit(1);
s-》data = x;//赋值
s-》next=q-》rear-》next;//新节点后继指向对尾后继
q-》rear-》next=s;//对尾后继指向新节点
q-》rear=s;//对尾指向新节点
}

在用单链表表示的链式队列Q中，对空条件

因为当队列中只有一个元素的时候 front和rear都指向第一个元素 此时队列不为空
只有front=rear=null时 队列才为空
忘采纳

用循环单链表实现循环队列,如何写出插入和删除的算法

typedef struct CircleListNode{

Datatype d;          

struct CircleList *pre,*nxt;          

}*CircleList,CirListNode;

typedef struct

{

CircleList Head;   

int num;

}CircleQueue;

void insertFront(CircleList *L,d);

{

if(!L)return NULL;

if(*L==NULL)

{

*L=(CircleList) malloc(sizeof(CirListNode));

*L-》nxt=  *L-》pre=*L ;

*L-》d=d;

}

else

{        

CircleList p =(CircleList) malloc(sizeof(CirListNode));

p-》nxt=*L;

p-》pre=*L-》pre;

*L-》pre-》nxt=p;

*L-》pre=p;

*L=p;           

}  

}

循环单链表是单链表的另一种形式，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。和单链表相同，循环链表也有带头结点结构和不带头结点结构两种，带头结点的循环单链表实现插入和删除操作较为方便。

用单循环链表来表示队列（也称为循环队列），只设一个队尾指针

struct Element{ int data; Element * next;}; void DelElement(Element * prev){ Element * tmp=prev-》next; prev.next=tmp.next tmp.next=null; free(tmp)}

C语言 用单链表实现队列

网络答案，已验证：
#include《stdio.h》
#include《stdlib.h》
struct Node
{
int data; /*值域*/
struct Node *next; /*链接指针*/
};
struct queue
{
struct Node *front; /*队首指针*/
struct Node *rear; /*队尾指针*/
};
/*初始化链队*/
void initQueue(struct queue *hq)
{
hq-》front=hq-》rear=NULL; /*把队首和队尾指针置空*/
}
/*向链队中插入一个元素x*/
void inQueue(struct queue *hq, int x)
{
struct Node *newNode; /*得到一个由newNode指针所指向的新结点*/
newNode=malloc(sizeof(struct Node));
if(newNode==NULL)
{
printf("内存空间分配失败！ ");
exit(1);
}
newNode-》data=x; /*把x的值赋给新结点的值域*/
newNode-》next=NULL; /*把新结点的指针域置空*/
/*若链队为空，则新结点即是队首结点又是队尾结点*/
if(hq-》rear==NULL)
{
hq-》front=hq-》rear=newNode;
}else
{
/*若链队非空，则依次修改队尾结点的指针域和队尾指针，使之指向新的队尾结点*/
hq-》rear=hq-》rear-》next=newNode;
}
//return;
}
/*从队列中删除一个元素*/
int delQueue(struct queue*hq)
{
struct Node*p;
int temp;
/*若链队为空则停止运行*/
if(hq-》front==NULL)
{
printf("队列为空，无法删除！ ");
exit(1);
}
temp=hq-》front-》data;
/*暂存队首元素以便返回*/
p=hq-》front;
/*暂存队首指针以便回收队尾结点*/
hq-》front=p-》next; /*使队首指针指向下一个结点*/
/*若删除后链队为空，则需同时使队尾指针为空*/
if(hq-》front==NULL)
{
hq-》rear=NULL;
}
free(p); /*回收原队首结点*/
return temp; /*返回被删除的队首元素值*/
}
/*读取队首元素*/
int peekQueue(struct queue *hq)
{ /*若链队为空则停止运行*/
if(hq-》front==NULL)
{
printf("队列为空，无法删除！ ");
exit(1);
}
return hq-》front-》data; /*返回队首元素*/
}
/*检查链队是否为空，若为空则返回1,否则返回0*/
int emptyQueue(struct queue *hq)
{
/*判断队首或队尾任一个指针是否为空即可*/
if(hq-》front==NULL)
{
return 1;
}else
{
return 0;
}
}
/*清除链队中的所有元素*/
void clearQueue(struct queue *hq)
{
struct Node *p=hq-》front; /*队首指针赋给p*/
/*依次删除队列中的每一个结点，最后使队首指针为空*/
while(p!=NULL)
{
hq-》front=hq-》front-》next;
free(p);
p=hq-》front;
}
/*循环结束后队首指针已经为空*/
hq-》rear=NULL; /*置队尾指针为空*/
return;
}
int main(int argc,char *argv)
{
struct queue q;
int a={3,8,5,17,9,30,15,22};
int i;
initQueue(&q);
for(i=0;i《8;i++)
{
inQueue(&q,a);
}
printf("delnode is %d\n",delQueue(&q));
printf("delnode is %d\n",delQueue(&q));
inQueue(&q,68);
printf("peeknode is %d\n",peekQueue(&q));
while(!emptyQueue(&q))
{
printf("%d\n",delQueue(&q));
}
clearQueue(&q);
}

如果用一个循环单链表表示队列（称为循环队列），该队列只设一个尾指针rear，不设队首指针，编写程序

你这是要用 C 语言实现吧？ 我很少用 C 语言，所以一下子也写不出程序给你。不过这个原理倒是不难。
单链表你会写吗？如果会，你把链表最后一项的尾指针指向第一个元素，就成了你说的循环链表了。
首元素和尾元素可能需要加个标志。
注意：
追加元素的时候，被追加元素的指针要指向首元素。
删除最后一个元素的时候，更新前一项的指针，使其指向首元素。
补充：
给你提供一个不考虑插入和删除中间元素的例子
#include 《stdio.h》
#include 《string.h》
#include 《stdlib.h》
#define MAX_LENGTH 5
struct list {
int key;
char name;
struct list *next;
};
struct list *add_list(int key, char *name, struct list *parent);
void show_list(struct list *p);
void free_list(struct list *p);
struct list *first;
int main(void)
{
struct list *parent;
char name;
int key = 0;
parent = NULL;
int count = 0;
printf("Please input key and name (length 《 20), END: CTRL+Z\n");
while (scanf("%d %s", &key, name) != EOF) {
parent = add_list(key, name, parent);
count++;
if(count == 1) first = parent;
if(count == MAX_LENGTH) break;
}
show_list(first);
free_list(first);
return 0;
}
/*** 追加队列成员 ***/
struct list *add_list(int key, char *name, struct list *parent)
{
struct list *p;
if ((p = (struct list *) malloc(sizeof(struct list))) == NULL) {
printf("malloc error\n");
exit(EXIT_FAILURE);
}
p-》key = key;
strcpy(p-》name, name);
if(parent == NULL) {
parent = p;
first = p;
} else {
parent-》next = p;
p-》next = first;
}
return p;
}
/*** 显示队列 ***/
void show_list(struct list *p)
{
while (p != NULL) {
printf("%3d %s\n", p-》key, p-》name);
p = p-》next;
if(p-》key == first-》key) break;
}
}
/*** 清空队列 ***/
void free_list(struct list *p)
{
struct list *p2;
while (p != NULL) {
p2 = p-》next;
free(p);
p = p2;
if(p-》key == first-》key) break;
}
}
运行结果：
输入
1 aa
2 bb
3 cc
4 dd
5 ee
输出
1 aa
2 bb
3 cc
4 dd
5 ee

若用单链表来表示队列,应该选用（）

带尾指针的循环链表，B。
此类题型以时间复杂度入手。首先明确：循环链表是指尾指针的next指向头结点，但与双循环链表不同的是，从头结点遍历到尾结点的时间复杂度为O(n)。而队列操作的插入和删除分别在一头一尾进行。
因此，CD选项在进行删除操作时，都需要从头遍历到尾，复杂度O(n);
A选项只能进行删除操作，因为无法遍历回头结点。
而B选项在插入时，直接在尾部后面插入新的结点，O(1);删除时，让尾结点的next指向下一个结点，O（1）。