MySQL eine richtige Datenbank für einen routenplaner erstellen

[Prince Nour]

ich habe mit jave einen Routenplaner programmiert und jetzt fehlt mir, den Schema wie kann ich eine guten Datenbank erstellen in MySQl,damit läuft meine Programme ganz sauber und Einwand frei.
hier ist mein code ,damit sie einen blick haben.

package model;


public class Kante {
	
	private double laenge;
	private double geschwindigkeit;
	private Knoten ursprung;
	private Knoten ziel;
	private String name;
	private int id;
	
	public Kante(int id) {
		this.id = id;
	}
	
	public Kante(int id, Knoten ursprung, Knoten ziel, double laenge, double geschwindigkeit) {
		this.ursprung = ursprung;
		this.ursprung.addVerbindung(this);
		this.ziel = ziel;
		this.laenge = laenge;
		this.geschwindigkeit = geschwindigkeit;
	}
	
	public Kante(int id, String name, Knoten ursprung, Knoten ziel, double laenge, double geschwindigkeit) {
		this(id, ursprung, ziel, laenge, geschwindigkeit);
		this.name = name;
	}
	
	@Override
	public String toString() {
		return getName();
	}

	public double getLaenge() {
		return laenge;
	}

	public void setLaenge(double laenge) {
		this.laenge = laenge;
	}

	public double getGeschwindigkeit() {
		return geschwindigkeit;
	}

	public void setGeschwindigkeit(double geschwindigkeit) {
		this.geschwindigkeit = geschwindigkeit;
	}

	public Knoten getUrsprung() {
		return ursprung;
	}

	public void setUrsprung(Knoten ursprung) {
		this.ursprung = ursprung;
	}

	public Knoten getZiel() {
		return ziel;
	}

	public void setZiel(Knoten ziel) {
		this.ziel = ziel;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	
}

package model;


public class Knoten  {

	private double x;
	private double y;
	private double abstand;
	private Kante[] verbindungen;
	private Kante vorgaenger;
	private String name;
	private int id;
	
	public Knoten(int id) {
		this.id = id;
		verbindungen = new Kante[0];
	}
	
	public Knoten(int id, String name) {
		this(id);
		this.name = name;
	}
	
	public Knoten(int id, String name, double x, double y) {
		this(id, name);
		this.x = x;
		this.y = y;
	}
	
	@Override
	public String toString() {
		return getName();
	}

	public double getX() {
		return x;
	}

	public void setX(double x) {
		this.x = x;
	}

	public double getY() {
		return y;
	}

	public void setY(double y) {
		this.y = y;
	}

	public Kante[] getVerbindungen() {
		return verbindungen;
	}

	public void setVerbindungen(Kante[] verbindungen) {
		this.verbindungen = verbindungen;
	}
	
