c++建立优先队列,将数字依次入队

可以使用堆来实现优先队列。以大根堆为例，堆中的每个元素都比其子节点大，堆顶元素即为优先级最高的元素。

1. 建立一个空的堆。
2. 将数字依次插入堆中。
3. 每次插入后，如果插入的元素比其父节点大，则交换它们的位置，直到满足堆的性质。
4. 重复步骤2和3，直到所有数字都插入堆中。

以下是Python代码示例：

import heapq

# 建立一个空的堆
heap = []

# 将数字依次插入堆中
nums = [5, 3, 8, 4, 2]
for num in nums:
    heapq.heappush(heap, -num)  # 在堆中插入相反数，实现大根堆

# 依次弹出堆顶元素，即为优先级最高的元素
while heap:
    print(-heapq.heappop(heap))

输出结果为：

8
5
4
3
2

相关问题

用c++写代码（1）栈的顺序实现：建立一个容量为5的栈，将a,b,c,d,e依次入栈，输出栈中所有元素；进行两次出栈操作并输出出栈元素；输出当前栈顶元素； （2）栈的链式实现：建立一个链栈，依次将a,b,c,d入栈；出栈并输出出栈结点数据域的值；将f入栈；输出当前链栈中各结点的数据域的值； （3）队列的顺序实现：建立一个容量为5的循环队列，将a,b,c,d,e依次入队；进行三次出队操作，并输出出队元素；将f,g,h入队；输出当前队列中所有元素； （4）队列的链式实现：建立一个链式队列，将a,b,c入队；进行两次出队操作并输出出队元素；将d,e入队，输出当前队列中所有元素。

好的，下面是你所需的代码实现：

（1）栈的顺序实现：

#include <iostream>
using namespace std;

const int MAX_SIZE = 5;

class Stack {
private:
    int data[MAX_SIZE];
    int top;
public:
    Stack() {
        top = -1;
    }

    bool isEmpty() {
        return top == -1;
    }

    bool isFull() {
        return top == MAX_SIZE - 1;
    }

    void push(int element) {
        if (isFull()) {
            cout << "Stack is full. Cannot push element." << endl;
            return;
        }
        data[++top] = element;
    }

    int pop() {
        if (isEmpty()) {
            cout << "Stack is empty. Cannot pop element." << endl;
            return -1;
        }
        return data[top--];
    }

    int peek() {
        if (isEmpty()) {
            cout << "Stack is empty. No top element." << endl;
            return -1;
        }
        return data[top];
    }

