c语言遍历循环队列算法代码

循环队列是一种常见的数据结构，它可以用数组来实现。下面是C语言遍历循环队列的算法代码：

void traverseQueue(int front, int rear, int queue[]) {
    int i;
    if (front == rear) {
        printf("Queue is empty.\n");
    } else {
        printf("Elements in the queue are: ");
        for (i = front; i < rear; i++) {
            printf("%d ", queue[i]);
        }
        printf("\n");
    }
}

这段代码中，front和rear分别表示队列的头和尾，queue是存储队列元素的数组。如果队列为空，则输出提示信息；否则，遍历队列并输出队列中的元素。

相关问题

利用循环队列的遍历算法输出队列中所有偶数的c语言代码

在C语言中，我们可以使用循环队列（Circular Queue）的数据结构，并结合遍历算法来输出队列中所有的偶数。首先，我们需要包含必要的头文件并实现队列的创建、入队、出队等基本操作。以下是一个简单的示例：

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

typedef struct {
    int capacity;
    int front;   // 队首元素索引
    int rear;    // 队尾元素索引
    int* queue;
} Queue;

// 初始化循环队列
Queue* create_queue(int size) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->capacity = size;
    q->front = -1;
    q->rear = -1;
    q->queue = (int*)malloc(q->capacity * sizeof(int));
    return q;
}

// 入队
void enqueue(Queue* q, int value) {
    if ((q->rear + 1) % q->capacity == q->front) { // 队满处理
        printf("Queue is full.\n");
        return;
    }
    q->rear = (q->rear + 1) % q->capacity;
    q->queue[q->rear] = value;
}

// 出队
int dequeue(Queue* q) {
    if (q->front == -1) { // 队空处理
        printf("Queue is empty.\n");
        return -1;
    }
    int value = q->queue[q->front];
    q->front = (q->front + 1) % q->capacity;
    return value;
}

// 检查并打印偶数
void print_even_numbers(Queue* q) {
    if (q->front == -1) return; // 如果队列为空

    while (q->front != q->rear) {
        int value = dequeue(q);
        if (value % 2 == 0) {
            printf("%d ", value); // 打印偶数
        }
        enqueue(q, value); // 回填以便下次循环继续检查
    }
}

int main() {
    Queue* my_queue = create_queue(5);
    
    // 入队一些数字
    enqueue(my_queue, 1);
    enqueue(my_queue, 2);
    enqueue(my_queue, 3);
    enqueue(my_queue, 4);
    enqueue(my_queue, 5);
    
    printf("Even numbers in the circular queue are:\n");
    print_even_numbers(my_queue);

    // 清理资源
    free(my_queue->queue);
    free(my_queue);
    return 0;
}

这个程序会创建一个循环队列，然后将数字1到5依次入队。当遍历时，它只打印出队列中的偶数。注意，这里通过`enqueue`函数回填刚刚出队的元素，使得下一次遍历可以从上一个位置开始，直到整个队列遍历完。

邻接矩阵广度优先遍历c语言算法代码

以下是邻接矩阵广度优先遍历的C语言算法代码：

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

#define MAX 100 // 最大顶点数

int arc[MAX][MAX]; // 边表二维数组，对，行列的下标对应实际存在的顶点，值为1表示两顶点间有边
int visited[MAX]; // 访问标志数组，0表示未访问，1表示已访问

// 邻接矩阵广度优先遍历算法
void BFS(int v, int n) {
    int queue[MAX], front = 0, rear = 0; // 队列
    int i, j;
    printf("%d ", v); // 访问初始顶点v并标记为已访问
    visited[v] = 1;
    queue[rear++] = v; // 初始顶点v入队列
    while (front != rear) { // 队列不为空时循环
        i = queue[front++]; // 出队列
        for (j = 0; j < n; j++) {
            if (arc[i][j] == 1 && visited[j] == 0) { // 顶点i与顶点j有边且顶点j未被访问
                printf("%d ", j); // 访问顶点j并标记为已访问
                visited[j] = 1;
                queue[rear++] = j; // 顶点j入队列
            }
        }
    }
}

int main() {
    int n = 5; // 顶点数
    int m = 6; // 边数
    int i, j, v1, v2;
    // 初始化边表
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            arc[i][j] = 0;
        }
    }
    // 建立边表
    for (i = 0; i < m; i++) {
        scanf("%d%d", &v1, &v2);
        arc[v1][v2] = 1;
        arc[v2][v1] = 1;
    }
    // 初始化访问标志数组
    for (i = 0; i < n; i++) {
        visited[i] = 0;
    }
    // 从顶点0开始广度优先遍历
    BFS(0, n);
    return 0;
}