	public void addVerbindung(Kante verbindung) {
		Kante[] neuVerbindungen = new Kante[verbindungen.length + 1];
		System.arraycopy(verbindungen, 0, neuVerbindungen, 0, verbindungen.length);
		neuVerbindungen[verbindungen.length] = verbindung;
		verbindungen = neuVerbindungen;
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public double getDistanzLuftlinie(Knoten knoten) {
		return Math.sqrt((this.getX() - knoten.getX())*(this.getX() - knoten.getX())
				+ (this.getY() - knoten.getY())*(this.getY() - knoten.getY()));
	}

	public double getAbstand() {
		return abstand;
	}

	public void setAbstand(double abstand) {[code=Java]

this.abstand = abstand;
}

public Kante getVorgaenger() {
return vorgaenger;
}

public void setVorgaenger(Kante vorgaenger) {
this.vorgaenger = vorgaenger;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

}
[/code]

package application;

import model.Kante;
import model.Knoten;

public class Graph {
	
	private Kante[] kanten;
	private Knoten[] knoten;
	
	public Graph() {
		
	}
	
/*	public void setGraphByMatrix(double[][] abstandsmatrix) {
		knoten = new Knoten[abstandsmatrix.length];
		for (int i = 0; i < knoten.length; i++) {
			knoten[i] = new Knoten();
			Kante[] kanten = new Kante[knoten.length];
			int k = 0;
			for (int j = 0; j < knoten.length; j++) {
				if (abstandsmatrix[i][k] != 0) {
					kanten[k] = new Kante(knoten[i], knoten[j], abstandsmatrix[i][j]);
					k++;
				}
			}
			Kante[] verbindungen = new Kante[k];
			System.arraycopy(kanten, 0, verbindungen, 0, k);
			knoten[i].setVerbindungen(verbindungen);
		}
	}
	
	public void setGraphByMatrix(double[][] abstandsmatrix, 
			double[][] geschwindigkeitsmatrix) {
		knoten = new Knoten[abstandsmatrix.length];
		for (int i = 0; i < knoten.length; i++) {
			knoten[i] = new Knoten();
			Kante[] kanten = new Kante[knoten.length];
			int k = 0;
			for (int j = 0; j < knoten.length; j++) {
				if (abstandsmatrix[i][k] != 0) {
					kanten[k] = new Kante(knoten[i], knoten[j], 
							abstandsmatrix[i][j], geschwindigkeitsmatrix[i][j]);
					k++;
				}
			}
			Kante[] verbindungen = new Kante[k];
			System.arraycopy(kanten, 0, verbindungen, 0, k);
			knoten[i].setVerbindungen(verbindungen);
		}
	}
	
	public void setGraphByMatrix(double[][] abstandsmatrix, Knoten[] knoten) {
		this.knoten = knoten;
		for (int i = 0; i < knoten.length; i++) {
			Kante[] kanten = new Kante[knoten.length];
			int k = 0;
			for (int j = 0; j < knoten.length; j++) {
				if (abstandsmatrix[i][k] != 0) {
					kanten[k] = new Kante(knoten[i], knoten[j], abstandsmatrix[i][j]);
					k++;
				}
			}
			Kante[] verbindungen = new Kante[k];
			System.arraycopy(kanten, 0, verbindungen, 0, k);
			knoten[i].setVerbindungen(verbindungen);
		}
	}
	
	public void setGraphByMatrix(double[][] abstandsmatrix, 
			double[][] geschwindigkeitsmatrix, Knoten[] knoten) {
		this.knoten = knoten;
		for (int i = 0; i < knoten.length; i++) {
			Kante[] kanten = new Kante[knoten.length];
			int k = 0;
			for (int j = 0; j < knoten.length; j++) {
				if (abstandsmatrix[i][k] != 0) {
					kanten[k] = new Kante(knoten[i], knoten[j], 
							abstandsmatrix[i][j], geschwindigkeitsmatrix[i][j]);
					k++;
				}
			}
			Kante[] verbindungen = new Kante[k];
			System.arraycopy(kanten, 0, verbindungen, 0, k);
			knoten[i].setVerbindungen(verbindungen);
		}
	}
*/		
	
	public int getKnotenIndex(Knoten knoten) {
		for (int i = 0; i < this.knoten.length; i++) {
			if (this.knoten[i].equals(knoten)) return i;
		}
		return -1;
	}
	
	public Kante getKante(int index) {
		return kanten[index];
	}

	public Kante[] getKanten() {
		return kanten;
	}

	public void setKanten(Kante[] kanten) {
		this.kanten = kanten;
	}

	public Knoten[] getKnoten() {
		return knoten;
	}

	public void setKnoten(Knoten[] knoten) {
		this.knoten = knoten;
	}

}

package application;

import model.Kante;
import model.Knoten;

public class DijkstraAlgorithmus {

	private Graph graph;
	private Knoten[] unbesuchteKnoten;
	private static final double DURSCHNITTSGESCHWINDIGKEIT = 50;	//Diese Konstante wird für die Berechnung der Dauer verwendet, falls
																	//Eine Strecke keine Geschwindigkeit angegeben hat 
	
	public DijkstraAlgorithmus(Graph graph) {
		this.graph = graph;
	}
	
	public String getKuerzesterWegAsString(Knoten start, Knoten ziel) {
		return getWeg(start, ziel, 0);
	}
	
	public String getSchnellsterWegAsString(Knoten start, Knoten ziel) {
		return getWeg(start, ziel, 1);
	}
	
	private String getWeg(Knoten start, Knoten ziel, int gewicht) {
		initialisiereGraph();
		start.setAbstand(0);
		while (unbesuchteKnoten.length > 0) {
			int index = getNaehsterKnotenIndex();
			Knoten knoten = unbesuchteKnoten[index];
			if (knoten == ziel) {
				if (gewicht == 0) return String.format("Kuerzester Weg von %s nach %s:%n%s",start,ziel,getWegBeschreibung(knoten));
				else return String.format("Schnellster Weg von %s nach %s:%n%s",start,ziel,getWegBeschreibung(knoten));
			}
			entferneKnoten(index);			//Entferne den naehsten Knoten aus den unbesuchten Knoten
			for (int i = 0; i < knoten.getVerbindungen().length; i++) {
				Kante verbindung = knoten.getVerbindungen()[i];
				if (isKnotenUnbesucht(verbindung.getZiel())) {
					aktualisiereAbstand(knoten, verbindung.getZiel(), verbindung, gewicht); //Nur die Laenge wird gewichtet
				}
			}
		}
		return "Das Ziel kann nicht erreicht werden";
	}
	
	
	private void initialisiereGraph() {
		for (int i = 0; i < graph.getKnoten().length; i++) {
			graph.getKnoten()[i].setAbstand(-1);	//Dieser Wert sollte nie erreicht werden und wird daher als "unendlich" betrachtet
			graph.getKnoten()[i].setVorgaenger(null);
		}
		unbesuchteKnoten = graph.getKnoten();
	}
	
	
	private boolean isKnotenUnbesucht(Knoten knoten) {
		for (int i = 0; i < unbesuchteKnoten.length; i++) {
			if (unbesuchteKnoten[i] == knoten) return true;
		}
		return false;
	}

	
	private int getNaehsterKnotenIndex() {
		int index = 0;
		double kleinsterAbstand = unbesuchteKnoten[0].getAbstand();
		for (int i = 1; i < unbesuchteKnoten.length; i++) {
			if ((unbesuchteKnoten[i].getAbstand() < kleinsterAbstand && unbesuchteKnoten[i].getAbstand() >= 0) || kleinsterAbstand < 0) {
				kleinsterAbstand = unbesuchteKnoten[i].getAbstand();
				index = i;
			}
		}
		return index;
	}
	
	private void entferneKnoten(int index) {
		Knoten[] neueKnoten = new Knoten[unbesuchteKnoten.length - 1];
		if (index > 0) System.arraycopy(unbesuchteKnoten, 0, neueKnoten, 0, index);
		if (index + 1 < unbesuchteKnoten.length) System.arraycopy(unbesuchteKnoten, index + 1, neueKnoten, index, unbesuchteKnoten.length - index - 1);
		unbesuchteKnoten = neueKnoten;
	}
	
	private void aktualisiereAbstand(Knoten ursprung, Knoten ziel, Kante verbindung, int gewicht) {
		double abstand;
		double geschwindigkeit = verbindung.getGeschwindigkeit() * gewicht;
		if (geschwindigkeit <= 0) abstand = ursprung.getAbstand() + verbindung.getLaenge() / DURSCHNITTSGESCHWINDIGKEIT;
		else abstand = ursprung.getAbstand() + verbindung.getLaenge() / geschwindigkeit;
		if (abstand < ziel.getAbstand() || ziel.getAbstand() < 0) {
			ziel.setAbstand(abstand);
			ziel.setVorgaenger(verbindung);
		}
	}
	
	private String getWegBeschreibung(Knoten knoten) {
		String weg = "";
		double strecke = 0;
		double dauer = 0;
		Kante vorgaenger = knoten.getVorgaenger();
		while (vorgaenger != null) {
			weg = String.format("folgen Sie %s über %s km von %s nach %s,%n%s", 
					vorgaenger, vorgaenger.getLaenge(), vorgaenger.getUrsprung(), vorgaenger.getZiel(), weg);
			strecke = strecke + vorgaenger.getLaenge();
			if (vorgaenger.getGeschwindigkeit() <= 0) dauer = dauer + vorgaenger.getLaenge() / DURSCHNITTSGESCHWINDIGKEIT;
			else dauer = dauer + vorgaenger.getLaenge() / vorgaenger.getGeschwindigkeit();
			knoten = vorgaenger.getUrsprung();
			vorgaenger = knoten.getVorgaenger();
		}
		weg = String.format("%sAnkunft in %s nach etwa %s Stunden, Gesamtstrecke: %s km.", 
				weg, knoten, dauer, strecke);
		return weg;
	}
	
}
[code=Java]

package test;

import model.Kante;
import model.Knoten;
import application.DijkstraAlgorithmus;
import application.Graph;

public class Test1 {

public static void main(String... strings) {

Knoten k1 = new Knoten(1, "Frankfurt");
Knoten k2 = new Knoten(2, "Mannheim");
Knoten k3 = new Knoten(3, "Wuerzburg");
Knoten k4 = new Knoten(4, "Stuttgard");
Knoten k5 = new Knoten(5, "Kassel");
Knoten k6 = new Knoten(6, "Karlsruhe");
Knoten k7 = new Knoten(7, "Erfurt");
Knoten k8 = new Knoten(8, "Nuernberg");
Knoten k9 = new Knoten(9, "Augsburg");
Knoten k10 = new Knoten(10, "Muenchen");

Kante w1_2 = new Kante(1, "Weg1", k1, k2, 85, 70);
Kante w2_1 = new Kante(1, "Weg1", k2, k1, 85, 70);
Kante w1_3 = new Kante(2, "Weg2", k1, k3, 217, 50);
Kante w3_1 = new Kante(2, "Weg2", k3, k1, 217, 50);
Kante w1_5 = new Kante(3, "Weg3", k1, k5, 173, 130);
Kante w5_1 = new Kante(3, "Weg3", k5, k1, 173, 130);
Kante w2_6 = new Kante(4, "Weg4", k2, k6, 80, 70);
Kante w6_2 = new Kante(4, "Weg4", k6, k2, 80, 70);
Kante w3_7 = new Kante(5, "Weg5", k3, k7, 186, 100);
Kante w7_3 = new Kante(5, "Weg5", k7, k3, 186, 100);
Kante w3_8 = new Kante(6, "Weg6", k3, k8, 103, 100);
Kante w8_3 = new Kante(6, "Weg6", k8, k3, 103, 100);
Kante w4_8 = new Kante(7, "Weg7", k4, k8, 183, 100);
Kante w8_4 = new Kante(7, "Weg7", k8, k4, 183, 100);
Kante w5_10 = new Kante(8, "Weg8", k5, k10, 502, 130);
Kante w10_5 = new Kante(8, "Weg8", k10, k5, 502, 130);
Kante w6_9 = new Kante(9, "Weg9", k6, k9, 250, 100);
Kante w9_6 = new Kante(9, "Weg9", k9, k6, 250, 100);
Kante w8_10 = new Kante(10, "Weg10", k8, k10, 167, 100);
Kante w10_8 = new Kante(10, "Weg10", k10, k8, 167, 100);
Kante w9_10 = new Kante(11, "Weg11", k9, k10, 84, 100);
Kante w10_9 = new Kante(11, "Weg11", k10, k9, 84, 100);

Graph graph = new Graph();

Knoten[] knoten = {k1,k2,k3,k4,k5,k6,k7,k8,k9,k10};

graph.setKnoten(knoten);
DijkstraAlgorithmus route = new DijkstraAlgorithmus(graph);

System.out.println(route.getKuerzesterWegAsString(k4, k2));
System.out.println("---");
System.out.println(route.getSchnellsterWegAsString(k4, k2));




}


}
[/code]
[JAPI]461px-MapGermanyGraph.png[/JAPI]

wie sie in meiner test classe,da gibt's meine datenbank ,aber jetzt ich woltte sie nicht mehr da haben,sonder in meiner sql programme,und ich werde sie mit jdbc verbinden,wenn einer von eine idee hat,dann schiess los.vielen dank

 

[Gast2]

Schuß ins Blaue,

Table Stadt:
id | koordx | koordy | name | ...

Table Wege:
stadt (fk:Stadt:id) | ziel (fk:Stadt:id) | entfernung | ...

mit [c]Stadt -> Knoten[/c] und [c]Weg -> Kante[/c] (logisch, was sonst)

hand, mogel

 

[Prince Nour]

:toll: