Disjunkt Set (Union-Find Algorithm) PHP-ben

Megjelent: 2025. február 16. 12:25:29 UTC

Ez a cikk a Disjoint Set adatstruktúra PHP-s implementációját mutatja be, amelyet általánosan használnak az Union-Findhez a minimális feszítőfa-algoritmusokban.

Ezt az oldalt angolból gépi fordítással készítettük, hogy minél több ember számára elérhető legyen. Sajnos a gépi fordítás még nem tökéletes technológia, ezért előfordulhatnak hibák. Ha szeretné, itt megtekintheti az eredeti angol nyelvű változatot:

Disjoint Set (Union-Find Algorithm) in PHP

A Disjunkt Set (általánosan használt Union-Find, más néven Disjoint Set Union) egy olyan adatstruktúra, amely az elemek diszjunkt (nem átfedő) halmazokra történő felosztásának kezelésére szolgál. Két kulcsfontosságú műveletet támogat hatékonyan:

Find : Meghatározza, hogy egy elem melyik halmazhoz tartozik.
Egyesülés : két halmazt egyesít.

Ez a struktúra különösen hasznos a minimális feszítőfa-algoritmusokban, mint például a Kruskal-algoritmus.

Van egy Kruskal-algoritmusom, amelyet véletlen labirintusok generálására használnak, és amely a Disjoint Set alábbi PHP-megvalósítására támaszkodik a halmazok hatékony egyesítése érdekében. Ha érdekel, itt megnézheted működés közben: Kruskal algoritmus labirintus generátora

Egyébként ez az én PHP implementációm a Disjoint Setről:

class DisjointSet 
{
    private $parent = [];
    private $rank   = [];

    public function __construct($size) 
    {
        for ($i = 0; $i < $size; $i++) 
        {
            $this->parent[$i]   = $i;
            $this->rank[$i]     = 0;
        }
    }

    public function find($x) 
    {
        if ($this->parent[$x] != $x) 
        {
            $this->parent[$x] = $this->find($this->parent[$x]);
        }

        return $this->parent[$x];
    }

    public function union($x, $y) 
    {
        $rootX = $this->find($x);
        $rootY = $this->find($y);

        if ($rootX != $rootY) 
        {
            if ($this->rank[$rootX] > $this->rank[$rootY]) 
            {
                $this->parent[$rootY] = $rootX;
            }
            elseif ($this->rank[$rootX] < $this->rank[$rootY]) 
            {
                $this->parent[$rootX] = $rootY;
    
            }
            else
            {
                $this->parent[$rootY] = $rootX;
                $this->rank[$rootX]++;
            }
        }
    }
}

Amellett, hogy mókás útvesztőket hoz létre, a Disjoint Set adatstruktúra minden bizonnyal valós forgatókönyvekhez is használható.

Képzeljünk el például egy közösségi hálózatot, amely új barátokat szeretne ajánlani a felhasználóinak, és akkor tegyük fel, hogy hat emberünk van már ilyen baráti kapcsolatokkal:

1 és 2 barátok.
2 és 3 barátok.
4 és 5 barátok.
6-nak nincsenek barátai.

Az Union-Find algoritmust ezekre a különálló csoportokra alkalmazva a következőket kell találnunk:

1, 2 és 3 egy csoportban.
4 és 5 egy második csoportban.
6 egy harmadik csoportban.

Ez alapján célszerű azt javasolni, hogy 1-es és 3-as legyen barátok, mert van bennük közös a 2. személy.

Természetesen egy ilyen kis példában könnyen észreveheti ezt a tényt, de ennek az algoritmusnak a hatékonysága lehetővé teszi, hogy több milliárd emberre és baráti csoportra terjedjen ki.