struct ed
{
    int wartosc;
    struct ed *prawy;
    struct ed *lewy;
    struct ed *rodzic;
};

typedef struct ed ed;

ed *min(ed *korzen)
{
    if (korzen -> lewy == NULL)
        return korzen;
    else
        korzen = min(korzen->lewy);
}

ed *max(ed *korzen)
{
    if (korzen -> prawy == NULL)
        return korzen;
    else
        korzen = max(korzen->prawy);
}

ed *dodaj(ed *korzen, int x)
{
    /* If the tree is empty return an empty node */
    if (korzen == NULL)
    {
        ed *q = (ed*)malloc(sizeof(ed));
        q -> wartosc = x;
        q -> lewy = NULL;
        q -> prawy = NULL;
        return q;
    }

    /* Otherwise, recur down the tree */
    if (x < korzen->wartosc)
    {
        korzen->lewy = dodaj(korzen->lewy, x);
        korzen->lewy->rodzic = korzen;
    }

    else if(x > korzen->wartosc)
    {
        korzen->prawy = dodaj(korzen->prawy, x);
        korzen->prawy->rodzic = korzen;
    }

    /* return the (unchanged) node pointer */
    return korzen;
}

ed *usun(ed* korzen, int x)
{
    if(korzen == NULL) return korzen;
    if(x < korzen->wartosc)
        korzen->lewy = usun(korzen->lewy, x);
    else if(x > korzen->wartosc)
        korzen->prawy = usun(korzen->prawy, x);
    else
    {
        if(korzen->lewy == NULL)
        {
            ed *tymczasowy = korzen->prawy;
            free(korzen);
            return tymczasowy;
        }
        else if(korzen->prawy == NULL)
        {
            ed *tymczasowy = korzen->lewy;
            free(korzen);
            return tymczasowy;
        }
         ed *tymczasowy = min(korzen->prawy);
         korzen->wartosc = tymczasowy->wartosc;
         korzen->prawy = usun(korzen->prawy, tymczasowy->wartosc);
    }
    return korzen;
}

ed *szukaj(ed *korzen, int x)
{
    if(korzen == NULL || korzen->wartosc == x)
        return korzen;
    if(korzen->wartosc < x)
        return szukaj(korzen->prawy, x);
    return szukaj(korzen->lewy, x);
}

void drukuj(ed *korzen, int spacje)
{
    if(korzen == NULL)
        return;
    int i;
    spacje += 10;
    drukuj(korzen->prawy, spacje);
    printf("\n");
    for(i=10; i<spacje; i++)
        printf(" ");
    printf("%d\n", korzen->wartosc);
    drukuj(korzen->lewy, spacje);
}

ed *poprzednik(ed *korzen)
{
    if(korzen->lewy)
        return max(korzen->lewy);
    else
    {
        while(korzen->rodzic && (korzen->rodzic->lewy == korzen))
            korzen = korzen->rodzic;
    }
    return korzen->rodzic;
}

ed *nastepnik(ed *korzen)
{
    if(korzen->prawy)
        return max(korzen->prawy);
    else
    {
        while(korzen->rodzic && (korzen->rodzic->prawy == korzen))
            korzen = korzen->rodzic;
    }
    return korzen->rodzic;
}

int ile_x(ed *korzen, int x) // zlicza liczbe x-ów w drzewie
{
    if(korzen == 0)
        return 0;
    int pom = 0;
    if(korzen->wartosc == x)
        pom = 1;
    return ile_x(korzen->lewy, x) + ile_x(korzen->prawy, x) + pom;
}

bool czy_te_same(ed *korzen_1, ed *korzen_2)
{
    if(korzen_1 == 0) // a¿ skoñczymy sprawdzaæ wartoœci 1 drzewa w 2 drzewie
        return true;
    if(ile_x(korzen_2, korzen_1->wartosc) > 0) // przeszukuje w drzewie nr 2 wartosci z 1 drzewa
        return czy_te_same(korzen_1->lewy, korzen_2) && czy_te_same(korzen_1->prawy, korzen_2);
    else
        return false;
}

int liczba_lisci(ed *korzen)
{
    if(korzen == NULL)
        return 0;
    if(korzen->lewy == NULL && korzen->prawy == NULL)
        return 1;
    else
        return liczba_lisci(korzen->lewy) + liczba_lisci(korzen->prawy);
}

void sumaLisci(ed *korzen, int *suma)
{
    if(korzen != NULL)
        return;
    if(korzen->lewy != NULL && korzen->prawy != NULL)
        *suma += korzen->wartosc;
    sumaLisci(korzen->lewy, suma);
    sumaLisci(korzen->prawy, suma);
}

int glebokosc(ed *korzen)
{
    if(korzen == NULL)
        return 0;
    else
    {
        int glebokoscL = glebokosc(korzen->lewy);
        int glebokoscR = glebokosc(korzen->prawy);
        if(glebokoscL > glebokoscR)
            return(glebokoscL + 1);
        else return(glebokoscR + 1);
    }
}

int liczebnosc(ed *korzen)
{
    if(korzen == NULL)
        return 0;
    else
        return(liczebnosc(korzen->lewy) + liczebnosc(korzen->prawy) + 1);
}

int liczebnosc(wsk T)
{
    if(T == NULL)
        return 0;
    else
        return(liczebnosc(T->lewy) + liczebnosc(T->prawy) + 1);
}

