[alg] array in blokken indelen.

Pagina: 1
Acties:

  • killercow
  • Registratie: Maart 2000
  • Laatst online: 28-11 15:56
Ik heb een array, de array zullen we voor het gemak even vergeleiken met een boom.

Het idee is dat ik de takken van de boom wil zagen op het punt waar ze anders zijn dan hun siblings.

Stel een tak heeft ronde (vorm) rode (kleur) blaadjes, en de tak er naast heeft ronde blouwe blaadjes dan wil ik ze van de parent tak zagen op het punt dat ze verschillende worden.

Een extra regeltje is dat ik zo hoog mogelijk richting de parent wil zagen.

Als laatste regeltje moeten alle blaadjes die op een tak boven een "botsing" zitten eraf gegooid worden.
Als een grote tak dus 2 child takken heeft welke andere kleuren of vormen hebben dan hijzelf moeten alle blaadjes er af gehaald worden.

Onderstaande input gaat in mijn functie:
children bevat de subtakken,
vorm is de vorm van de blaadjes,
kleur is de kleur van de blaadjes.
PHP:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
$input[0]['children'][1]['children'][0]['children'][0]['children'][0]['vorm']='rond';
$input[0]['children'][0]['children'][0]['children'][1]['children'][0]['children'][0]['kleur']='rood';
$input[0]['children'][0]['children'][0]['children'][1]['children'][0]['children'][0]['vorm']='vierkant';

$input[1]['children'][0]['children'][0]['vorm']='driehoek';
$input[1]['children'][0]['children'][0]['kleur']='rood';
$input[1]['children'][1]['children'][0]['vorm']='5kant';
$input[1]['children'][1]['children'][0]['kleur']='blauw';

$input[2]['children'][0]['children'][0]['vorm']='6kant';
$input[2]['children'][1]['children'][0]['vorm']='7kant';
$input[3]['children'][0]['children'][0]['vorm']='8kant';
$input[3]['children'][0]['children'][0]['kleur']='groen';
?>


De output is;
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
Parsing:

Array
(
    [0] => Array
        (
            [children] => Array
                (
                    [0] => Array
                        (
                            [children] => Array
                                (
                                    [0] => Array
                                        (
                                            [children] => Array
                                                (
                                                    [0] => Array
                                                        (
                                                            [children] => Array
                                                                (
                                                                    [0] => Array
                                                                        (
                                                                            [children] => Array
                                                                                (
                                                                                    [0] => Array
                                                                                        (
                                                                                            [vorm] => rond6
                                                                                        )

                                                                                    [1] => Array
                                                                                        (
                                                                                            [kleur] => geel
                                                                                        )

                                                                                )

                                                                            [vorm] => rond6
                                                                            [kleur] => geel
                                                                        )

                                                                )

                                                            [kleur] => geel
                                                        )

                                                    [1] => Array
                                                        (
                                                            [children] => Array
                                                                (
                                                                    [0] => Array
                                                                        (
                                                                            [children] => Array
                                                                                (
                                                                                    [0] => Array
                                                                                        (
                                                                                            [kleur] => rood
                                                                                            [vorm] => vierkant
                                                                                        )

                                                                                )

                                                                            [vorm] => vierkant
                                                                            [kleur] => rood
                                                                        )

                                                                )

                                                            [vorm] => vierkant
                                                            [kleur] => rood
                                                        )

                                                )

                                        )

                                )

                        )

                    [1] => Array
                        (
                            [children] => Array
                                (
                                    [0] => Array
                                        (
                                            [children] => Array
                                                (
                                                    [0] => Array
                                                        (
                                                            [children] => Array
                                                                (
                                                                    [0] => Array
                                                                        (
                                                                            [vorm] => rond
                                                                        )

                                                                )

                                                            [vorm] => rond
                                                        )

                                                )

                                            [vorm] => rond
                                        )

                                )

                            [vorm] => rond
                        )

                )

        )

    [1] => Array
        (
            [children] => Array
                (
                    [0] => Array
                        (
                            [children] => Array
                                (
                                    [0] => Array
                                        (
                                            [vorm] => driehoek
                                            [kleur] => rood
                                        )

                                )

                            [vorm] => driehoek
                            [kleur] => rood
                        )

                    [1] => Array
                        (
                            [children] => Array
                                (
                                    [0] => Array
                                        (
                                            [vorm] => 5kant
                                            [kleur] => blauw
                                        )

                                )

                            [vorm] => 5kant
                            [kleur] => blauw
                        )

                )

        )

    [2] => Array
        (
            [children] => Array
                (
                    [0] => Array
                        (
                            [children] => Array
                                (
                                    [0] => Array
                                        (
                                            [vorm] => 6kant
                                        )

                                )

                            [vorm] => 6kant
                        )

                    [1] => Array
                        (
                            [children] => Array
                                (
                                    [0] => Array
                                        (
                                            [vorm] => 7kant
                                        )

                                )

                            [vorm] => 7kant
                        )

                )

        )

    [3] => Array
        (
            [children] => Array
                (
                    [0] => Array
                        (
                            [children] => Array
                                (
                                    [0] => Array
                                        (
                                            [vorm] => 8kant
                                            [kleur] => groen
                                        )

                                )

                            [vorm] => 8kant
                            [kleur] => groen
                        )

                )

            [vorm] => 8kant
            [kleur] => groen
        )

)


