优先级队列判断队空队满

优先级队列是一种特殊的队列，其中的每个元素都有一个优先级。优先级较高的元素会在优先级较低的元素之前被处理。判断优先级队列是否为空或为满的方法取决于具体的实现方式。以下是一些常见的实现方式及其判断方法：

1. **基于数组的实现**：
- **队空**：通常情况下，当队列中没有元素时，队列为空。可以通过检查队列的当前大小是否为0来判断。

     public boolean isEmpty() {
         return size == 0;
     }

- **队满**：当数组的容量被完全使用时，队列为满。可以通过检查当前大小是否等于数组的容量来判断。

     public boolean isFull() {
         return size == capacity;
     }

2. **基于链表的实现**：
- **队空**：当队列的头指针和尾指针都指向空时，队列为空。

     public boolean isEmpty() {
         return head == null;
     }

- **队满**：在链表的实现中，通常不会定义队满的情况，因为链表的大小是动态的，除非有特定的限制。

3. **基于堆的实现**：
- **队空**：当堆中没有元素时，队列为空。可以通过检查堆的大小是否为0来判断。

     public boolean isEmpty() {
         return heap.size() == 0;
     }

- **队满**：在堆的实现中，通常不会定义队满的情况，因为堆的大小是动态的，除非有特定的限制。

以下是一个简单的优先级队列实现示例：

public class PriorityQueue {
    private int[] heap;
    private int size;
    private int capacity;

    public PriorityQueue(int capacity) {
        this.capacity = capacity;
        heap = new int[capacity];
        size = 0;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public boolean isFull() {
        return size == capacity;
    }

    public void insert(int element) {
        if (isFull()) {
            throw new RuntimeException("Queue is full");
        }
        heap[size] = element;
        heapifyUp(size);
        size++;
    }

    public int remove() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        int root = heap[0];
        heap[0] = heap[size - 1];
        size--;
        heapifyDown(0);
        return root;
    }

    private void heapifyUp(int index) {
        while (index > 0 && heap[parent(index)] < heap[index]) {
            swap(index, parent(index));
            index = parent(index);
        }
    }

    private void heapifyDown(int index) {
        while (leftChild(index) < size) {
            int max = leftChild(index);
            if (rightChild(index) < size && heap[rightChild(index)] > heap[max]) {
                max = rightChild(index);
            }
            if (heap[index] < heap[max]) {
                swap(index, max);
                index = max;
            } else {
                break;
            }
        }
    }

    private int parent(int index) {
        return (index - 1) / 2;
    }

    private int leftChild(int index) {
        return 2 * index + 1;
    }

    private int rightChild(int index) {
        return 2 * index + 2;
    }

    private void swap(int i, int j) {
        int temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }
}