声明一个整型队列对象，插入五个整数，压入队列

下面是一个使用 Python 语言声明一个整型队列对象，插入五个整数并压入队列的示例代码：

from queue import Queue

# 创建一个整型队列对象
int_queue = Queue()

# 插入五个整数到队列中
int_queue.put(1)
int_queue.put(2)
int_queue.put(3)
int_queue.put(4)
int_queue.put(5)

# 打印队列中的元素
while not int_queue.empty():
    print(int_queue.get())

输出结果为：

1
2
3
4
5

在这个示例代码中，我们使用了 Python 内置的 `queue` 模块，使用 `Queue()` 函数创建了一个整型队列对象 `int_queue`。然后，我们使用 `put()` 函数向队列中插入了五个整数。最后，我们使用 `get()` 函数从队列中取出元素，并打印出来。

相关问题

用链表 LinkedList 实现队列类。在 main 函数中会声明一个整型队列对象，插入 5 个整数，压入队列，再依次取出并显示出来。

好的，下面是用 LinkedList 实现队列类的示例代码：

import java.util.LinkedList;

public class Queue {
    private LinkedList<Integer> list = new LinkedList<Integer>();

    // 入队
    public void enqueue(int item) {
        list.addLast(item);
    }

    // 出队
    public int dequeue() {
        return list.removeFirst();
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return list.isEmpty();
    }

    // 获取队列长度
    public int size() {
        return list.size();
    }

    public static void main(String[] args) {
        Queue queue = new Queue();
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        queue.enqueue(4);
        queue.enqueue(5);

        while (!queue.isEmpty()) {
            System.out.println(queue.dequeue());
        }
    }
}

在 main 函数中，我们声明了一个整型队列对象 `queue`，并依次插入了 5 个整数。然后，我们使用 `while` 循环依次取出队列中的元素，并将其显示出来。

编写程序queue.h，用链表实现队列（或栈）类。在测试程序lab9_3.cpp 中声明一个整型队列（或栈）对象，插入5个整数，压入队列（或栈），再依次取出并显示出来。

好的，我可以帮你编写 queue.h，这里提供一份链式队列的实现代码，你可以参考一下：

#ifndef QUEUE_H_
#define QUEUE_H_

#include <iostream>

template<typename T>
class Queue
{
private:
    struct Node
    {
        T item;
        Node* next;
        Node(const T& i, Node* n = nullptr) : item(i), next(n) {}
    };
    Node* front;
    Node* rear;
    int size;
public:
    Queue() : front(nullptr), rear(nullptr), size(0) {}
    ~Queue()
    {
        Node* temp;
        while (front != nullptr)
        {
            temp = front;
            front = front->next;
            delete temp;
        }
    }
    bool is_empty() const { return size == 0; }
    int get_size() const { return size; }
    void clear() { *this = Queue(); }
    void enqueue(const T& item)
    {
        Node* temp = new Node(item);
        if (front == nullptr)
        {
            front = temp;
            rear = temp;
        }
        else
        {
            rear->next = temp;
            rear = temp;
        }
        ++size;
    }
    T dequeue()
    {
        if (is_empty())
        {
            std::cerr << "Queue is empty." << std::endl;
            exit(EXIT_FAILURE);
        }
        T item = front->item;
        Node* temp = front;
        front = front->next;
        delete temp;
        --size;
        return item;
    }
    T peek() const
    {
        if (is_empty())
        {
            std::cerr << "Queue is empty." << std::endl;
            exit(EXIT_FAILURE);
        }
        return front->item;
    }
};

#endif

然后你可以在测试程序lab9_3.cpp中创建一个整型队列对象，并进行入队、出队操作，代码如下：

#include <iostream>
#include "queue.h"

int main()
{
    Queue<int> q;
    q.enqueue(1);
    q.enqueue(2);
    q.enqueue(3);
    q.enqueue(4);
    q.enqueue(5);

    while (!q.is_empty())
    {
        std::cout << q.dequeue() << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果为：

1 2 3 4 5