Dat ziet er redelijk uit, behalve dat vorm6 niet hoog genoeg omhoog klimt, Daarnaast gaat het ook nog mis met parent takken welke niet de zelfde vorm of kleur hebben als de child takken.
Een niveau dieper gaat nog prima, die worden netjes gecleared, maar als de parent 2 of meer hoger zit als de botsing tussen 2 children gaat het mis.

Is er een naam voor dit algoritme? ik neem aan dat anno 2007 iemand al eens ieder hiermee gespeeld heeft?

Mijn code is als volgt, maar ondanks mijn 2 dagen klooien en debuggen kom ik niet op een stabielere oplossing:

PHP:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
function walkup(&$DOM,$fields){
    $domcount=count($DOM);
    $i=0;
    $walkup=true;
    $objects=array();
    $fieldcount=count($fields);
    for($j=0;$j<$fieldcount;$j++){
        $subcount[$j]=0;
        $objects[$j]=array();
    }
    while($i<$domcount){
        
        if(is_array($DOM[$i])){
            for($j=0;$j<$fieldcount;$j++){
                if(trim($DOM[$i][$fields[$j]])!=''){
                    $subcount[$j]=$subcount[$j]+1;
                    $objects[$j][]=$DOM[$i][$fields[$j]];
                }
            }
            if(isset($DOM[$i]['children'])){
                list($subsubcount,$subobjects)=walkup(&$DOM[$i]['children'],$fields);
                for($j=0;$j<$fieldcount;$j++){
                    if($subsubcount[$j]==1){
                        if(isset($subobjects[$j][0])){
                            $DOM[$i][$fields[$j]]=$subobjects[$j][0];
                        }
                    } elseif($subsubcount!=0 or $walkup==false){
                        if(isset($subobjects[$j])){
                            if(count(array_unique($subobjects[$j]))==1 or $walkup==false){                              
                                $store=true;
                                for($k=0;$k<$fieldcount;$k++){
                                    if(
                                        isset($subobjects[$k][0]) && 
                                        (
                                            $subobjects[$k][0]==$subobjects[$k][1] or 
                                            !isset($subobjects[$k][1])
                                        )
                                    ){
                                    } else {
                                        $store=false;
                                        break;
                                    }
                                }
                                if($store==true){
                                    $DOM[$i][$fields[$j]]=$subobjects[$j][0];
                                }
                                $subsubcount[$j]=1;
                                unset($subobjects[$j]);
                                $subobjects[$j][]=$DOM[$i][$fields[$j]];
                                $walkup=false;
                            } else {
                                // just let this slide up the ladder
                            }
                        }
                    }
                    if(isset($subobjects[$j]) && $subsubcount[$j]>0){
                        $subcount[$j]=$subcount[$j]+$subsubcount[$j];
                        $objects[$j]=array_merge($subobjects[$j],$objects[$j]);
                    }

                }
            }
        }
        $i++;
    }
    return array($subcount,$objects);
}

openkat.nl al gezien?


  • Ciqniz
  • Registratie: Oktober 2002
  • Laatst online: 07-09-2023

Ciqniz

On the move...

Meestal helpt het wel om het helemaal uit te tekenen.

Teken eens een voorbeeld boom met takken en probeer je probleem schematisch op te lossen met behulp van iets visueels.

