/ / Wie erstelle ich einen Maze Solver in Java mit Stack, Queue und Coordinate? - Java, Generika, Stapel, Warteschlange, Labyrinth

Wie erstelle ich einen Maze Solver in Java mit Stack, Queue und Coordinate? - Java, Generika, Stapel, Warteschlange, Labyrinth

Ich möchte mit Java einen Maze Solver in Java erstellenfolgende generische Klassen: Queue, Stack und Coordinate (speichert die aktuelle [x, y] -Koordinate). Das Programm liest eine Textdatei, die ein Labyrinth enthält, transferiert es in eine Matrix und sucht von der Startposition aus nach leeren Räumen, bis es die endgültige Position findet.

Dies ist die Textdatei:

   5
8
########
E      #
### ####
### ####
###S####

Da die generischen Klassen Warteschlange, Stapel und Koordinate im Programm vorhanden sein müssen, müssen 4 Objekte erstellt werden:

-Ein Objekt der Klasse Stack <Coordinate> namens "path" und ein Objekt der Klasse
Stack <Warteschlange <Koordinate>> "Möglichkeiten" genannt, beide können 40 Koordinaten speichern (5 x 8 -
5 Zeilen und 8 Spalten);

-Ein Objekt der Klasse Queue namens "queue"das speichert 3 Koordinaten und reiht die leeren Räume oder das Zeichen "S" um die gegenwärtige Position ein, die gefunden werden, wenn sie alle 4 Richtungen suchen. (Bei der ersten Suche würde die Warteschlange beispielsweise lauten: [(1,1),,]) Als 1,1 ist der erste leere Speicherplatz, der von der Startposition gefunden wird, der dann zur Warteschlange hinzugefügt wird.)

-Ein Objekt der Coordinate-Klasse namens "current", das die aktuelle Position darstellt.

5 repräsentiert die Anzahl der Zeilen. 8 repräsentiert die Anzahl der Spalten. Das Zeichen "#" steht für eine Mauer, ein unpassierbares Gelände. Das Zeichen "E" ist die Startposition, das Zeichen "S" ist der Exit und die Leerstellen (char "") stehen für begehbare Leerzeichen. Also überträgt das Programm zuerst das Labyrinth auf die Textdatei zu einer Matrix mit der angegebenen Anzahl von Zeilen und Spalten (5 und 8), und findet dann das Zeichen "E", welches die Startposition ist und das "aktuelle" instanziiert Objekt, seine Koordinate darauf speichern ((1,0) in dem Fall).

Von dort aus sucht es alle 4 Richtungen herumdie aktuelle Position im Uhrzeigersinn (oben, rechts, unten und links, in dieser Reihenfolge) und speichert die Koordinaten der leeren Räume (oder char "S") auf der "Warteschlange" -Objekt und entfernt die erste Koordinate aus der "Warteschlange ", Speichern dieser Koordinate auf dem" aktuellen "Objekt, das die aktuelle Position darstellt. Dann wird in der Matrix ein Zeichen "*" an die Position gesetzt, die durch das "aktuelle" Objekt (Koordinate) repräsentiert wird, was anzeigt, dass ein Schritt ausgeführt wurde. Stapelt dann das Objekt "current" auf das "path" -Objekt und stapelt das "queue" -Objekt auf das Objekt "possibilites". Dann werden diese Schritte wiederholt, bis der Ausgang (Zeichen "S") gefunden wird, die Matrix gedruckt und das Programm geschlossen wird.

Am Ende, wie jede Position mit einem "*" markiert ist, müsste die Matrix so aussehen: (Die Textdatei ist unverändert).

   5
8
########
E***   #
###*####
###*####
###S####

Bisher habe ich die Klassen erstellt:

Warteschlange:

public class Fila <T> {
private Object[objfila] = null;
private int quantidade,posinicial,posfinal;
public void inserir(Object x) throws Exception
{
if(quantidade==objfila.length)
throw new Exception("Queue is full");
x=objfila(posfinal);
quantidade++;
posfinal++;
}
public void remover() throws Exception
{
if(quantidade==0){
throw new Exception("there are no elements on the queue");
}
quantidade--;
posinicial++;
}
public Fila(int capacidade)
{
this.posinicial=0;
this.posfinal=0;
Object objfila=new Object();
}
}

Stapel:

public class Pilha <T> {
private Object[] objpilha = null;
private int topo;
public void inserir(T x) throws Exception
{
if(topo==objpilha.length-1){
throw new Exception("the stack is full.");
}
topo++;
objpilha[topo]=x;
}
public void remover() throws Exception
{
if(topo==-1){
throw new Exception("there are no elements to be removed.");
}
topo--;
}
public Pilha(int capacidade){
objpilha=new Object[capacidade];
topo=-1;
}
}

Und Koordinaten: (Ich denke, es sollte ein Array von x und y geben, das Koordinaten speichert)

public class Coordenadas <T>{
private int x;
private int y;
}

Worüber ich Probleme habe, ist die Erstellung vondiese Objekte und fügen sie in andere Objekte ein, wie beim Speichern gefundener Koordinaten in der "Warteschlange" und beim Stapeln des "aktuellen" Objekts auf dem "Pfad" -Objekt. Was ist der richtige Weg, um dieses Programm zu machen?

Entschuldigung für die lange Frage.

Antworten:

0 für die Antwort № 1

Das Wichtigste zuerst: Es gibt ein Stack Klasse in Java API. Das Deque Schnittstelle enthält ein wenig mehr als der Stapel. Sie können jede Implementierung starten, wie ArrayDeque:

Deque<Point> stack = new ArrayDeque<>();
stack.push(new Point(2,3));
stack.push(new Point(2,4));
Point p = stack.pop(); // (2, 4)

Ebenso gibt es a Queue Schnittstelle zu zahlreichen Implementierungen. ArrayDeque Ist einer von ihnen:

Queue<Point> queue = new ArrayDeque<>();
queue.add(new Point(1, 2));
queue.add(new Point(1, 3));
Point p = queue.remove(); // (1, 2)

Ich benutzte die Point Klasse, die mit diesen Tokens verwendet werden soll.

Fazit: Sie können Ihren Labyrinth-Löser oben auf dieser Klasse aufbauen. So können Sie sich auf das Labyrinth-Lösen konzentrieren. Die Java-Bibliothek wird sich um die algorithmischen Details kümmern.