    void display() {
        cout << "Stack elements: ";
        for (int i = 0; i <= top; i++) {
            cout << data[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    Stack stack;

    stack.push('a');
    stack.push('b');
    stack.push('c');
    stack.push('d');
    stack.push('e');

    stack.display();

    cout << "Popped element: " << stack.pop() << endl;
    cout << "Popped element: " << stack.pop() << endl;

    cout << "Current top element: " << stack.peek() << endl;

    return 0;
}

（2）栈的链式实现：

#include <iostream>
using namespace std;

class Node {
public:
    char data;
    Node* next;

    Node(char element) {
        data = element;
        next = nullptr;
    }
};

class Stack {
private:
    Node* top;
public:
    Stack() {
        top = nullptr;
    }

    bool isEmpty() {
        return top == nullptr;
    }

    void push(char element) {
        Node* newNode = new Node(element);
        newNode->next = top;
        top = newNode;
    }

    char pop() {
        if (isEmpty()) {
            cout << "Stack is empty. Cannot pop element." << endl;
            return '\0';
        }
        char poppedElement = top->data;
        Node* temp = top;
        top = top->next;
        delete temp;
        return poppedElement;
    }

    void display() {
        cout << "Stack elements: ";
        Node* temp = top;
        while (temp != nullptr) {
            cout << temp->data << " ";
            temp = temp->next;
        }
        cout << endl;
    }
};

int main() {
    Stack stack;

    stack.push('a');
    stack.push('b');
    stack.push('c');
    stack.push('d');

    stack.display();

    cout << "Popped element: " << stack.pop() << endl;

    stack.push('f');

    stack.display();

    return 0;
}

（3）队列的顺序实现：

#include <iostream>
using namespace std;

const int MAX_SIZE = 5;

class Queue {
private:
    int data[MAX_SIZE];
    int front, rear;
public:
    Queue() {
        front = rear = -1;
    }

    bool isEmpty() {
        return front == -1;
    }

    bool isFull() {
        return (rear + 1) % MAX_SIZE == front;
    }

    void enqueue(char element) {
        if (isFull()) {
            cout << "Queue is full. Cannot enqueue element." << endl;
            return;
        }
        if (isEmpty()) {
            front = rear = 0;
        }
        else {
            rear = (rear + 1) % MAX_SIZE;
        }
        data[rear] = element;
    }

    char dequeue() {
        if (isEmpty()) {
            cout << "Queue is empty. Cannot dequeue element." << endl;
            return '\0';
        }
        char dequeuedElement = data[front];
        if (front == rear) {
            front = rear = -1;
        }
        else {
            front = (front + 1) % MAX_SIZE;
        }
        return dequeuedElement;
    }

    void display() {
        cout << "Queue elements: ";
        int i = front;
        while (i != rear) {
            cout << data[i] << " ";
            i = (i + 1) % MAX_SIZE;
        }
        cout << data[rear] << endl;
    }
};

int main() {
    Queue queue;

    queue.enqueue('a');
    queue.enqueue('b');
    queue.enqueue('c');
    queue.enqueue('d');
    queue.enqueue('e');

    queue.display();

    cout << "Dequeued element: " << queue.dequeue() << endl;
    cout << "Dequeued element: " << queue.dequeue() << endl;
    cout << "Dequeued element: " << queue.dequeue() << endl;

    queue.enqueue('f');
    queue.enqueue('g');
    queue.enqueue('h');

    queue.display();

    return 0;
}

（4）队列的链式实现：

#include <iostream>
using namespace std;

class Node {
public:
    char data;
    Node* next;

    Node(char element) {
        data = element;
        next = nullptr;
    }
};

class Queue {
private:
    Node* front;
    Node* rear;
public:
    Queue() {
        front = rear = nullptr;
    }

    bool isEmpty() {
        return front == nullptr;
    }

    void enqueue(char element) {
        Node* newNode = new Node(element);
        if (isEmpty()) {
            front = rear = newNode;
        }
        else {
            rear->next = newNode;
            rear = newNode;
        }
    }

    char dequeue() {
        if (isEmpty()) {
            cout << "Queue is empty. Cannot dequeue element." << endl;
            return '\0';
        }
        char dequeuedElement = front->data;
        Node* temp = front;
        front = front->next;
        delete temp;
        if (front == nullptr) {
            rear = nullptr;
        }
        return dequeuedElement;
    }

    void display() {
        cout << "Queue elements: ";
        Node* temp = front;
        while (temp != nullptr) {
            cout << temp->data << " ";
            temp = temp->next;
        }
        cout << endl;
    }
};

int main() {
    Queue queue;

    queue.enqueue('a');
    queue.enqueue('b');
    queue.enqueue('c');

    queue.display();

    cout << "Dequeued element: " << queue.dequeue() << endl;
    cout << "Dequeued element: " << queue.dequeue() << endl;

    queue.enqueue('d');
    queue.enqueue('e');

    queue.display();

    return 0;
}

希望对你有所帮助！如果有任何问题，请随时提问。

C++ 建立一个空队列，编写入队函数，随机产生10个100以内的整数，并按输入循环依次入队，编写出队函数，从键盘输入出队元素个数n（n<10），将n个元素出队后显示队中数据结果，考虑判断队空情况，编写取队头元素函数，若队不为空，则取队头元素显示；否则提示队空。

你好！听懂您的问题了。下面是解答：

首先，我们需要定义一个队列结构体，包括队头和队尾以及队列元素数组，具体代码如下：

typedef struct {
    int front;     // 队头指针
    int rear;      // 队尾指针
    int data[10];  // 队列元素数组
} Queue;

然后，我们定义以下三个函数：

1. 初始化队列函数init\_queue，将队头和队尾指针都置为-1。

2. 入队函数enqueue，将元素插入队尾，并更新rear指针。

3. 出队函数dequeue，从队头开始按次序将元素出队，并更新front指针。

另外，我们还需要编写一个函数isEmpty，用于判断队列是否为空。如果队头指针和队尾指针都为-1，则说明队列为空。

下面是完整代码实现：

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

typedef struct {
    int front;     // 队头指针
    int rear;      // 队尾指针
    int data[10];  // 队列元素数组
} Queue;

void init_queue(Queue *q) {
    q->front = q->rear = -1;
}

void enqueue(Queue *q, int value) {
    q->rear++;
    q->data[q->rear] = value;
}

int isEmpty(Queue *q) {
    if (q->front == -1 && q->rear == -1)
        return 1;
    return 0;
}

int dequeue(Queue *q, int n) {
    int i, val;
    if (isEmpty(q)) {
        printf("队列为空！\n");
        return -1;
    }
    if (n > q->rear - q->front + 1) {
        printf("出队元素个数超过队列元素个数！\n");
        return -1;
    }
    printf("出队的元素为：");
    for (i = 1; i <= n; i++) {
        q->front++;
        val = q->data[q->front];
        printf("%d ", val);
    }
    printf("\n");
    return 0;
}

int getFront(Queue *q) {
    if (isEmpty(q)) {
        printf("队列为空！\n");
        return -1;
    }
    printf("队头元素为：%d\n", q->data[q->front]);
    return 0;
}

int main() {
    Queue q;
    int i, n, val;
    srand(time(NULL));  // 初始化随机数种子

    // 初始化队列
    init_queue(&q);

    // 将10个100以内的整数随机入队
    for (i = 1; i <= 10; i++) {
        val = rand() % 100;
        enqueue(&q, val);
    }

    // 显示队列中的数据
    printf("队列中的数据为：");
    for (i = q.front + 1; i <= q.rear; i++) {
        printf("%d ", q.data[i]);
    }
    printf("\n");

    // 出队
    printf("请输入要出队的元素个数(n<10)：");
    scanf("%d", &n);
    dequeue(&q, n);

    // 取队头元素
    getFront(&q);

    return 0;
}

希望这个代码可以帮到您，如果还有什么问题，可以随时问我。