C语言编程题，实现一个顺序存储的循环队列。

Posted 2023-03-13

#include<stdio.h>
#include<stdbool.h>
#include<malloc.h>

typedef int typedata;
struct node

struct node *prev, *next;
typedata data;
;
typedef struct node node;
typedef struct node* link;

// ============init_head=============== //
//头节点的初始化
link init_head(void)

link head = (link)malloc(sizeof(node));

if(head != NULL)

head->prev = head->next = head;


return head;


// ============newnode ================ //
//创建新节点
link newnode(typedata data)

link new = (link)malloc(sizeof(node));

if(new != NULL)

//前趋指针和后趋指针都指向自己

new->prev = new->next = new;
new->data = data;


return new;

// =================is_empty================ //
bool is_empty(link head)

//为空时，头节点的前趋指针和后趋指针都指向head（头节点）

if((head->next==head) && (head->prev==head))
return true;
return false;

// ================insert_tail ================== //
void insert_tail(link head, link new)

if(is_empty(head))

//第一个节点插入

head->next = head->prev = new;
new->next = new->prev = head;
return ;


//除了第一个节点插入

new->prev = head->prev;
new->next = head;

new->prev->next = new;
new->next->prev = new;

// ================show ==================== //
void show(link head)

//为空时，直接返回

if(is_empty(head))
return ;

//遍历整个链

link tmp = head->next;
while(tmp != head)

printf("%d\t", tmp->data);
tmp = tmp->next;

printf("\n");

// ==============insert_opint =============== //
void insert_opint(link end_node, link p)

p->prev = end_node;
p->next = end_node->next;

end_node->next->prev = p;
end_node->next = p;


// ================insertion_sort=========== //
//顺序排序
void insertion_sort(link head)

if(is_empty(head))
return;

//把队列分拆，头节点和第一个节点为一个已排序的队列，
//其他的节点逐个比较已排序队列插

link p = head->next->next;
head->prev->next = NULL;

head->next->next = head;
head->next->prev = head;
head->prev = head->next;

while(p != NULL)

link end_node = head->prev;

if(p->data > end_node->data)

link tmp = p;
p = p->next;
insert_tail(head, tmp);


else

while(end_node!=head && p->data<end_node->data)
end_node = end_node->prev;

link tmp = p;
p = p->next;
insert_opint(end_node, tmp);



int main(void)

link head = init_head();
if(head == NULL)

printf("falure\n");
return 0;


typedata data;
while(1)

if(scanf("%d", &data) != 1 )
break;

link new = newnode(data);
if(new == NULL)

printf("falure\n");
return 0;


insert_tail(head, new);
show(head);


printf("the figure is:\n");
show(head);

insertion_sort(head);
show(head);

return 0;
参考技术A 什么意思！追问

不知道。。。任意写一个吧。。。。。。

数据结构(C语言版)严蔚敏-＞队列的顺序存储(循环队列)和链式存储

1. 队列的顺序存储

1.1 队列的顺序存储结构：

#define MaxSize 50 // 定义队列中的元素的最大个数
typedef struct
	ElemType data[MaxSize];
	int front,rear; // 对头指针和队尾指针
SqQueue;

1.2 队列的初始状态、进队操作及出队操作

• 初始状态：Q.front = Q.rear = 0;
• 进队操作：队列不满时，先送值到队尾元素，再将队尾指针加1；
• 出队操作：队列不空时，先取对头元素值，再将对头指针加1；

【注】：队列为空时，有Q.front==Q.rear=0成立；不能用Q.rear = MaxSize 来队列已满。

1.3 循环队列

把存储队列元素的表从逻辑上视为一个环，称为循环队列。

• 初始状态：Q.front = Q.rear = 0
• 入队操作后队尾指针进1：Q.rear =(Q.rear+1)%MaxSize;
• 出队操作后对头指针进1：Q.front = (Q.front+1)%MaxSize;
• 队列长度：(Q.rear-Q.front+MaxSize)%MaxSize;

【注】：队列为空的条件是Q.front = Q.rear;若入队元素的速度快于出队元素的速度，则队尾指针很快就追上了对头指针，此时对满时也有Q.front = Q.rear，为了区分对空还是对满，有如下3中处理方式。

