Tree mit X Leveln als SingleLevel darstellen

[Unicate]

Hallo alle zusammen!

Hier mein Problem:
Ich habe eine Klasse Tree. Diese erbt von LinkedList<Tree>.
Ein Objekt Tree kann 2 verschiedene Typen annehmen.
DEFAULT und ALTERNATIVE. Wenn der Tree vom Typ ALTERNATIVE ist, enthält er mindestens 2 ALTERNATIVE's
Das kann auch geschachtelt passieren. Hier eine Darstellung:

Hier ein Beispiel

Tree: DEFAULT 1
Tree: DEFAULT 2
Tree: ALTERNATIVE
  Tree: DEFAULT 3
  Tree: ALTERNATIVE
    Tree: DEFAULT 4
    Tree: DEFAULT 5

Jetzt soll mein Objekt aus dem Oben gezeigten Beispiel viele "SingleLevel" Darstellungen machen. D.h. es soll viele neue Tree's erstellen die alle Kombinationen der DEFAULT Objekte darstellen
Für obiges Beispiel wäre das:

Tree 1:
Tree: DEFAULT 1
Tree: DEFAULT 2
Tree: DEFAULT 3

Tree 2:
Tree: DEFAULT 1
Tree: DEFAULT 2
Tree: DEFAULT 4

Tree 3:
Tree: DEFAULT 1
Tree: DEFAULT 2
Tree: DEFAULT 5

Habt Ihr eine Idee, wie ich das mit einem Algorithmus machen könnte?
Das schreit eigentlich schon nach Rekursion, aber ich komm grad nicht drauf.

Hier noch die sehr Klasses selbst:

package de.unicate;

import java.util.LinkedList;

@SuppressWarnings("serial")
public class Tree extends LinkedList<Tree> {
	
	public enum Type {
		DEFAULT,
		ALTERNATIVE
	}

	private Type _type;
	
	public Type getType() {
		return _type;
	}
	
	public Tree(Type type) {
		_type = type;
	}
	
	public Tree convertTree() {
		// to collect all the alternatives
		Tree root = new Tree(Type.ALTERNATIVE);
		
		// ****?
		
		return root;
		
	}	
}

 

[HonniCilest]

Eine Frage am Rande, würde es nicht mehr Sinn machen, wenn es so aussehen würde?

Tree: DEFAULT 1
Tree: DEFAULT 2
Tree: ALTERNATIVE
  Tree: DEFAULT 3
  Tree: DEFAULT 4
  Tree: DEFAULT 5

Ich denke dann würdest du dich auch mit der Rekusion leichter tun.

 

[Unicate]

Naja, es ist nicht ganz das Selbe. Ich gebe Dir recht, das es für diesen Fall tatsächlich das selbe wäre. Aber was ist z.B. damit:

Tree: DEFAULT 1
Tree: DEFAULT 2
Tree: ALTERNATIVE
  Tree: DEFAULT
    Tree: DEFAULT 3
    Tree: DEFAULT 4
  Tree: ALTERNATIVE
    Tree: DEFAULT 5
    Tree: DEFAULT 6

Die Lösung wäre dann:

Tree: ALTERNATIVE
  Tree: DEFAULT
    Tree: DEFAULT 1
    Tree: DEFAULT 2
    Tree: DEFAULT 3
    Tree: DEFAULT 4
  Tree: DEFAULT
    Tree: DEFAULT 1
    Tree: DEFAULT 2   
    Tree: DEFAULT 5
  Tree: DEFAULT
    Tree: DEFAULT 1
    Tree: DEFAULT 2   
    Tree: DEFAULT 6

Hat natürlich zur Folge das Tree: DEFAULT selbst auch Kinder vom Typ Tree: DEFAULT haben darf


Ich glaub ich muss über die Struktur nochma nachdenken, da stimmt was hinten und vorn nicht...

 

[HonniCilest]

Wenn das so ist würde nun das für mich mehr Sinn machen, andererseits komme ich gedanklich immer auf einen Zwiespalt:

Tree: DEFAULT 1
Tree: DEFAULT 2
Tree: ALTERNATIVE
  Tree: DEFAULT
    Tree: DEFAULT 3
    Tree: DEFAULT 4
  Tree: DEFAULT 5
  Tree: DEFAULT 6

 

[Unicate]

Ich habe den Baum inzwischen hoffentlich etwas eindeutiger geteilt:

Container (rootcontainer)
  Container (defaultcontainer 1)
    Default
    Default
    Default
  Alternative (alternative container)
    Container (alternative 1)
      Default
      Default
    Container (alternative 2)
      Default
      Default
      Default
  Container (defaultcontainer 2)
    Default
    Default

Ziel: Daraus soll folgendes werden

Container (rootcontainer)
  Container (defaultcontainer)
    Default (defaultcontainer 1)
    Default (defaultcontainer 1)
    Default (defaultcontainer 1)
    Default (alternative 1)
    Default (alternative 1)
    Default (defaultcontainer 2)
    Default (defaultcontainer 2)
  Container (defaultcontainer)
    Default (defaultcontainer 1)
    Default (defaultcontainer 1)
    Default (defaultcontainer 1)
    Default (alternative 2)
    Default (alternative 2)
    Default (alternative 2)
    Default (defaultcontainer 2)
    Default (defaultcontainer 2)

Es kann beliebig viele Container in einer "Alternative" geben.
Die Container (!=rootcontainer) können beliebig viele "Default" Nodes haben
Der Inhalt eines "Alternative" Nodes kann selbst auch "Alternative"'s haben (hier kommt die Rekursion ins Spiel)

Beispiel:

1+2+3+(5+2 oder 100-4) + 3+4+5

Rootcontainer
  Container 1: 1,2,3
  Alternative: 
    Container A1: 5,2
    Container A2: 100, -4
  Container 2: 3,4,5

Ziel ist es dem Rootcontainer eine Methode zu implementieren, welche einen neuen Rootcontainer zurückgibt, welcher so aussieht:

Rootcontainer:
  Container 1: 1+2+3+  5+2    +3+4+5 (alt 1)
  Container 2: 1+2+3+  100-4  +3+4+5 (alt 2)

 

[HonniCilest]

So sieht das auch für mich viel besser aus Ich würde nun aber nicht mehr zwingend mit Rekursion arbeiten. Ich würde nun so vorgehen:
- hänge über den bestehenden Root-Container einen weiteren, neuen Root-Container
- Solange die Tiefe des Baumes > 3 betrachte alle Bäume der 3. Ebene, hier können 3 Typen auftreten:
a) Default --> tue nichts
b) Container --> hänge alle Subtrees anstatt des Containers an die aktuelle Position, der Container verschwindet
c) Alternative --> merke dir alle Subtrees, kopiere aktuellen Tree (Ebene 2) entsprechend der Anzahl der Subtrees und hänge die Subtrees je 1x ein, die Subtrees ersetzen hier den Alternative Tree

In jedem Durchgang erhälst du so immer eine Ebene weniger bis du irgendwann bei 3 Ebenen bist.