Bij dit soort 'problemen' kom je vaak tot een beknopter en logischer algorythme die goed te implementeren zou moeten zijn. Tijdens het uitschrijven/tekenen van je schema terwijl je naar je boom kijkt zie je meteen je knelpunten en de kortste routes die je moet nemen.

Het is nog te vroeg om dieper op je probleem in te gaan, maar deze manier helpt mij altijd perfect (dikke arrays of matrixen omzetten).

  • killercow
  • Registratie: Maart 2000
  • Laatst online: 28-11 15:56
Ciqniz schreef op donderdag 14 juni 2007 @ 09:50:
Meestal helpt het wel om het helemaal uit te tekenen.

Teken eens een voorbeeld boom met takken en probeer je probleem schematisch op te lossen met behulp van iets visueels.

Bij dit soort 'problemen' kom je vaak tot een beknopter en logischer algorythme die goed te implementeren zou moeten zijn. Tijdens het uitschrijven/tekenen van je schema terwijl je naar je boom kijkt zie je meteen je knelpunten en de kortste routes die je moet nemen.

Het is nog te vroeg om dieper op je probleem in te gaan, maar deze manier helpt mij altijd perfect (dikke arrays of matrixen omzetten).
:)
Dat is wat ik nu aan het doen ben, gewoon van scratch opnieuw een boom uitwerken, ik hoop dat er een algemene naam voor is, want er zijn zo veel variabelen die output kunnen beinvloeden dat het verstandiger is om een ready made algo te gebruiken. (daar heb je tenslotte professors hogere informatica voor toch?)

openkat.nl al gezien?


  • Janoz
  • Registratie: Oktober 2000
  • Nu online

Janoz

Moderator Devschuur®

!litemod

Geen arrays gebruiken op plekken waar je eigenlijk een struct of class nodig hebt. Op een dergelijke manier arrays gebruiken in php gebeurt best vaak, maar ik vind het ontiegelijk foutgevoelig en onoverzichtelijk.

[ Voor 5% gewijzigd door Janoz op 14-06-2007 10:24 ]

Ken Thompson's famous line from V6 UNIX is equaly applicable to this post:
'You are not expected to understand this'


  • killercow
  • Registratie: Maart 2000
  • Laatst online: 28-11 15:56
Janoz schreef op donderdag 14 juni 2007 @ 10:24:
Geen arrays gebruiken op plekken waar je eigenlijk een struct of class nodig hebt. Op een dergelijke manier arrays gebruiken in php gebeurt best vaak, maar ik vind het ontiegelijk foutgevoelig en onoverzichtelijk.
En hoe precies wordt het algoritme anders als je recursief alle objecten (tak) door gaat lopen?
Daarnaast is een class een stuk trager om te initieren.
Het voordeel is dat je de functie per object instantie kan aanroepen waardoor het wellicht wat onzichtelijker wordt, maar de logica blijft het zelfde.

openkat.nl al gezien?


  • .oisyn
  • Registratie: September 2000
  • Laatst online: 23:31

.oisyn

Moderator Devschuur®

Demotivational Speaker

killercow schreef op donderdag 14 juni 2007 @ 09:23:
Ik heb een array, de array zullen we voor het gemak even vergeleiken met een boom.
Een array is geen boom. Wat jij hebt is ook niet "een array", maar een array van objecten, waarbij elk object mogelijk ook weer een dergelijke array is.

Boom is idd de correcte term, maar array niet. Dat je het in PHP kan simuleren met arrays is verder niet interessant, en zorgt alleen maar voor reacties zoals die van Janoz (correct imho), terwijl het eigenlijke probleem daar helemaal niet over gaat :)

Verder nog wat vragen: wat wil je eigenlijk doen met de takken die zijn afgesneden? Moeten die gewoon weggegooid worden, of moeten die in de root node weer geinsert worden? En wat als een tak maar 1 child tak heeft die anders is dan zichzelf, wil je daar dan ook zagen (niet volgens je tekst want daar heb je het slechts over siblings)? Overigens zijn blaadjes op een tak zelf ook vertakkingen, maar dat bedoel je waarschijnlijk niet zo?

[ Voor 38% gewijzigd door .oisyn op 14-06-2007 10:57 ]

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.


  • killercow
  • Registratie: Maart 2000
  • Laatst online: 28-11 15:56
.oisyn schreef op donderdag 14 juni 2007 @ 10:50:
[...]

Een array is geen boom. Wat jij hebt is ook niet "een array", maar een array van objecten, waarbij elk object mogelijk ook weer een dergelijke array is.

