[c#] treeview

[Bint]

Dag,

ik probeer een treeview te maken van wat data, maar nu zit ik met het volgende probleem:

ik heb bijvoorbeeld de volgende data:

code:

A.aa.b
A.aa.c.
A.aa.d.e
A.aa.d.f
A.bb.b
A.bb.c
A.bb.d.f
A.bb.d.g

alles wat achter A komt, is 1 string

Maar nu wil ik graag ervoor zorgen, dat er na elke punt een nieuwe node wordt gemaakt, zodat ik het volgende in de tree zie:

code:

A.aa.b
     c
     d.e
       f
A.bb.b
     c
     d.f
       g

Is hier een simpele methode voor, of moet ik daar zelf weer een functie voor schrijven?

[ Voor 5% gewijzigd door Bint op 15-03-2006 13:33 ]

[giMoz]

je code geeft niet na elke punt een nieuwe node...
want dan zou je tree worden:

code:

A
  aa
    b
    c
    d
      e
      f
  bb
    b
    c
    d
     e
     f
     g

[ Voor 3% gewijzigd door giMoz op 15-03-2006 13:38 ]

[mulder]

Daar zul je toch zelf een functie voor moeten schrijven. Tenzij er een functie MakeTreeFromStringAndMakeNodesWhenAPointIsEncountered bestaat, maar dat lijkt me niet. Krijg je de data zo aangeleverd?

[Bint]

Ja, ik krijg die data zo aangeleverd.
Was maar vast begonnen met een functie te schrijven, is het nodig om die code te plaatsen als ik ermee klaar ben? Of ben ik de enige die ooit tegen zoiets aanloopt?

[UniCache2]

beetje offtopic, maar zoek een naar de Microsoft.Web.UI.WebControls, daar zit standaard een treeview component in. Deze kan echter niet wat jij wilt, hier zul je dus zelf code voor moeten schrijven.

[mulder]

Of ben ik de enige die ooit tegen zoiets aanloopt?

Ja en nee. Een (recursieve) functie om een tree op te bouwen heeft iedereen wel nodig, maar dit is wel weer een specifieke oplossing

[Bint]

hmmm,

bijna af, maar ik zit nu met het volgende probleem:

stel, ik heb
A.aa.a
A.aa.b

dan maakt ie van beide aa's nieuwe nodes. Hoe kan ik controleren of "aa" al bestaat of niet?

node.Nodes.Contains(bla) geeft niet de juiste output, misschien een andere?

[Woy]

Je zou nodes die je maakt in een Hashtable kunnen zetten dan kan je aan de hand van de key "aa" of "A.aa" je node weer terug vinden.

[Bint]

rwb schreef op woensdag 15 maart 2006 @ 15:50:
Je zou nodes die je maakt in een Hashtable kunnen zetten dan kan je aan de hand van de key "aa" of "A.aa" je node weer terug vinden.

een hashtable lijkt mij geen oplossing, want dan moet ik hashtables gaan nesten ...

Is echt er geen manier waarop ik gemakkelijk kan kijken of een node al bestaat?

[Woy]

Hoezo moet je hashtables nesten? Je kan toch alle nodes in een hashtable doen. Je moet er dan alleen voor zorgen dat je het volledige path in de tree als key gebruikt ( Of zorgen dat names niet dubbel voor kunnen komen ).

[riezebosch]

Krijg je ze wel op volgorde binnen? Je kan het dan met zogenaamde "level-break" oplossen.

Misschien wel aardig pittig, omdat het natuurlijk niet om een bepaalde diepte gaat. Denk dat je het dan het mooist kan oplossen door recursief een bepaalde functie aan te roepen, met als argument de prefix van de string: het niveau waarop je de nieuwe toe wilt voegen. Zodra dit verandert jump je een niveau terug.

[ Voor 66% gewijzigd door riezebosch op 15-03-2006 17:17 ]

[Daos]

Je kan toch gewoon een string vergelijken met de vorige en bij alles wat vanaf het begin nog steeds gelijk is een spatie uitspugen.

c# ken ik niet zogoed, dus maar even in Java:

Java:

    String[] input = {
      "A.aa.b",
      "A.aa.c",
      "A.aa.d.e",
      "A.aa.d.f",
      "A.bb.b",
      "A.bb.c",
      "A.bb.d.f",
      "A.cc.d.f",
      "A.cc.d.g"
    };

    System.out.println(input[0]);
    for (int i = 1; i < input.length; i++) {
      boolean gelijk = true;
      for (int j = 0; j < input[i].length(); j++)
        if (gelijk && j < input[i-1].length() && input[i-1].charAt(j) == input[i].charAt(j))
          System.out.print(' ');
        else {
          gelijk = false;
          System.out.print(input[i].charAt(j));
        }
        System.out.println();
    }

Waarschijnlijk kan je het nog iets mooier maken.

[ Voor 10% gewijzigd door Daos op 15-03-2006 17:32 ]

[Bint]

dit heb ik op het moment, om nodes toe te voegen:

C#:

private void AddNode(TreeNode node, string[] s, int x)
{
       if (x < s.Length)
       {
           TreeNode n = new TreeNode(s[x], x + 1, x + 1);
           node.Nodes.Add(n);   
           AddNode(n, s, x + 1);
       }
}

het stringarray is een array van een string, gesplits op punten.
De data komt niet op volgorde door:
wel eerst alles wat met bijvoorbeeld een A begint, en daarna B,
maar
A.aa kan gemakkelijk gevolgd worden door A.bb en dan weer A.aa

[ Voor 12% gewijzigd door Bint op 16-03-2006 09:01 ]

[mulder]

Dan zou ik eerst zorgen dat de data wel goed gesorteerd is. (Zoeken op quicksort c#)
Dan, in pseudo:

code:

Voor elke regel
  Bepaal parent
    Voeg kinderen aan parent toe
      Check of children ook children hebben, zo ja roep deze functie aan
      Lees volgende regel
    Totdat de parent verandert.

[Bint]

ok, ik heb het

C#:

private void AddNode(TreeNode node, string[] s, int x)
{
    if (x < s.Length)
    {
        TreeNode ni;
        TreeNode n = new TreeNode(s[x], x + 1, x + 1);
        ni = CheckForExistingNode(node.Nodes, n.Text);
        if (ni == null)
        {
            node.Nodes.Add(n);
        }
        else
        {
            x++;
            if (x < s.Length)
            {
                n = new TreeNode(s[x], x + 1, x + 1);
                ni.Nodes.Add(n);
            }
        }
        AddNode(n, s, x + 1);
    }
}

private TreeNode CheckForExistingNode(TreeNodeCollection nodes, string text)
{
    foreach (TreeNode node in nodes)
    {
        if (node.Text == text)
        {
            return node;
        }
    }
    return null;
}

Maar denk dat ik em nog ga aanpassen, zodat ik ook alles kan sorteren :D

[Woy]

Waarom doe je het recursief? Ik zou het denk ongeveer zo doen.

C#:

Dictionary<String, TreeNode> table = new Dictionary<String, TreeNode>();
foreach (String s in input)
{
    String[] parts = s.Split('.');
    String parent = String.Empty;
    foreach (String part in parts)
    {
        String currentNode;
        if (parent.Equals(String.Empty))
            currentNode = part;
        else
            currentNode = parent + "." + part;

        if (!table.ContainsKey( currentNode ))
        {
            TreeNode newNode = new TreeNode(part);
            table[currentNode] = newNode;
            if (parent.Equals(string.Empty))
                tree.Nodes.Add(newNode);
            else
                table[parent].Nodes.Add(newNode);
        }
        parent = currentNode;
    }
}

[ Voor 7% gewijzigd door Woy op 16-03-2006 10:21 ]

[Bint]

Ik zal die ook eens gaan testen.

Maar waarom niet recursief? Is dat slechter ofzo? Of niet zo netjes?
Of scheelt dat in performance?

[Woy]

Recursief is meestal niet de meest performante oplossing. Maar zeker het gedeelte waar je telkens door je Nodes heen moet lopen is natuurlijk niet echt handig. Bij de oplossing die ik aandraag maak ik gebruik van een Dictionary ( Hashtable ) waar je aan de hand van een Key heel snel een element op kan zoeken. Door dit te doen hoef je niet telkens door alle nodes heen te lopen.

[Bint]

Zijn dictionaries ook te gebruiken in visual c#.Net 2003?

[RobIII]

Bintje schreef op donderdag 16 maart 2006 @ 10:53:
Zijn dictionaries ook te gebruiken in visual c#.Net 2003?

Waarom niet?

Dit gaat wel richting erg basic zo hoor...

[Bint]

klopt, maar omdat generics in 2005 te gebruiken zijn, dacht ik: misschien is dit ook niet te gebruiken..

en volgens mij gaat

C#:

Dictionary<String, TreeNode> table = new Dictionary<String, TreeNode>(); 

ook niet werken in 2003

Is gelukkig niet erg, omdat ik voor dit gedeelte 2005 gebruik, maar dit komt denk ik ook nog wel van pas in een ander stuk software waar ik mee bezig ben, wat wel in 2003 is geschreven

Maar daar is wel een oplossing voor te vinden

[ Voor 8% gewijzigd door Bint op 16-03-2006 11:07 ]

[Verwijderd]

Dictionary is alleen beschikbaar in .NET 2.0. Gebruik de HashTable in .NET 1.1

[RobIII]

Verwijderd schreef op donderdag 16 maart 2006 @ 11:07:
Dictionary is alleen beschikbaar in .NET 2.0. Gebruik de HashTable in .NET 1.1

Dat een Dictionary niet in het framework zit wil niet zeggen dat je het niet kan gebruiken / implementeren....

[Bint]

Ik ben in ieder geval geholpen atm, en heb dankzij het dictionary//hashtable verhaal een andere kijk op mijn probleem gekregen, en een snellere oplossing gevonden!

[Verwijderd]

Naar mijn weten kun je zonder de .NET 2.0 SDK niet gebruik maken van de Dictionary.

[RobIII]

Verwijderd schreef op donderdag 16 maart 2006 @ 11:25:
Naar mijn weten kun je zonder de .NET 2.0 SDK niet gebruik maken van de Dictionary.

Niet van "de" Dictionary misschien, maar wat let je om er zelf 1 te implementeren? Het is écht niet iets dat je alleen maar kunt gebruiken als het in het framework zit...

(Soms krijg ik het idee dat "mensen" (in general, niet Avater specifiek hoor ) alleen nog maar libraries en/of frameworks aan elkaar kunnen "lijmen" en zelf de onderliggende code niet meer snappen of beseffen wat er achter de schermen gebeurt).

http://en.wikipedia.org/wiki/Associative_array
http://www.nist.gov/dads/HTML/dictionary.html
http://www.cs.sunysb.edu/~algorith/files/dictionaries.shtml

[ Voor 51% gewijzigd door RobIII op 16-03-2006 11:51 ]

[Woy]

Hij zit idd niet in het 1.x framework. Vandaar dat ik ook tussen haakjes HashTable had neergezet. De 2.0 Dictonary spaart wat casts uit maar voor de rest werkt het met een HashTable natuurlijk exact hetzelfde.

Bintje schreef op donderdag 16 maart 2006 @ 11:20:
Ik ben in ieder geval geholpen atm, en heb dankzij het dictionary//hashtable verhaal een andere kijk op mijn probleem gekregen, en een snellere oplossing gevonden!

Als je ook nog vermeld hoe je het uiteindelijk opgelost hebt heeft iemand anders er later mischien nog een keer wat aan.

[Verwijderd]

Dictionary is de generieke versie van de Hashtable. .NET 1.1 ondersteund geen Generics. Dus de Dictionary(met generics) zoals het hierboven gebruikt wordt kun je niet implementeren zonder .NET 2.0. Wat inhoudt dat Hashtable de beste keuze is. Je kunt natuurlijk ook de functionaliteit die al beschikbaar is in de klasse HashTable herimplementeren als je zin hebt in het leveren van overbodig werk .

[ Voor 25% gewijzigd door Verwijderd op 16-03-2006 12:00 ]

[Woy]

Het is hier idd nogal overbodig om zelf het wiel uit te gaan vinden. Maar wat RobIII denk bedoelt is dat het geen kwaad kan om wat besef te hebben over hoe dergelijke datastructuren intern werken aangezien je dan veel beter de beslissing kan nemen of je die datastructuur wel wilt gebruiken. Als er geen passende datastructuur beschikbaar is kan je dan altijd nog je eigen implementeren.

[Bint]

Is het trouwens slim om een hashtable // dictionary te gebruiken als je +/- 500 verschillende objecten hebt?

[RobIII]

Bintje schreef op donderdag 16 maart 2006 @ 13:34:
Is het trouwens slim om een hashtable // dictionary te gebruiken als je +/- 500 verschillende objecten hebt?

Het is dan vooral slim om je eens te verdiepen in een hashtable / dictionary en zélf te ontdekken of het slim is om die te gebruiken

[Woy]

Bintje schreef op donderdag 16 maart 2006 @ 13:34:
Is het trouwens slim om een hashtable // dictionary te gebruiken als je +/- 500 verschillende objecten hebt?

Een hashtable kan best om gaan met 500 objecten. Het is meer de vraag wat het doel is wat je wilt bereiken. Zoals RobIII al zegt is het een goed idee om je eens in Datastructuren in zijn algemeen te verdiepen. Dan kan je daarna per geval makkelijker bepalen welke structuur je het beste kunt gebruiken.

[Bint]

rwb schreef op donderdag 16 maart 2006 @ 11:50:
Als je ook nog vermeld hoe je het uiteindelijk opgelost hebt heeft iemand anders er later mischien nog een keer wat aan.

het stukje code wat ik had gekregen, heb ik bijna helemaal kunnen gebruiken.

Wat ik in het andere projectje veranderd heb, doet er niet toe, omdat het een heel ander probleem was.

[gorgi_19]

Ik geloof dat EfBe ook nog een en ander destijds had geschreven hierover

[rml]EfBe in "[ VB.NET] Treeview + Subnodes (van Subnod..."[/rml]

[Woy]

gorgi_19 schreef op donderdag 16 maart 2006 @ 14:22:
Ik geloof dat EfBe ook nog een en ander destijds had geschreven hierover

[rml]EfBe in "[ VB.NET] Treeview + Subnodes (van Subnod..."[/rml]

Idd, al gaat het daar over het creeren van een Tree uit bijvoorbeeld een database waar je per record een NodeID en ParentID hebt. In dit geval zit het natuurlijk net wat anders in elkaar.