izbacivanje duplikata iz liste uz pomoc hash tabele

Code:

//esmain.cpp

#include <stdlib.h>
#include <iostream>

using namespace std;

struct Cvor {
    int broj;
    Cvor *sljedeci;
};

struct HashZapis {
    Cvor *pok;
    HashZapis *sljedeci;
};

#define VELICINA_TABELE 100

unsigned int hash(int vrednost) {
  return abs(vrednost) % VELICINA_TABELE;
}

HashZapis *hashTabela[VELICINA_TABELE];

/*
prethodnik[in] - pokazivac na element u listi koji je prethodnik elementu koji zelimo da obrisemo
*/
Cvor *obrisiElementIzListe(Cvor *prethodnik) {
    if(prethodnik == 0) return 0;//Ne zelimo da ispadnemo budale, te ako je argument NULL pointer, sa prezirom cemo izignorisati celu operaciju.
    Cvor *zaBrisanje = prethodnik->sljedeci;
    if(zaBrisanje == 0) return 0; //ovo je kraj liste, trazeni element ni ne postoji ili je u pitanju neka greska.
    prethodnik->sljedeci = zaBrisanje->sljedeci;//prevezujemo elemente liste
    free(zaBrisanje);//ili delete zaBrisanje - vidi 3. b)
    return zaBrisanje;
}

int dajVrednostPodatka(HashZapis *zapis) {
    if(zapis == 0) return 0;
    Cvor *prethodnik = zapis->pok;
    if(prethodnik == 0) return 0;
    if(prethodnik->sljedeci == 0) return 0;
    //ok, sada mozemo da dohvatimo podatak
    return prethodnik->sljedeci->broj;
}

HashZapis *dajRedIzHashTabele(int kljuc) {
    unsigned int indeks = hash(kljuc);
    HashZapis *rezultat = hashTabela[indeks];
    return rezultat;
}
/*
elementUHashTabeli[in] - hash zapis elementa cije duplikate valja zatuci.
return broj obrisanih elemenata
*/
unsigned int izbaciDuplikate(HashZapis *elementUHashTabeli) {
    if(elementUHashTabeli == 0) return 0;
    unsigned int rezultat = 0;
    int kljuc = dajVrednostPodatka(elementUHashTabeli);
    HashZapis *prethodni = elementUHashTabeli;//trebace nam za brisanje duplikata iz Hash tabele
    elementUHashTabeli = elementUHashTabeli->sljedeci;//prvi posle originala
    while(elementUHashTabeli) {
        if(kljuc == dajVrednostPodatka(elementUHashTabeli)) {
            //duplikat - obrisacemo ga
            Cvor *previous = elementUHashTabeli->pok;
            Cvor *obrisani = obrisiElementIzListe(previous);
            //medjutim, sada je za element koji dolazi posle obrisanog
            //potrebno promeniti hash zapis, tako da ovaj ukazuje na novog prethodnika.
            Cvor *zaAzuriranje = previous->sljedeci;
            if(zaAzuriranje != NULL) {
                unsigned int indeks = hash(zaAzuriranje->broj);
                HashZapis *hashAzuriranog = hashTabela[indeks];
                while(hashAzuriranog) {
                    if(hashAzuriranog->pok == obrisani) {
                        hashAzuriranog->pok = previous;
                        break;
                    }
                    hashAzuriranog = hashAzuriranog->sljedeci;
                }
            }
            //sada da izbacimo i ovaj hash zapis za obrisani element
            prethodni->sljedeci = elementUHashTabeli->sljedeci;
            free(elementUHashTabeli);//ili delete elementUHashTabeli;
            ++rezultat;
        } else {
            prethodni = elementUHashTabeli;
        }
        elementUHashTabeli = prethodni->sljedeci;
    }
    return rezultat;
}


void napraviTabelu(Cvor *headListe) {
    //inicijalizacija
    for(int i = 0; i < VELICINA_TABELE; ++i) {
        hashTabela[i] = NULL;
    }
    //glavna prica
    cout << "Pravljenje tabele" << endl;
    if(headListe == NULL) return;
    Cvor *prethodni = headListe;
    Cvor *zaObradu = headListe->sljedeci;
    while(zaObradu) {
        HashZapis *zapis = (HashZapis *) malloc(sizeof(HashZapis));
        zapis->pok = prethodni;
        unsigned int indeks = hash(zaObradu->broj);
        HashZapis *sledeci = hashTabela[indeks];
        zapis->sljedeci = sledeci;
        hashTabela[indeks] = zapis;
        prethodni = zaObradu;
        zaObradu = zaObradu->sljedeci;
    }
    return;
}

void pisiListu(Cvor *headListe) {
    if(headListe == NULL) return;
    Cvor *element = headListe->sljedeci;
    cout << "Sadrzaj liste:" << endl;
    while(element) {
        cout << element->broj << ", ";
        element = element->sljedeci;
    }
    cout << endl;
}

int main() {
    Cvor head;
    head.sljedeci = NULL;
    int niz[30] = {
            7, 9, 12, 347, 283, 25, 1200, 3047, 400, 83,
            7, 9, 12, 347, 283, 25, 1200, 3047, 400, 83,
            7, 9, 12, 347, 283, 25, 1200, 3047, 400, 83
    };
    for(int i = 0; i < 30; ++i) {//Ovo sve je sada da napravimo nekakvu test listu sa duplikatima
        Cvor *novi = (Cvor *) malloc(sizeof(Cvor));
        novi->broj = niz[i];
        novi->sljedeci = head.sljedeci;
        head.sljedeci = novi;
    }
    pisiListu(&head);
    cout << "Izbacujem duplikate" << endl;
    napraviTabelu(&head);

    for(unsigned int i = 0; i < 100; ++i) {
        HashZapis *trenutni = hashTabela[i];
        while(trenutni != NULL) {
            unsigned n = izbaciDuplikate(trenutni);
            cout << "Izbacio " << n << " elemenata sa vrednoscu " << dajVrednostPodatka(trenutni) << endl;
            pisiListu(&head);
            trenutni = trenutni->sljedeci;
        }


    }
    cout << "Na kraju je" << endl;
    pisiListu(&head);
}