int wywazenie(wsk T) // roznica pomiedzy liczebnosciami lewego i prawego poddrzewa
{
    if(T == NULL)
        return 0;
    else
        return max(abs(liczebnosc(korzen->lewy) - liczebnosc(korzen->prawy)), wywazenie(korzen->lewy), wywazenie(korzen->prawy));
}

int wywazenie(wsk T) // roznica pomiedzy wysokosciami lewego i prawego poddrzewa
{
    if(T == NULL)
        return 0;
    else
        return max(abs(glebokosc(korzen->lewy) - glebokosc(korzen->prawy)), wywazenie(korzen->lewy), wywazenie(korzen->prawy));
}

int maxSzerokosc(ed *korzen)
{
    int maxSzer = 0;
    int szer;
    int w = glebokosc(korzen);
    int i;
    for(i=1; i<=w; i++)
    {
        szer = pobSzerokosc(korzen, i);
        if(szer > maxSzer)
            maxSzer = szer;
    }
    return maxSzer;
}

int pobSzerokosc(ed *korzen, int poziom)
{
    if(korzen == NULL)
        return 0;
    if(poziom == 1)
        return 1;
    else if(poziom > 1)
        return pobSzerokosc(korzen->lewy, poziom - 1) + pobSzerokosc(korzen->prawy, poziom - 1);
}

void lustrzane_odbicie(ed *korzen)
{
    if(korzen == NULL)
        return;
    else
    {
        ed *tymczasowy;
        lustrzane_odbicie(korzen->lewy);
        lustrzane_odbicie(korzen->prawy);
        tymczasowy = korzen->lewy;
        korzen->lewy = korzen->prawy;
        korzen->prawy = tymczasowy;
    }
}

int CzySaIdentyczne(ed *a, ed *b)
{
    if(a == NULL & b == NULL)
        return 1;
    if(a != NULL && b!= NULL)
    {
        return (a->wartosc == b->wartosc && CzySaIdentyczne(a->lewy, b->lewy) && CzySaIdentyczne(a->prawy, b->prawy));
    }
    return 0; // jesli jedno jest puste a drugie nie
}

int CzySaOdbiciemLustrzanym(ed *a, ed *b)
{
    if(a == NULL && b == NULL)
        return true;
    if(a == NULL || b == NULL)
        return false;
    return a->wartosc == b->wartosc && CzySaOdbiciemLustrzanym(a->lewy, b->prawy) && CzySaOdbiciemLustrzanym(a->prawy, b->lewy);
}

void drukLevel(ed *korzen)
{
    int w = glebokosc(korzen);
    int i;
    for(i=1; i<=w; i++)
    {
        drukujDanyLevel(korzen, i);
        printf("\n");
    }
}

void drukujDanyLevel(ed *korzen, int level)
{
    if(korzen == NULL)
        return;
    if(level == 1)
        printf("%d ", korzen->wartosc);
    else if(level > 1)
    {
        drukujDanyLevel(korzen->lewy, level - 1);
        drukujDanyLevel(korzen->prawy, level - 1);
    }
}

DFS

Mam listê s¹siadów, listê odwiedzonych oraz stos. Zaczynam w A. S¹siedzi A: B i S. Dodajê A do odwiedzonych oraz do stosu (na samym dole). Odwiedzam nieodwiedzonych s¹siadów tego elementu,
który jest na górze stosu (A). Nieodwiedzeni s¹siedzi: B i S. Dodajê B na górê stosu i do listy odwiedzonych. S¹siedzi B: brak. Nieodwiedzeni s¹siedzi B: brak. Usuwam B ze stosu. A jest
znowu na górze stosu. Nieodwiedzeni s¹siedzi A: S. Dodajê S na górê stosu i do listy odwiedzonych. S¹siedzi S: A, C i G. Nieodwiedzeni s¹siedzi S: C i G. Dodajê C na górê stosu i do listy odwiedzonych.
Itd...
/*Rysowanie: idziemy od pierwszego elementu w dó³, a¿ dojdziemy do elementu, który nie ma jako s¹siada nastêpnego elementu z odwiedzonych. Wtedy wracamy do góry, do pierwszego z kolei elementu,
który ma jako s¹siada nastêpny element z odwiedzonych. Wtedy tworzy siê rozwidlenie.*/
*********************************************************************************************************************************************************************************************

BFS

Mam listê s¹siadów, listê odwiedzonych oraz kolejkê. Zaczynam w A. Dodajê A do odwiedzonych. Pracujê na A. S¹siedzi A: B i S. Dodajê B i S do kolejki (od góry do do³u) oraz do listy odwiedzonych.
Teraz pracujê na pierwszym elemencie kolejki: B. Zdejmujê B z kolejki. S¹siedzi B: A. A ju¿ by³o odwiedzone. Teraz pracujê na S. Zdejmujê S z kolejki. S¹siedzi S: A, C i G. Nieodwiedzeni
s¹siedzi S: C i G. Dodajê C i G do kolejki i do listy odwiedzonych. Teraz pracujê na C. Zdejmujê C z kolejki. S¹siedzi C: D, E, F i S. Nieodwiedzeni s¹siedzi C: D, E i F. Dodajê D, E i F
do kolejki (pod G) i do listy odwiedzonych. Teraz pracujê na G... itd.
/*Rysowanie: idziemy od pierwszego elementu i w drugiej linii dodajemy tyle elementów, ile on ma s¹siadów. Nastêpnie tak samo.*/