So implementieren Sie Vorgänge zum Einfügen und Löschen von Warteschlangen in Java

So implementieren Sie Vorgänge zum Einfügen und Löschen von Warteschlangen in Java

Warteschlange ist eine häufig verwendete Datenstruktur, die dem First-In-First-Out-Prinzip (FIFO) folgt. In Java können Warteschlangen mithilfe von Arrays oder verknüpften Listen implementiert werden. Im Folgenden werden die beiden Implementierungsmethoden vorgestellt und Codebeispiele gegeben.

1. Verwenden Sie ein Array, um eine Warteschlange zu implementieren:

Die Idee, eine Warteschlange mit einem Array zu implementieren, besteht darin, ein Array als zugrunde liegende Datenstruktur der Warteschlange zu verwenden und Einfüge- und Löschvorgänge durch Beibehaltung von Kopf und Ende zu implementieren Hinweise.

Codebeispiel:

public class ArrayQueue {
    private int[] queueArray;    // 队列数组
    private int front;  // 队头指针
    private int rear;   // 队尾指针
    private int maxSize;    // 队列的最大容量

    public ArrayQueue(int size) {
        queueArray = new int[size];
        maxSize = size;
        front = 0;
        rear = -1;
    }

    // 入队操作
    public void enqueue(int data) {
        if (isFull()) {
            throw new IllegalStateException("队列已满，无法入队");
        }
        rear++;
        queueArray[rear] = data;
    }

    // 出队操作
    public int dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("队列为空，无法出队");
        }
        int data = queueArray[front];
        front++;
        return data;
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return (rear + 1 == front);
    }

    // 判断队列是否已满
    public boolean isFull() {
        return (rear == maxSize - 1);
    }
}

2. Verwenden einer verknüpften Liste zum Implementieren einer Warteschlange:

Die Idee einer verknüpften Liste, die eine Warteschlange implementiert, besteht darin, Einfüge- und Löschvorgänge zu implementieren, indem ein Zeiger auf den Kopf der Warteschlange und verwaltet wird ein Zeiger auf das Ende der Warteschlange. Jedes Mal, wenn ein neues Element eingefügt wird, wird es am Ende der Warteschlange hinzugefügt, und der Zeiger am Ende der Warteschlange zeigt auf das neue Element. Jedes Mal, wenn ein Element gelöscht wird, zeigt der Zeiger am Anfang der Warteschlange das nächste Element.

Codebeispiel:

public class LinkedQueue {
    private Node front;    // 队头指针
    private Node rear;     // 队尾指针

    public LinkedQueue() {
        front = null;
        rear = null;
    }

    // 节点类
    private class Node {
        private int data;   // 数据
        private Node next;  // 指向下一个节点的指针

        public Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    // 入队操作
    public void enqueue(int data) {
        Node newNode = new Node(data);
        if (isEmpty()) {
            front = newNode;
            rear = newNode;
        } else {
            rear.next = newNode;
            rear = newNode;
        }
    }

    // 出队操作
    public int dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("队列为空，无法出队");
        }
        int data = front.data;
        front = front.next;
        if (front == null) {
            rear = null;
        }
        return data;
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return (front == null);
    }
}

Das Obige sind zwei Möglichkeiten, Warteschlangeneinfüge- und -löschvorgänge in Java zu implementieren. Die Verwendung einer Array-Implementierung kann die Effizienz des Direktzugriffs bis zu einem gewissen Grad verbessern, während die Verwendung einer verknüpften Listenimplementierung flexibler ist und die Größe der Warteschlange dynamisch anpassen kann. Wählen Sie einfach die geeignete Implementierungsmethode entsprechend den tatsächlichen Anforderungen aus.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie Vorgänge zum Einfügen und Löschen von Warteschlangen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!