Zusammenfassung der LeetCode-Lösungen 1670. Entwerfen Sie vordere, mittlere und hintere Warteschlangen

Verzeichnislink:

Likou-Programmierfragen – Lösungszusammenfassung_Teilen + Aufzeichnen – CSDN-Blog

GitHub-Projekt zum synchronen Fragen-Bürsten:

https://github.com/September26/java-algorithms

Original-Titellink:Offizielle Website von LeetCode – die Technologie-Wachstumsplattform, die von Geeks auf der ganzen Welt geliebt wird

beschreiben:

Bitte entwerfen Sie eine Warteschlange, um push - und pop -Operationen an der ersten, mittleren und letzten Position zu unterstützen.

Vollständige FrontMiddleBack Kategorie:

FrontMiddleBack() Initialisieren Sie die Warteschlange.
void pushFront(int val) fügt val an den Anfang der Warteschlange hinzu .
void pushMiddle(int val) fügt val zur Mitte der Warteschlange hinzu .
void pushBack(int val) fügt val am Ende von in der Warteschlange hinzu.
int popFront() löscht das vorderste Element aus der Warteschlange und gibt den Wert zurück. Wenn die Warteschlange vor dem Löschen leer ist, geben Sie zurück < a i=3>. -1
int popMiddle() Löschen Sie das Element in der Mitte von aus der Warteschlange und geben Sie den Wert zurück. Wenn die Warteschlange vor dem Löschen leer ist, geben Sie -1
int popBack() löscht das letzte Element von aus der Warteschlange und gibt den Wert zurück. Wenn die Warteschlange vor dem Löschen leer ist, geben Sie < a i=3>. -1

Bitte beachten Sie, dass bei zwei mittleren Positionen die vordere Position für den Betrieb ausgewählt werden muss. Zum Beispiel:

fügt 6 zur mittleren Position von [1, 2, 3, 4, 5] hinzu und das resultierende Array ist . [1, 2, 6, 3, 4, 5]
entfernt das Element aus der mittleren Position von , gibt zurück und das Array wird zu . [1, 2, 3, 4, 5, 6]3[1, 2, 4, 5, 6]

Beispiel 1:

eingeben:
[„FrontMiddleBackQueue“, „pushFront“, „pushBack“, „pushMiddle“, „pushMiddle“, „popFront“, „popMiddle“, „popMiddle“, „popBack“, „popFront“ ]
[[], [1], [2], [3], [4], [], [], [], [], []]
Ausgabe:
[null, null, null, null, null, 1, 3, 4, 2, -1]

erklären:
FrontMiddleBackQueue q = new FrontMiddleBackQueue();
q.pushFront(1); // [1]
q.pushBack(2); // [1, 2]
q.pushMiddle(3); // [1, 3, 2]
q.pushMiddle(4); // [1, 4, 3, 2]
q.popFront(); // gibt 1 zurück -> [4, 3, 2]
q.popMiddle(); // return 3 -> [4, 2]
q.popMiddle(); // Return 4 -> [2]
q.popBack(); // Return 2 -> []
q.popFront(); // Return -1 -> [] (Warteschlange ist leer)

class FrontMiddleBackQueue {
    List<Integer> list;

        public FrontMiddleBackQueue() {
            list = new ArrayList<>();
        }

        public void pushFront(int val) {
            list.add(0, val);
        }

        public void pushMiddle(int val) {
            int size = list.size();
            int middle = size / 2;
            list.add(middle, val);
        }

        public void pushBack(int val) {
            list.add(val);
        }

        public int popFront() {
            if (list.size() == 0) {
                return -1;
            }
            return list.remove(0);
        }

        public int popMiddle() {
            if (list.size() == 0) {
                return -1;
            }
            int size = list.size();
            int middle = size % 2 == 0 ? size / 2 - 1 : size / 2;
            return list.remove(middle);
        }

        public int popBack() {
            if (list.size() == 0) {
                return -1;
            }
            return list.remove(list.size() - 1);
        }
}

/**
 * Your FrontMiddleBackQueue object will be instantiated and called as such:
 * FrontMiddleBackQueue obj = new FrontMiddleBackQueue();
 * obj.pushFront(val);
 * obj.pushMiddle(val);
 * obj.pushBack(val);
 * int param_4 = obj.popFront();
 * int param_5 = obj.popMiddle();
 * int param_6 = obj.popBack();
 */

Hinweis:

1 <= val <= 109
Am häufigsten verwendet 1000 Weiter pushFront, pushMiddle, pushBack, . und popFront, popMiddlepopBack

Ideen zur Problemlösung:

Die Verwendung von List zur Implementierung ist etwas weniger effizient, aber mir ist im Moment keine bessere Lösung eingefallen.