Boom is idd de correcte term, maar array niet. Dat je het in PHP kan simuleren met arrays is verder niet interessant, en zorgt alleen maar voor reacties zoals die van Janoz (correct imho), terwijl het eigenlijke probleem daar helemaal niet over gaat :)

Verder nog wat vragen: wat wil je eigenlijk doen met de takken die zijn afgesneden? Moeten die gewoon weggegooid worden, of moeten die in de root node weer geinsert worden? En wat als een tak maar 1 child tak heeft die anders is dan zichzelf, wil je daar dan ook zagen (niet volgens je tekst want daar heb je het slechts over siblings)? Overigens zijn blaadjes op een tak zelf ook vertakkingen, maar dat bedoel je waarschijnlijk niet zo?
Boom/array, in php is het werken met een array wat sneller handiger dan met een boom van objecten.
De takken worden in principe niet afgezaagd, maar worden gewoon tot aan de parent opgevuld met de zelfde blaadjes. (tot de botsing zeg maar)

Een tweede pass loopt daarna de boom nogmaals door om alles takken de zagen waar blaadjes te vinden zijn, als het goed is komt hij vanzelf de hoofd-takken tegen waar onder alleen nog maar gelijke blaadjes te vinden zijn.

Als een tak zelf 1 child tak heeft die ander blaadjes heeft als hij zelf moet de huidige tak leeg gesnoeid worden, alle blaadjes er af, en wordt de child-tak dus de eerst tak met blaadjes.

Blaadjes zelf zijn idd geen tak, maar een waarde.

openkat.nl al gezien?


  • .oisyn
  • Registratie: September 2000
  • Laatst online: 23:31

.oisyn

Moderator Devschuur®

Demotivational Speaker

killercow schreef op donderdag 14 juni 2007 @ 11:03:
[...]


Boom/array, in php is het werken met een array wat sneller handiger dan met een boom van objecten.
Doet er niet toe, de structuur is een boom, hoe je dat representeert boeit niet. Een array is geen boom (ja, of een root node met alleen maar N leaf nodes - jij hebt niet een array, jij hebt een hele structuur van arrays). Dit is toch een [Alg] topic, of heb ik nieuwe lenzen nodig? :)

(Overigens vind ik het discutabel om te zeggen dat werken met arrays in PHP handiger is. Ja, een boom is daardoor makkelijker te definieren in code, maar het algoritme dat ermee werkt leest allesbehalve prettig door alle blokhaken e.d.)
De takken worden in principe niet afgezaagd, maar worden gewoon tot aan de parent opgevuld met de zelfde blaadjes. (tot de botsing zeg maar)
Wat voor soort blaadjes dan, die van de parent?

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.


  • killercow
  • Registratie: Maart 2000
  • Laatst online: 28-11 15:56
.oisyn schreef op donderdag 14 juni 2007 @ 11:15:
[...]

Doet er niet toe, de structuur is een boom, hoe je dat representeert boeit niet. Een array is geen boom (ja, of een root node met alleen maar N leaf nodes - jij hebt niet een array, jij hebt een hele structuur van arrays). Dit is toch een [Alg] topic, of heb ik nieuwe lenzen nodig? :)

(Overigens vind ik het discutabel om te zeggen dat werken met arrays in PHP handiger is. Ja, een boom is daardoor makkelijker te definieren in code, maar het algoritme dat ermee werkt leest allesbehalve prettig door alle blokhaken e.d.)
True, de blokhaken maken het wat onduidelijk, maar een class met funcies is ook niet handigin psuedo code / php/
.oisyn schreef op donderdag 14 juni 2007 @ 11:15:
[...]

Wat voor soort blaadjes dan, die van de parent?
De blaadjes van de child, en deze mogen eventueel (maakt voor de structuur niet uit), ook op de net gesnoeide tak geplakt worden.

openkat.nl al gezien?


  • Grijze Vos
  • Registratie: December 2002
  • Laatst online: 28-02 22:17
Als je hier wel gewoon objecten gebruikt en een nette tree opbouwt, dan kun je je functies tenminste ook definieren over de nodes van je tree. Dat maakt het coden echt wel overzichtelijker (en inzichtelijker). Dat is waar Janoz (en .oisyn) op duiden.

Op zoek naar een nieuwe collega, .NET webdev, voornamelijk productontwikkeling. DM voor meer info


  • Janoz
  • Registratie: Oktober 2000
  • Nu online