• 牺牲一个单元来区分对空还是对满，入队时少用一个队列单元。
  • 对满的条件为:(Q.rear+1)%MaxSize == Q.front;
  • 对空的条件为：Q.front == Q.rear
  • 队列中元素个数：(Q.rear-Q.front+MaxSize)%MaxSize
• 类型中增设表示元素个数的数据成员。这样对空条件为Q.size == 0,对满条件为Q.size==MaxSize。
  • 此时队列的结构如下：

#define MaxSize 50 // 定义队列中的元素的最大个数
typedef struct
	ElemType data[MaxSize];
	int front,rear; // 对头指针和队尾指针
	int size;
SqQueue;

• 类型中增设tag数据成员，以区分对满还是对空。tag等于0时，若因删除导致Q.front==Q.rear,则为对空；tag等于1时，若因插入导致Q.front = Q.rear,则为对满。
  • 此时队列的结构如下：

#define MaxSize 50 // 定义队列中的元素的最大个数
typedef struct
	ElemType data[MaxSize];
	int front,rear; // 对头指针和队尾指针
	int tag;
SqQueue;

其实就是初始化时Q.tag=0，当执行入队操作时，Q.tag赋值为1，当执行出队操作时，Q.tag赋值为0.

2. 队列的链式存储

linkqueue.h

#ifndef LINKQUEUE_H_INCLUDED
#define LINKQUEUE_H_INCLUDED

typedef int ElemType;

typedef struct LinkNode
    ElemType data;
    struct LinkNode *next;
LinkNode;

typedef struct
    LinkNode *front2,*rear;
LinkQueue;


void InitQueue(LinkQueue &Q);
// 初始化队列
bool QueueEmpty(LinkQueue Q);
// 判断队列是否为空
bool EnQueue(LinkQueue &Q,ElemType e);
// 入队操作
bool DeQueue(LinkQueue &Q,ElemType &e);
// 出队操作
bool GetHead(LinkQueue Q,ElemType &e);
//获取队头元素
int QueueLength(LinkQueue Q);
//获取队列长度
#endif // LINKQUEUE_H_INCLUDED

linkqueue.cpp

#include <stdlib.h>
#include "linkqueue.h"

// 带头节点
void InitQueue(LinkQueue &Q)
    Q.rear = (LinkNode *)malloc(sizeof(LinkNode));
    if(!Q.rear)
        exit(-1);
    // 分配资源失败
    Q.front2=Q.rear;
    Q.front2->next = NULL;

// 初始化队列
bool QueueEmpty(LinkQueue Q)
    return Q.front2 == Q.rear;

// 判断队列是否为空
bool EnQueue(LinkQueue &Q,ElemType e)
    LinkNode *p = (LinkNode *)malloc(sizeof(LinkNode));
    if(!p)
        exit(-1);
    // 资源分配失败
    p->data = e;
    p->next = NULL;
    // 创建新节点，插入到链尾
    Q.rear->next = p;
    Q.rear = p;
    return false;

// 入队操作
bool DeQueue(LinkQueue &Q,ElemType &e)
    if(QueueEmpty(Q))
        return false;
    // 如果队列已经为空
    LinkNode *p = Q.front2->next;
    // p节点才是出队的节点
    e = p->data;
    Q.front2->next = p->next;
    if(Q.rear == p)
        Q.rear = Q.front2;
    // 原队列中只有一个节点，删除后变空
    free(p);
    return true;

// 出队操作
bool GetHead(LinkQueue Q,ElemType &e)
    if(QueueEmpty(Q))
        return false;
    e = Q.front2->next->data;
    return true;

//获取队头元素
int QueueLength(LinkQueue Q)
    LinkNode *p = Q.front2->next;
    int i = 0;
    while(p)
        ++i;
        p = p->next;
    
    return i;

//获取队列长度

main.cpp

#include <stdio.h>
#include "linkqueue.h"

int main()

    LinkQueue Q;
    InitQueue(Q);
    int a[] =1,2,3,4,5,6,7,8,9,10;
    int e;
    for(int i=0;i<10;i++)
        EnQueue(Q,a[i]);
    GetHead(Q,e);
    printf("The head node element of the queue is %d\\n",e);
    int q_len = QueueLength(Q);
    printf("The length of the queue is %d\\n",q_len);
    while(!QueueEmpty(Q))
        DeQueue(Q,e);
        printf("%d\\t",e);
    
    printf("\\n");
    return 0;

运行结果：