算法设计题（队列）

于 2024-10-31 19:14:00 发布
阅读量292 收藏
点赞数 2
文章标签： c语言 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_74859128/article/details/143414435
版权

1.设一个循环顺序队列Queue,只有头指针fromt,不设尾指针，另设一个含有元素个 数的计数器count,试写出相应的进队算法和出队算法。

代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#define MAX_SIZE 100  // 定义队列的最大容量
typedef struct {
    int data[MAX_SIZE];  // 存储队列元素的数组
    int front;           // 队列的头指针
    int count;           // 队列中的元素个数
} Queue;
//初始化队列
void initQueue(Queue* q) {
    q->front = 0;
    q->count = 0;
}
//进入队列
int enQueue(Queue* q, int value) {
    if (q->count == MAX_SIZE) {
        printf("队列已满，无法进队\n");
        return -1;
    }
    int rear = (q->front + q->count) % MAX_SIZE;
    q->data[rear] = value;
    q->count++;
    return 0;
}

//出队列
int outQueue(Queue *q, int *value) {
if (q->count == 0) {
    // 队列为空
    printf("队列为空，无法出队\n");
    return -1;
}
     *value = q->data[q->front];
     q->front = (q->front + 1) % MAX_SIZE;
     q->count--;
     return 0;
}

//队列是否为空
int isQueueEmpty(Queue* q) {
    return q->count == 0;
}
//函数打印

void printQueue(Queue* q) {
    if (isQueueEmpty(q)) {
        printf("队列为空\n");
        return;
    }
    printf("队列中的元素：");
    int i;
    for (i = 0; i < q->count; i++) {
        int index = (q->front + i) % MAX_SIZE;
        printf("%d ", q->data[index]);
    }
    printf("\n");
}

int main() {
    Queue q;
    initQueue(&q);

    enQueue(&q, 10);
    enQueue(&q, 20);
    enQueue(&q, 30);

    printQueue(&q);  // 打印队列中的元素
    int value;
    outQueue(&q, &value);
    printf("出队元素：%d\n", value);
    enQueue(&q, 40);
    printQueue(&q);  // 打印队列中的元素

    while (!isQueueEmpty(&q)) {
        outQueue(&q, &value);
        printf("出队元素：%d\n", value);
    }
	return 0;
}

2.用一个数组data [0....N-1]表示队列时，该队列设头指针front,不设尾指针，但是 设置了一个计数器count用以记录队列中的结点个数。试编写初始化队列、判队空、读队 头元素、进队和出队操作的算法。

代码：

#include <stdio.h>

#define N 100  // 定义队列的最大容量

// 定义队列结构体
typedef struct {
    int data[N];  // 存储队列元素的数组
    int front;    // 队列的头指针，指向队头元素的位置
    int count;    // 队列中的元素个数
} Queue;

// 初始化队列
// 功能：将队列的头指针和计数器初始化
// 参数：队列指针 q
void initQueue(Queue *q) {
    q->front = 0;  // 初始时，头指针指向数组的第一个位置
    q->count = 0;  // 初始时，队列中没有元素
}

// 判断队列是否为空
// 功能：检查队列是否为空
// 参数：队列指针 q
// 返回值：如果队列为空，返回 1（true）；否则返回 0（false）
int isQueueEmpty(Queue *q) {
    return q->count == 0;  // 通过计数器 count 判断队列是否为空
}

// 读取队头元素
// 功能：获取队列的第一个元素（队头元素）
// 参数：队列指针 q，用于存储读取的队头元素的指针 value
// 返回值：如果队列为空，返回 -1 表示失败；否则返回 0 表示成功
int getFrontElement(Queue *q, int *value) {
    if (isQueueEmpty(q)) {  // 如果队列为空
        printf("队列为空，无法读取队头元素\n");
        return -1;  // 返回 -1 表示失败
    }
    *value = q->data[q->front];  // 获取队头元素
    return 0;  // 返回 0 表示成功
}

// 进队操作
// 功能：将元素 value 插入队列
// 参数：队列指针 q，要插入的元素 value
// 返回值：如果队列已满，返回 -1 表示失败；否则返回 0 表示成功
int enQueue(Queue *q, int value) {
    if (q->count == N) {  // 如果队列已满
        printf("队列已满，无法进队\n");
        return -1;  // 返回 -1 表示失败
    }
    int rear = (q->front + q->count) % N;  // 计算尾指针的位置（循环队列）
    q->data[rear] = value;  // 在尾指针位置插入元素
    q->count++;  // 更新队列元素个数
    return 0;  // 返回 0 表示成功
}