Janoz

Moderator Devschuur®

!litemod

killercow schreef op donderdag 14 juni 2007 @ 11:18:
True, de blokhaken maken het wat onduidelijk, maar een class met funcies is ook niet handigin psuedo code / php/
Probeer het eens. Een class/struct is wel degelijk handig:

PHP:
1
2
3
4
5
6
class node{

  var $Children = Array();
  var $Parent;
  var $andereinformatie;
}

Bij elke functie kun je nu van een node uitgaan. Maakt niet uit of je in de root of ergens in je boom bent. ELK algoritme boek gebruikt dergelijke structuren. Maar goed, die zullen het wel op een onhandige manier doen dan.

Enige lastige aspect in php is dat je moet zorgen dat je de objecten by reference doorgeeft. Je zult dus even moeten kijken naar het gebruik van =& ed.


offtopic:
Misschien moet ik maar eens een php AAA oprichten... Anti Array Abuse..

Ken Thompson's famous line from V6 UNIX is equaly applicable to this post:
'You are not expected to understand this'


  • Grijze Vos
  • Registratie: December 2002
  • Laatst online: 28-02 22:17
Janoz schreef op donderdag 14 juni 2007 @ 13:12:
[...]


Probeer het eens. Een class/struct is wel degelijk handig:

PHP:
1
2
3
4
5
6
class node{

  var $Children = Array();
  var $Parent;
  var $andereinformatie;
}

Bij elke functie kun je nu van een node uitgaan. Maakt niet uit of je in de root of ergens in je boom bent. ELK algoritme boek gebruikt dergelijke structuren. Maar goed, die zullen het wel op een onhandige manier doen dan.

Enige lastige aspect in php is dat je moet zorgen dat je de objecten by reference doorgeeft. Je zult dus even moeten kijken naar het gebruik van =& ed.


offtopic:
Misschien moet ik maar eens een php AAA oprichten... Anti Array Abuse..
Ik zie nergens dat er specifiek PHP4 gebruikt wordt. Dus 'var' vervangen door 'public' danwel 'private'. En dat genezeul met &= hoeft ook niet meer sinds PHP5.

Op zoek naar een nieuwe collega, .NET webdev, voornamelijk productontwikkeling. DM voor meer info


  • Ciqniz
  • Registratie: Oktober 2002
  • Laatst online: 07-09-2023

Ciqniz

On the move...

Ik ben eigenlijk wel benieuwd wat je nou ECHT wilt... Een boom is ook zoiets... Ben je met een stamboom bezig? Personeelsleden? ...

  • Janoz
  • Registratie: Oktober 2000
  • Nu online

Janoz

Moderator Devschuur®

!litemod

Grijze Vos schreef op donderdag 14 juni 2007 @ 14:56:
Ik zie nergens dat er specifiek PHP4 gebruikt wordt. Dus 'var' vervangen door 'public' danwel 'private'. En dat genezeul met &= hoeft ook niet meer sinds PHP5.
Kan heel goed. Ik zit niet zo goed in php. Het is iig wel iets om even op te letten.

Ken Thompson's famous line from V6 UNIX is equaly applicable to this post:
'You are not expected to understand this'


  • killercow
  • Registratie: Maart 2000
  • Laatst online: 28-11 15:56
Ciqniz schreef op donderdag 14 juni 2007 @ 16:35:
Ik ben eigenlijk wel benieuwd wat je nou ECHT wilt... Een boom is ook zoiets... Ben je met een stamboom bezig? Personeelsleden? ...
Ik ben bezig met het parsen van html,
Ik moet blokken maken binnen de html,
Elk Element is een tak, de children zijn de childElements.

Een eerste pass loopt alles textNodes door om te zoeken naar steekwoorden (kleuren/vormen) en plaatst deze als "atribuut" in de boom.

Als er een td bijvoorbeeld "rood" bevat dan moet deze omhoog lopen tot en met de TR, want op de tbody botst hij met de volgende row in de table welke in zijn td de kleur "geel" heeft staan.

De combinatie maakt het iets lastiger kleur+vorm maar wel nuttiger, zo kunnen losse tr's netjes van elkaar gecheiden worden in plaats van dat ze een groot blok worden in plaats van losse blokjes.

openkat.nl al gezien?


  • Janoz
  • Registratie: Oktober 2000
  • Nu online

