# Probleme bei Gruppierungsaufgabe



## nettchen (1. Aug 2007)

Hallo 

habe die Aufgabe das Angebot einer Apotheke zu Modellieren. Zu jedem Medikament ist die Firma(z.b. Aurum), Zweck(z.b Kopfschmerzen) ,Art(z.b Tropfen) dann Name( z.b. Wunderwerk) und dann Inhalt(z.B. 10) Die ersten 4 werte werden als String und der letzte als Zahl gespeichert. Ich bekomme jetzt eine Arraylist gegeben ,welche eine beliebig große Menge an Medikamanten enthält und soll diese guppieren( Als Baum ausgeben)  Zum testen haben wir eine Liste bekommen, aber die Abnahme erfolgt mit einer anderen. Es soll also am Ende so aussehen
       -Aurum
	-Kopfschmerzen		
		-Tabletten
			- Kopfweh Weg 
				-10
				-20
			- Neuromehr 
				-10
				-20
		+Tropfen
	-Zahnschmerzen		
		+Spray
		+Tabletten
		+Tropfen 



ein Eintrag der Arraylist sieht so aus: Aurum	Kopfschmerzen	Tabletten	Neuromehr	10

jetzt habe ich mir überlegt die Arraylist als erstes nach allen Spalten zu sortieren, das funzt auch fehlerfrei.
Doch bei der Erstellung des Baumes hänge ich. den Baum erstellen kann ich zwar (also das anlegen der tree Elemente (in SWT) aber ich habe Probleme wenn sich am ende der liste. Sind dort 2 Elemente fast gleich wird fü as letzte element noch ein extra pfad angelegt (siehe Bild)





Habe das Problem bis jetzt so gelöst aber es sind halt noch bugs enthalten, hoffe mir kann jemand sagen wie ich diese behebe

also als erstes sortiere ich die liste
dann vergleiche ich das n.te element des zwecks mit dem n+1 ten element des zwecks und zähle wie oft das gleich ist, diese zahl merke ich mir dann erstelle ich ein Baumelement mit diesem Zweck, jetzt zähle ich in einer inneren schleife wieder die gleichen Elemente usw.

Hier ist mein Quellcode für das Sortieren 


```
public class ArraySort implements Comparator<Medikament>
{

	public final static int FIRMA = 0;
	public final static int ZWECK = 1;
	public final static int ART = 2;
	public final static int NAME = 3;
	public final static int INHALT = 4;

	public int compare(Medikament med1, Medikament med2)
	{
		int result = 0;
		for (int i = 0; i < 5 && result == 0; i++)
		{
			result = doCompare(i, med1, med2);
		}
		return result;
	}

	public ArraySort()
	{
		super();

	}

	public int doCompare(int sortField, Medikament med1, Medikament med2)
	{
		int result = 0;
		switch (sortField)
		{
			case FIRMA:
				result = med1.firma.compareTo(
						med2.firma);
				break;
			case ZWECK:
				result = med1.zweck.compareTo(
						med2.zweck);
				break;
			case ART:
				result = med1.art.compareTo(
						med2.art);
				break;
			case NAME:
				result = med1.name.compareTo(med2.name);
				break;
			case INHALT:
				result = ((Integer)med1.inhalt).compareTo((Integer)med2.inhalt);
				break;
			default:
				break;
		}
		return result;
	}
}
```

und jetzt das fürs baum erstellen, die Methode generateTree wird von der shell beim erstellen aufgerufen


```
public void generateTree(ArrayList<Medikament> liste)
	{
		try
		{
			ArrayList<Medikament> list = liste;
			Collections.sort(list, new ArraySort());
			for (Medikament med : list)
			{
				System.out.println(med.firma + "      "
						+ med.zweck + "     "
						+ med.art + "      "
						+ med.name + "   " + med.inhalt);
			}

			boolean b1, b2, b3, b4, b5, b6, b7;
			ArraySort sort = new ArraySort();
			//
			int anzF = 0;
			int j_ind = 0;
			int alt_F = 0;
			for (int i = 1; i < list.size(); i++)
			{

				// Vergleich Firma
				if ((sort.doCompare(0, list.get(i), list.get(i - 1)) == 0)
						&& (i != (list.size() - 1)))
				{
					anzF++;
				} else
				{
					// generiert Knoten für Firma
					generateTreeItem(0, list.get(i - 1).firma);

					int anzF_akt = anzF;
					anzF = 0;
					int anzZ = 0;
					for (int j = 0; j <= anzF_akt; j++)
					{
						j_ind = alt_F + j;

						if ((sort.doCompare(1, list.get(j_ind), list
								.get(j_ind + 1)) == 0)
								&& (sort.doCompare(0, list.get(j_ind),
										list.get(j_ind + 1)) == 0)
								&& (j_ind != (list.size() - 2)))
						{
							anzZ++;
						} else
						{
							generateTreeItem(1, list.get(j_ind).zweck);
							int anzJ_akt = anzZ;
							anzZ = 0;
							int anzC = 0;
							int k_bevor = j_ind - anzJ_akt;
							for (int k = 0; k <= anzJ_akt; k++)
							{
								int c_ind = k_bevor + k;
								b1 = (anzJ_akt != 0);
								b2 = sort.doCompare(2, list.get(c_ind),
										list.get(c_ind + 1)) == 0;
								b3 = sort.doCompare(1, list.get(c_ind),
										list.get(c_ind + 1)) == 0;
								b4 = (c_ind != (list.size() - 2));

								if (b1 && (b2 && b3) && b4)
								{
									anzC++;
								} else
								{
									generateTreeItem(2, list.get(c_ind)	.art);
									int anzC_akt = anzC;
									anzC = 0;

									int anzI = 0;
									int i_bevor = c_ind - anzC_akt;

									for (int l = 0; l <= anzC_akt; l++)
									{
										int i_ind = i_bevor + l;

										b1 = (anzC_akt != 0);
										b2 = (l != anzC_akt);
										b3 = (sort.doCompare(3, list
												.get(i_ind), list
												.get(i_ind + 1)) == 0);
										b4 = (sort.doCompare(2, list
												.get(i_ind), list
												.get(i_ind + 1)) == 0);
										b5 = (sort.doCompare(1, list
												.get(i_ind), list
												.get(i_ind + 1)) == 0);
										b6 = (sort.doCompare(0, list
												.get(i_ind), list
												.get(i_ind + 1)) == 0);
										b7 = (i_ind != (list.size() - 2));

										if ((b1 && b2) && (b3 && b4)
												&& (b5 && b6) && b7)
										{
											anzI++;
										} else
										{
											generateTreeItem(3, ""
													+ list.get(i_ind)
															.name);
											int anzI_alt = anzI;
											anzI = 0;
											int a_bevor = i_ind - anzI_alt;
											// if (i_ind == (listPjOv.size()-2))
											// {
											// anzI_alt++;
											// }
											for (int m = 0; m <= anzI_alt; m++)
											{
												int a_ind = a_bevor + m;
												generateTreeItem(4, ""
														+ list.get(a_ind)
																.inhalt);
											}
										}
									}
								}
							}
						}
					}
					alt_F = i;
				
					if (i == (list.size() - 1))
					{
						
						generateTreeItem(1, list.get(i).zweck
								);
						
						generateTreeItem(2, list.get(i).
								art);
						
						generateTreeItem(3, list.get(i).name);
						
						generateTreeItem(4, "" + list.get(i).inhalt);
						
					}
				}
			}
		} catch (Exception e)
		{
			System.out.println(e.getMessage());
			e.printStackTrace();
		}
	}
	
	private void generateTreeItem(int kind, String text)
	{

		switch (kind)
		{
			case 0:
				tZweck = new TreeItem(treeSortiment, SWT.NONE);
				tZweck.setText(text);
				tZweck.setData(text);
				break;
			case 1:
				tFirma = new TreeItem(tZweck, SWT.NONE);
				tFirma.setText(text);
				tFirma.setData(text);
				break;
			case 2:
				tArt = new TreeItem(tFirma, SWT.NONE);
				tArt.setText(text);
				tArt.setData(text);
				break;
			case 3:
				tName = new TreeItem(tArt, SWT.NONE);
				tName.setData(text);				
				tName.setText(text);
				break;
			case 4:
				tInhalt = new TreeItem(tName, SWT.NONE);
				tInhalt.setData(text);				
				tInhalt.setText(text);				
				break;
			default:
				break;
		}
	}
```


Wie gesagt ich bin mit dem code selber nicht zufrieden, hatte aber leider keine andere Idee wie ich das Problem lösen kann,  bin aber für jegliche Ideen offen.
Nur war Vorgabe an der Struktur nix zu ändern also der für Medikament.


----------



## SlaterB (1. Aug 2007)

nur so nebenbei zur Code-Vereinfachung:
du hast oft
if (sort.doCompare(0, list.get(i), list.get(i - 1)) == 0)
if ((sort.doCompare(1, list.get(j_ind), list.get(j_ind + 1)) == 0)

schreibe dafür eine Hilfsfunktion in sort, dann brauchst du nur noch Aufrufe a la
if (sort.equal(0, list, i-1))
if (sort.equal(1, list, j_ind))

(da immer benachbarte Elemente vergleichen werden reicht immer der kleinere Index)

sort scheint auch zustandslos zu sein, 
schadet also nicht, dass als statische oder Exemplarvariable zu modellieren,
dann reicht gar eine lokale Operation equal und

if (equal(0, list, i-1))
if (equal(1, list, j_ind))

-------

und list.size() hast du auch viel zu oft stehen,
das ist für sich schon unnötig (ein teuer Operationsaufruf), sieht aber auch noch schlecht aus im Code,
definiere dir eine Variable size und benutze die stattdessen

----------

bei
((b1 && b2) && (b3 && b4) && (b5 && b6) && b7
bringen die Subklammern nix, außer sie sind für dein eigenens Verständnis da,
stören aber auch nicht allzu sehr


----------



## nettchen (1. Aug 2007)

hallo, habe deine 2 Tipps umgesetzt und den code geändert 
Hier ist die neue  methode und die geänderte variante.

Leider ändern die aber nicht die probleme, welche ich mit dem ende der liste habe. kann auch gern die übrigen Klassen und Methoden hier noch posten, wenn das jemand mal selber testen will.

Gibt es vielleicht noch eine andere Methode das problem zu lösen? Gerne auch mit treeviewer oder irgendwas ganz anderes als ich versucht habe.
.


```
private boolean equal(int sortField, int index) {
		return (sort.doCompare(sortField, list.get(index), list.get(index + 1)) == 0);

	}
```



```
public void generateTree(ArrayList<Medikament> liste) {
		try {
			list = liste;
			Collections.sort(list, new ArraySort());
			for (Medikament med : list) {
				System.out.println(med.firma + "      " + med.zweck + "     "
						+ med.art + "      " + med.name + "   " + med.inhalt);
			}

			boolean b1, b2, b3, b4, b5, b6, b7;
			int size = list.size();
			
			int anzF = 0;
			int j_ind = 0;
			int alt_F = 0;
			for (int i = 1; i < size; i++) 
			{

				// Vergleich Firma				
				if ((equal(0, i - 1)) && (i != (size - 1))) 
				{
					anzF++;
				} else 
				{
					// generiert Knoten für Firma
					generateTreeItem(0, list.get(i - 1).firma);

					int anzF_akt = anzF;
					anzF = 0;
					int anzZ = 0;
					for (int j = 0; j <= anzF_akt; j++) {
						j_ind = alt_F + j;

						if ((equal(1, j_ind)) && (equal(0, j_ind))
								&& (j_ind != (size - 2))) {
							anzZ++;
						} else {
							generateTreeItem(1, list.get(j_ind).zweck);
							int anzJ_akt = anzZ;
							anzZ = 0;
							int anzC = 0;
							int k_bevor = j_ind - anzJ_akt;
							for (int k = 0; k <= anzJ_akt; k++) {
								int c_ind = k_bevor + k;
								b1 = (anzJ_akt != 0);
								b2 = equal(2, c_ind);
								b3 = equal(1, c_ind);
								b4 = (c_ind != (size - 2));

								if (b1 && (b2 && b3) && b4) {
									anzC++;
								} else {
									generateTreeItem(2, list.get(c_ind).art);
									int anzC_akt = anzC;
									anzC = 0;

									int anzI = 0;
									int i_bevor = c_ind - anzC_akt;

									for (int l = 0; l <= anzC_akt; l++) {
										int i_ind = i_bevor + l;

										b1 = (anzC_akt != 0);
										b2 = (l != anzC_akt);
										b3 = equal(3, i_ind);
										b4 = equal(2, i_ind);
										b5 = equal(1, i_ind);
										b6 = equal(0, i_ind);
										b7 = (i_ind != (size - 2));

										if ((b1 && b2) && (b3 && b4)
												&& (b5 && b6) && b7) {
											anzI++;
										} else {
											generateTreeItem(3, ""
													+ list.get(i_ind).name);
											int anzI_alt = anzI;
											anzI = 0;
											int a_bevor = i_ind - anzI_alt;
											// if (i_ind == (listPjOv.size()-2))
											// {
											// anzI_alt++;
											// }
											for (int m = 0; m <= anzI_alt; m++) {
												int a_ind = a_bevor + m;
												generateTreeItem(
														4,
														""
																+ list
																		.get(a_ind).inhalt);
											}
										}
									}
								}
							}
						}
					}
					alt_F = i;

					if (i == (size - 1)) {

						generateTreeItem(1, list.get(i).zweck);

						generateTreeItem(2, list.get(i).art);

						generateTreeItem(3, list.get(i).name);

						generateTreeItem(4, "" + list.get(i).inhalt);

					}
				}
			}
		} catch (Exception e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
		}
	}
```
[/code]


----------



## nettchen (1. Aug 2007)

hallo, habe deine 2 Tipps umgesetzt und den code geändert 

Hier ist die neue  methode und die geänderte variante.

Leider ändern die aber nicht die probleme, welche ich mit dem ende der liste habe. kann auch gern die übrigen Klassen und Methoden hier noch posten, wenn das jemand mal selber testen will.

Gibt es vielleicht noch eine andere Methode das problem zu lösen? Gerne auch mit treeviewer oder irgendwas ganz anderes als ich versucht habe.
.


```
private boolean equal(int sortField, int index) {
		return (sort.doCompare(sortField, list.get(index), list.get(index + 1)) == 0);

	}
```



```
public void generateTree(ArrayList<Medikament> liste) {
		try {
			list = liste;
			Collections.sort(list, new ArraySort());
			for (Medikament med : list) {
				System.out.println(med.firma + "      " + med.zweck + "     "
						+ med.art + "      " + med.name + "   " + med.inhalt);
			}

			boolean b1, b2, b3, b4, b5, b6, b7;
			int size = list.size();
			
			int anzF = 0;
			int j_ind = 0;
			int alt_F = 0;
			for (int i = 1; i < size; i++) 
			{

				// Vergleich Firma				
				if ((equal(0, i - 1)) && (i != (size - 1))) 
				{
					anzF++;
				} else 
				{
					// generiert Knoten für Firma
					generateTreeItem(0, list.get(i - 1).firma);

					int anzF_akt = anzF;
					anzF = 0;
					int anzZ = 0;
					for (int j = 0; j <= anzF_akt; j++) {
						j_ind = alt_F + j;

						if ((equal(1, j_ind)) && (equal(0, j_ind))
								&& (j_ind != (size - 2))) {
							anzZ++;
						} else {
							generateTreeItem(1, list.get(j_ind).zweck);
							int anzJ_akt = anzZ;
							anzZ = 0;
							int anzC = 0;
							int k_bevor = j_ind - anzJ_akt;
							for (int k = 0; k <= anzJ_akt; k++) {
								int c_ind = k_bevor + k;
								b1 = (anzJ_akt != 0);
								b2 = equal(2, c_ind);
								b3 = equal(1, c_ind);
								b4 = (c_ind != (size - 2));

								if (b1 && (b2 && b3) && b4) {
									anzC++;
								} else {
									generateTreeItem(2, list.get(c_ind).art);
									int anzC_akt = anzC;
									anzC = 0;

									int anzI = 0;
									int i_bevor = c_ind - anzC_akt;

									for (int l = 0; l <= anzC_akt; l++) {
										int i_ind = i_bevor + l;

										b1 = (anzC_akt != 0);
										b2 = (l != anzC_akt);
										b3 = equal(3, i_ind);
										b4 = equal(2, i_ind);
										b5 = equal(1, i_ind);
										b6 = equal(0, i_ind);
										b7 = (i_ind != (size - 2));

										if ((b1 && b2) && (b3 && b4)
												&& (b5 && b6) && b7) {
											anzI++;
										} else {
											generateTreeItem(3, ""
													+ list.get(i_ind).name);
											int anzI_alt = anzI;
											anzI = 0;
											int a_bevor = i_ind - anzI_alt;
											// if (i_ind == (listPjOv.size()-2))
											// {
											// anzI_alt++;
											// }
											for (int m = 0; m <= anzI_alt; m++) {
												int a_ind = a_bevor + m;
												generateTreeItem(
														4,
														""
																+ list
																		.get(a_ind).inhalt);
											}
										}
									}
								}
							}
						}
					}
					alt_F = i;

					if (i == (size - 1)) {

						generateTreeItem(1, list.get(i).zweck);

						generateTreeItem(2, list.get(i).art);

						generateTreeItem(3, list.get(i).name);

						generateTreeItem(4, "" + list.get(i).inhalt);

					}
				}
			}
		} catch (Exception e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
		}
	}
```
[/code]


----------



## nettchen (1. Aug 2007)

*Sorry* Doppelpost, bitte letzten Beitrag löschen


----------



## Marco13 (1. Aug 2007)

Der Code ist (für mich) ziemlich schwer nachvollziehbar. Spontan würde ich sagen, dass er durch einen "Rekursiven" Ansatz vielleicht übersichtlicher (und damit auch leichter debugbar) werden könnte.

Du hast also eine Liste, die lexikographisch sortierte Medikamente enthält. (Also erst nach Firma sortiert, dann nach Symptom etc...). 

Jeder Knoten des Baums hat dabei die Eigenschaft, dass er _selbst_ für eine Gruppe von Medikamenten steht, die an der entsprechenden Stelle (beim entsprechenden sortItem) gleich sind.

Im Pseudocode(!) könntest du ja jetzt vielleicht sowas machen wie

```
TreeNode createTreeNode(List<Medi> medis, int sortField)
{
    // Der Knoten mit dem "Namen" enthält nurnoch die letzten Unterknoten (die Blätter)
    if (sortField == NAME)
    {
         TreeNode result = new TreeNode(name);
         for (Medi m : medis)
         {
             result.addChild(new TreeNode(m)); 
         }
         return result;
    }

    // Erstelle eine Liste, die mehrere Listen enthält:
    // Die 'medis'-Liste wird aufgeteilt. Die entstehenden 
    // Listen haben JEWEILS das gleiche Element bei "sortField",
    // aber unterschiedliche Elemente bei "sortField+1"
    List<List<Medis>> subListen = erstelleSubListen(medis, sortField);

    TreeNode result = new TreeNode();
    for (List<Medis> subList : subListen)
    {
        Node child = createTreeNode(subList, sortField+1);
        result.addChild(child);
    }
    return result;
}
```
Ist nur ein spontaner Gedanke, aber KÖNNTE das ganze VIELLEICHT erheblich vereinfachen - müße man nochmal drüber nachdenken.


----------



## nettchen (1. Aug 2007)

ja ich glaube das würde das ganze wirklich vereinfachen, Ich weiß zwar was rekursion bedeuted und habe sie auch schon manschmal gebraucht. Allerdings nie bei einem so komplexen bsp eher bei sowas wie fakultät oder so. 

Könntest du mir das ganze nochmal etwas näher erklären also ist medis am anfang  die liste, welche ich in apotheke erstellt habe und wie mache ich dann so richtig weiter. das mit dem wenn feld name ist , ist mir klar. was ich aber auch nicht so recht versteh ist was du meinst mit erstelle eine liste die mehrere listen enthäl.

Hoffe du kannst es mir nochmal etwas näher erklären, da ich mit rekursion bisher noch nicht viel gemacht habe, aber denke das das wirklich die lösung wäre


----------



## nettchen (1. Aug 2007)

So habe mich mal an die Rekursion rangetraut und konnte die listen auch erstellen, allerdings haperts jetzt bei der Umsetzung in SWT in die Baumstruktur. Marco13 erstellt ja in seiner struktur Knoten denen er immer nur den wert mitgibt in SWT muss man aber auch noch den parent also darüberliegenden Knoten angeben und hat keine addChild Methode. Und jetzt weiß ich nicht so recht weiter, wie ich das Problem lösen soll.

Hier mein bisheriger Ansatz




```
//Einordnung nur die werte in eine liste, die im sortfield gleichen wert haben
private ArrayList<ArrayList<Medikament>> erstelleSublisten(ArrayList<Medikament> medis ,int sortField)
	{
		ArrayList<ArrayList<Medikament>> subListen = new ArrayList<ArrayList<Medikament>>();
		ArrayList<Medikament> subListe = new ArrayList<Medikament>(); 
		
		int size = medis.size();
		for (int i = 0; i< size-1 ;i++ )
		{		
			if(testEqual(sortField, medis.get(i), medis.get(i+1)))
			{
				subListe.add(medis.get(i));
				if (i == size-2)
    				{
					subListe.add(medis.get(i+1));
					subListen.add(subListe);
				}
								
			}else
			{
				subListe.add(medis.get(i));
				subListen.add(subListe);
				subListe = new ArrayList<Medikament>();		
				if (i == size-2)
				{
					subListe.add(medis.get(i+1));
					subListen.add(subListe);
				}
			}
			
		}
	         return subListen;
	}
```

und hier meine ander Methode


```
private TreeItem createTreeItem(ArrayList<Medikament> medis, int sortField)
	{
		
		if (sortField == NAME)
		{
			TreeItem result = generateTreeItems(NAME, medis.get(0));
			for (Medikament m : medis)
			{
				generateTreeItems(INHALT,m);
			}
			return result;
		}
		
		System.out.println("Sortfield: " +sortField);
		
		ArrayList<ArrayList<Medikament>> subListen = erstelleSublisten(medis, sortField);
		
		for (ArrayList<Medikament> sublist: subListen)
		{
			TreeItem item = createTreeItem(sublist, sortField+1);
			//hier weiß ich nicht weiter
                                                //generateTreeItems(sortField, med);
			
			
		}
		return null;
		
	}
```

und hier noch die Methode die die einzelnen treeitems anlegt

```
private TreeItem generateTreeItem(int kind, Medikament med) {

		switch (kind) {
		case 0:
			tZweck = new TreeItem(treeSortiment, SWT.NONE);
			tZweck.setText(med.zweck);
			tZweck.setData(med.zweck);
			return tZweck;			
		case 1:
			tFirma = new TreeItem(tZweck, SWT.NONE);
			tFirma.setText(med.firma);
			tFirma.setData(med.firma);
			return tFirma;
		case 2:
			tArt = new TreeItem(tFirma, SWT.NONE);
			tArt.setText(med.art);
			tArt.setData(med.art);
			return tArt;
		case 3:
			tName = new TreeItem(tArt, SWT.NONE);
			tName.setData(med.name);
			tName.setText(med.name);
			return tName;
		case 4:
			tInhalt = new TreeItem(tName, SWT.NONE);
			tInhalt.setData(""+med.inhalt);
			tInhalt.setText(""+med.inhalt);
			return tInhalt;
		default:
			return null;
		}
	}
```

Kann mir nochmal jemand helfen bitte?


----------



## Marco13 (1. Aug 2007)

Hm - dass bei SWT immer der Parent angegeben werden muss, war mir nicht bewußt...Aber im Prinzip dürfte das kein Problem sein: Man kann bei der Rekursion den Parent jeweils mit übergeben. Ich weiß nicht genau, was deine generateTreeItems-Methode macht, aber jeder Knoten, der erstellt wird, ist der "parent"-Knoten für die _nächste_ Ebene - und wird in den rekursiven Aufruf übergeben. NOCH pseudocodiger:

```
TreeItem createTree(List list, TreeItem parent)
{
    if (man ist in der letzen Ebene vor den bei den Blättern) 
    {
        TreeItem node = new TreeItem(parent); // Knoten ans "parent" hängen
        for (alle Blätter)
        { 
             TreeItem leaf = new TreeItem(node); // Blätter erstellen, und an "node" hängen
        }
        return node;
    }
    else
    {
        TreeItem result = new TreeItem(parent); // Den 'result'-Knoten ans parent hängen
        for (alle neuen Knoten)
        {
                TreeItem neuerKnoten = createTree(datenFürNeuenKnoten, result); // Alle neuen Knoten an 'result' hängen
        }
        return result;
    }
}
```
Der Aufruf auf der "untersten" Ebene würde dann eben mit den Wurzelknoten stattfinden... FALLS es nicht der Aufgabenstellung widerspricht, könntest du dann evtl. EINEN "echten" Wurzelknoten in den Tree legen (im Moment gibt es ja für jede Firma einen) - das würde das ganze vmtl. nochmal vereinfachen.


----------



## nettchen (1. Aug 2007)

hallo,

ok soweit habe ich es hinbekommen, der baum wird richtig aufgebaut, allerdings gibt es da noch das problem, das die ersten 3 stufen, also bis ich bei name bin ohne wert sind, wir kann ich auf diesen zugreifen um ihn beim knotenanlegen angeben zu können damit er mir angezeigt wird.


----------



## Marco13 (1. Aug 2007)

Die Namen für die Knoten müßten eigentlich direkt aus der "aktuellen" Medi-Liste gelesen werden können. Und zwar sollte es genau das aktuelle sortField (eines _beliebigen_ Medikaments der aktuellen Liste) sein. Mit einer Methode

```
private String getNodeLabel(int sortField, Medikament med)
{
      switch (sortField)
      {
         case FIRMA:
            return med.firma;
...
}
```
die jeweils beim Erstellen eines Knotens mit dem erstbesten Medikament der aktuellen Liste aufgerufen wird sollte eigentlich das richtige liefern.


----------



## nettchen (1. Aug 2007)

Danke habe es hinbekommen. Und es sieht so viel besser aus, jetzt versteht es sogar mein prof beim draufgucken, sollte mich wohll mal ein bischen öfter an rekursion versuchen. macht das ganze um vieles einfacher
dank dir Marco13


----------