// 出队操作
// 功能：从队列中删除并返回队头元素
// 参数：队列指针 q，用于存储出队元素的指针 value
// 返回值：如果队列为空，返回 -1 表示失败；否则返回 0 表示成功
int deQueue(Queue *q, int *value) {
    if (isQueueEmpty(q)) {  // 如果队列为空
        printf("队列为空，无法出队\n");
        return -1;  // 返回 -1 表示失败
    }
    *value = q->data[q->front];  // 获取队头元素
    q->front = (q->front + 1) % N;  // 更新头指针，指向下一个队头元素（循环队列）
    q->count--;  // 更新队列元素个数
    return 0;  // 返回 0 表示成功
}

// 主函数，用于测试队列操作
int main() {
    Queue q;  // 定义一个队列
    initQueue(&q);  // 初始化队列

    // 进队操作
    enQueue(&q, 10);
    enQueue(&q, 20);
    enQueue(&q, 30);

    int frontElement;

    // 读取队头元素并打印
    if (getFrontElement(&q, &frontElement) == 0) {
        printf("队头元素: %d\n", frontElement);
    }

    // 出队操作并打印出队元素
    int dequeuedElement;
    while (!isQueueEmpty(&q)) {
        deQueue(&q, &dequeuedElement);
        printf("出队元素: %d\n", dequeuedElement);
    }

    // 尝试在空队列中读取队头元素
    if (getFrontElement(&q, &frontElement) == 0) {
        printf("队头元素: %d\n", frontElement);
    }

    // 尝试在空队列中出队
    if (deQueue(&q, &dequeuedElement) == 0) {
        printf("出队元素: %d\n", dequeuedElement);
    }

    // 再次进队操作
    enQueue(&q, 40);
    enQueue(&q, 50);

    // 读取队头元素并打印
    if (getFrontElement(&q, &frontElement) == 0) {
        printf("队头元素: %d\n", frontElement);
    }

    // 出队操作并打印出队元素
    while (!isQueueEmpty(&q)) {
        deQueue(&q, &dequeuedElement);
        printf("出队元素: %d\n", dequeuedElement);
    }

    return 0;
}

3.一个用单向循环链表构成的循环队列，只设一个尾指针rear,，不设头指针，请编写 如下算法 （1)向循环队列中插入一个元素为×的结点。 （2)从循环队列中删除一个结点。

代码：

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构
typedef struct Node {
    int data;  // 节点数据
    struct Node *next;  // 指向下一个节点的指针
} Node;

// 定义队列结构
typedef struct {
    Node *rear;  // 队列的尾指针
} CircularQueue;

// 初始化队列
void initQueue(CircularQueue *q) {
    q->rear = NULL;  // 初始时，队列为空，尾指针设为 NULL
}

// 判断队列是否为空
int isQueueEmpty(CircularQueue *q) {
    return q->rear == NULL;
}

// 创建新节点
Node* createNode(int x) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    if (!newNode) {
        printf("内存分配失败\n");
        exit(EXIT_FAILURE);
    }
    newNode->data = x;
    newNode->next = NULL;
    return newNode;
}

// 向循环队列中插入一个元素为 x 的节点
void enQueue(CircularQueue *q, int x) {
    Node *newNode = createNode(x);
    if (isQueueEmpty(q)) {
        // 如果队列为空，新节点既是头节点也是尾节点，形成自循环
        newNode->next = newNode;
    } else {
        // 否则，新节点的 next 指向原尾节点的下一个节点（头节点）
        newNode->next = q->rear->next;
        // 尾节点的 next 指向新节点
        q->rear->next = newNode;
    }
    // 更新尾指针，指向新节点
    q->rear = newNode;
    printf("插入元素: %d\n", x);
}

// 从循环队列中删除一个节点
int deQueue(CircularQueue *q) {
    if (isQueueEmpty(q)) {
        printf("队列为空，无法删除元素\n");
        return -1;  // 返回 -1 表示删除失败
    }
    Node *front = q->rear->next;  // 获取头节点
    int value = front->data;  // 获取头节点的数据

    if (front == q->rear) {
        // 如果头节点和尾节点是同一个节点，说明队列中只有一个节点
        free(front);
        q->rear = NULL;  // 队列变为空
    } else {
        // 否则，尾节点的 next 指向头节点的下一个节点
        q->rear->next = front->next;
        free(front);  // 释放头节点
    }

    printf("删除元素: %d\n", value);
    return value;  // 返回删除的元素值
}

// 主函数，用于测试
int main() {
    CircularQueue q;
    initQueue(&q);

    // 插入元素
    enQueue(&q, 10);
    enQueue(&q, 20);
    enQueue(&q, 30);

    // 删除元素
    deQueue(&q);
    deQueue(&q);

    // 插入更多元素
    enQueue(&q, 40);
    enQueue(&q, 50);

    // 继续删除元素
    deQueue(&q);
    deQueue(&q);
    deQueue(&q);

    // 尝试删除空队列中的元素
    deQueue(&q);

    return 0;
}

@干吧jyb
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值