Janoz

Moderator Devschuur®

!litemod

Ikzelf zou zeggen, bouw het node object na zoals je dat ook in dom gebruikt. Met een child elements, properties en een parent en je kunt er keurig doorheen wandelen.

Ken Thompson's famous line from V6 UNIX is equaly applicable to this post:
'You are not expected to understand this'


  • killercow
  • Registratie: Maart 2000
  • Laatst online: 28-11 15:56
Janoz schreef op donderdag 14 juni 2007 @ 17:34:
Ikzelf zou zeggen, bouw het node object na zoals je dat ook in dom gebruikt. Met een child elements, properties en een parent en je kunt er keurig doorheen wandelen.
Die code heb ik inderdaad ook al gemaakt, ik kan nu redelijk simpel zelfs normale dom path's vertalen en de juiste node reference terug geven.

Dom manipulaten gaat nog niet zo goed, als ik een node probeer te verwijderen dan verwijderd ik alleen de reference er naar toe in plaats van de node zelf.

Anyway:
deze code lijkt te doen wat ik wil.
PHP:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
function walkup(&$DOM,$fields){
    $domcount=count($DOM);
    $fieldvalues=array();
    $i=0;
    while($i<$domcount){ // main loop, walk trough all childnodes on a level.
        if(is_array($DOM[$i])){
            // loop trough all the fields, and find if they are set.
            for($a=0;$a<count($fields);$a++){
                if(!is_array($fieldvalues[$fields[$a]])){
                    $fieldvalues[$fields[$a]]=array();
                }
                if(trim($DOM[$i][$fields[$a]])!=''){
                    
                    if(!in_array($DOM[$i][$fields[$a]],$fieldvalues[$fields[$a]])){
                        $fieldvalues[$fields[$a]][]=trim($DOM[$i][$fields[$a]]);
                    }
                }
            }
            if(isset($DOM[$i]['children'])){ // if this branch has subbranches walk trough them first.
                $subfieldvalues[$i]=walkup(&$DOM[$i]['children'],$fields);
                //echo '<hr />Children return:<br /><pre>';
                //print_r($subfieldvalues[$i]);
                //echo'</pre>';
                // check if any of the childs information either colides with this information, or supplements this node's info.
                // walk trough all needed values.

                $childcollision=false;
                $childdiffersfromparent=false;
                for($a=0;$a<count($fields);$a++){
                    // if any of the childs fields is coliding with a sibling, clean everything from here up to the roots.
                    if( count($subfieldvalues[$i][$fields[$a]])>1 ){
                        // detected collision for $fields[$a];
                        //echo 'detected collision for '. $fields[$a].'<br />';
                        $childcollision=true;
                    } elseif($DOM[$i][$fields[$a]]!='' && isset($subfieldvalues[$i][$fields[$a]][0]) && $DOM[$i][$fields[$a]]!=$subfieldvalues[$i][$fields[$a]][0]){
                        // child has different info than parent.
                        //echo 'A child contains different info than this node: '.$DOM[$i][$fields[$a]].'&isnot;'.$subfieldvalues[$i][$fields[$a]][0].'<br />';
                        //unset($DOM[$i][$fields[$a]]);
                        $childdiffersfromparent=true;
                    }
                }
                // now either propogate all fields, or destroy all fields up the stream.
                
                if($childcollision==true or $childdiffersfromparent==true){
                    //echo'Not propogating<br />';
                    for($a=0;$a<count($fields);$a++){
                        // strip all values from the current item.
                        unset($DOM[$i][$fields[$a]]);
                        $fieldvalues[$fields[$a]]=array_merge($fieldvalues[$fields[$a]],$subfieldvalues[$i][$fields[$a]]);
                    }
                } else {
                    //echo'Propogating<br />';
                    for($a=0;$a<count($fields);$a++){
                        if(isset($subfieldvalues[$i][$fields[$a]][0])){
                            $DOM[$i][$fields[$a]]=$subfieldvalues[$i][$fields[$a]][0];
                            if(!in_array($DOM[$i][$fields[$a]],$fieldvalues[$fields[$a]])){
                                $fieldvalues[$fields[$a]][]=trim($subfieldvalues[$i][$fields[$a]][0]);
                            }
                        }
                    }
                }
            }
        }
        $i++;
    }
    
    return $fieldvalues;
}

openkat.nl al gezien?

Pagina: 1