[ demon_01 @ 01.09.2010. 18:07 ] @
pozz ljudi trebao bih malu pomoc..
ovako treba mi funkcija za brisanje duplikata iz liste uz pomoc hash tabele,
imam
struct Cvor{
int broj;
Cvor *sljedeci;};
i
struct HashZapis{
Cvor *pok;
HashZapis *sljedeci;};

funkcija treba proci kroz listu i premjestit podatke u hash tabelu, nakon hashiranja pokazivac broja u hash tabeli mora pokazivat na broj u listi, ako moze neko nek pomaze... Hvala
[ Goran Rakić @ 01.09.2010. 18:10 ] @
Kako si ti pokušao da rešiš? Razmisli čemu služi hash tabela i šta se dešava kada imaš dva ista.
[ Mihajlo Cvetanović @ 01.09.2010. 18:56 ] @
Ova klasa HashZapis nije dovoljna za implementaciju heš tabele. Potrebno je da postoji - heš tabela. To bi recimo bio jedan veliki niz pointera na HashZapis objekte, a indeks ovog niza je zapravo vrednost heš funkcije. Ovo je pod pretpostavkom da predavač zna šta je heš tabela. Jbg, možda ne zna. Možda heš "tabela" treba da izgleda drugačije. Vrednost heš funkcije se dobija na osnovu vrednosti int broj za svaki čvor. Znači, algoritam bi bio sledeći: dok ideš kroz listu za svaki član liste konstruišeš odgovarajući član u heš tabeli, a ako takav član već postoji onda član ne konstruišeš u heš tabeli nego ga brišeš iz originalne liste. I tako do kraja.

Konstruisanje člana u heš tabeli podrazumeva računanje heša, i potraga mini liste pod indeksom u tabeli čija je vrednost upravo taj heš. U mini listi gledamo sve čvorove gledajući da li neki sadrži onaj broj koji pokušavamo da ubacimo. Ako sadrži onda imamo duplikat.

Brisanje čvora iz originalne liste se radi tako što moramo da imamo prethodni čvor pri ruci. Polje sljedeci od tog prethodnog čvora mora da "preskoči" trenutni čvor, i da počne da pokazuje na onaj sledeći u listi. Trenutni čvor tek tada smemo da obrišemo iz memorije.

Ovo sve zajedno nije trivijalan domaći zadatak, to jest nije trivijalan za nekog ko to trenutno uči, a bogme ni meni možda ne bi iz prve proradio. Pošto nije trivijalno mora da je predavač objašnjavao šta i kako treba da se radi. Da li je?
[ demon_01 @ 01.09.2010. 21:36 ] @
void Hashiraj(Cvor *glava,Hash *glavaHash){
if(glava==NULL)
cout<<"prazna lista"<<endl;
else{
Cvor *temp2,*dup;
Cvor *temp=glava;
Hash *temp1=glavaHash;

while (temp->sljedeci !=NULL){
temp2=temp;
while (temp2->sljedeci !=NULL){
if(temp->broj==temp2->sljedeci->broj){
dup=temp2->sljedeci;
temp2->sljedeci = temp2->sljedeci->sljedeci;
free(dup);
}
else{
temp2=temp2->sljedeci;
}
}
temp=temp->sljedeci;
}
while(temp!=NULL){
pok=pok->sljedeci;
pok=glavaHash


} } }

ewo ovako sam ja pokusao medjutim nisam uspio ja mogu lako izbacit duplikat al ja u sustini trebam heshirat listu i ispisat je heshiranu tj bez duplikata
[ demon_01 @ 01.09.2010. 21:38 ] @
pa od profesora sam dobio ove dvije strukture i rekao mi je da je to dovoljno da se uradi zadatak... moram to predati ako hocu na ispit a nikako da mi uspije
[ Goran Rakić @ 01.09.2010. 22:00 ] @
Možda ovako nešto? Ova struktura nema mogućnost direktnog pristupa tako da će pretraga po "hash listi" biti linearna. Zavisno koliko pametno napišeš funkciju hashtable_set() možeš da imaš spoljne direktne pokazivače na neki deo liste (tada bi HashTable sadržala ove pokazivače plus pokazivač na prvi HashZapis). U tom slučaju bi hashtable_get() mogla da bude efikasnija. Kada izgradiš listu, pošto ne definišeš slučaj za koliziju (samo preskačeš duplikate), dovoljno je da ispišeš sadržaj liste čvorova koji grade HashTable.

Code (c):

/* racuna hash elementa kao int */
int cvor_get_hash(Cvor *c) {
  return c->broj;
}

/* tabela je povezana lista, mozda neopadajuce uredjena po hashu */
typedef HashZapis HashTable;

/* pronadji cvor u "hash tabeli". nemamo nikakvu visu strukturu
    za direktni pristup pa je ovo prosta iteracija. Funkcija je ovde reda radi. */
Cvor* hashtable_get(HashTable *h, int hash) {
  HashZapis *i = (HashZapis*) h;
  while(i != NULL) {
    int i_hash = cvor_get_hash(i->pok);
    /* ako je poredjano neopadajuće: if(i_hash < hash)  break; */
    if(i_hash == hash) return i;
    i = i->sljedeci;
  }
  return NULL;
}

/* ubaci cvor u "hash tabelu", mozes, a ne moras da cuvas uredjenje */
/* vraca NULL ako vec postoji inace pronalazi mesto za hash i ubacuje ga u listu */
void hashtable_set(HashTable **h, Cvor *c) {
  ...
}

/* Ubacuje cvorove u "hash tabelu" */
HashTable* hashtable_build(Cvor *c) {
  HashTable *h = (HashTable*) malloc(sizeof(HashTable));
  while(c != NULL) {
    hashtable_set(&h, c); /* ovde ce da preskoci dupla dodavanja */
    c = c->sljedeci;
  }
}
 


Ako hoćeš i da zaista obrišeš element iz polazne liste onda pre hashtable_set() pozovi hashtable_get() i ako ga ima (nije NULL), obriši element.

Korisno je da za početak napraviš opšte funkcije ubacivanje elementa posle određenog (nađi taj prethodni, uzmi njegov sledeći, spoji prethodni na novi, i potom novi na sledeći koji si zapamtio) i brisanje elementa iz liste (nađi koji treba obrisati, zapamti prethodni, uzmi sledeći, poveži prethodni na sledeći i onda obriši).

[Ovu poruku je menjao Goran Rakić dana 01.09.2010. u 23:11 GMT+1]
[ demon_01 @ 02.09.2010. 12:48 ] @
ne razumijem ja ovaj kod tvoj nikako, sta trebam unijet u funkciju hashtable_set??
[ demon_01 @ 04.09.2010. 15:45 ] @
na koji nacin cu ja kad prolazim kroz listu prebacivat jedan po jedan clan u hash tabelu???
[ demon_01 @ 04.09.2010. 16:05 ] @
[quote]Goran Rakić: Možda ovako nešto? Ova struktura nema mogućnost direktnog pristupa tako da će pretraga po "hash listi" biti linearna. Zavisno koliko pametno napišeš funkciju hashtable_set() možeš da imaš spoljne direktne pokazivače na neki deo liste (tada bi HashTable sadržala ove pokazivače plus pokazivač na prvi HashZapis). U tom slučaju bi hashtable_get() mogla da bude efikasnija. Kada izgradiš listu, pošto ne definišeš slučaj za koliziju (samo preskačeš duplikate), dovoljno je da ispišeš sadržaj liste čvorova koji grade HashTable.

Code (c):

/* racuna hash elementa kao int */
int cvor_get_hash(Cvor *c) {
  return c->broj;
}

/* tabela je povezana lista, mozda neopadajuce uredjena po hashu */
typedef HashZapis HashTable;

/* pronadji cvor u "hash tabeli". nemamo nikakvu visu strukturu
    za direktni pristup pa je ovo prosta iteracija. Funkcija je ovde reda radi. */
Cvor* hashtable_get(HashTable *h, int hash) {
  HashZapis *i = (HashZapis*) h;
  while(i != NULL) {
    int i_hash = cvor_get_hash(i->pok);
    /* ako je poredjano neopadajuće: if(i_hash < hash)  break; */
    if(i_hash == hash) return i;
    i = i->sljedeci;
  }
  return NULL;
}

/* ubaci cvor u "hash tabelu", mozes, a ne moras da cuvas uredjenje */
/* vraca NULL ako vec postoji inace pronalazi mesto za hash i ubacuje ga u listu */
void hashtable_set(HashTable **h, Cvor *c) {
  ...
}

/* Ubacuje cvorove u "hash tabelu" */
HashTable* hashtable_build(Cvor *c) {
  HashTable *h = (HashTable*) malloc(sizeof(HashTable));
  while(c != NULL) {
    hashtable_set(&h, c); /* ovde ce da preskoci dupla dodavanja */
    c = c->sljedeci;
  }
}
 


Ako hoćeš i da zaista obrišeš element iz polazne liste onda pre hashtable_set() pozovi hashtable_get() i ako ga ima (nije NULL), obriši element.

Korisno je da za početak napraviš opšte funkcije ubacivanje elementa posle određenog (nađi taj prethodni, uzmi njegov sledeći, spoji prethodni na novi, i potom novi na sledeći koji si zapamtio) i brisanje elementa iz liste (nađi koji treba obrisati, zapamti prethodni, uzmi sledeći, poveži prethodni na sledeći i onda obriši).







cannot convert HashZapis to Cvor i return.... tu mi gresku javlja sta trebam uraditi??
[ Goran Rakić @ 04.09.2010. 16:07 ] @
Izmeni
if(i_hash == hash) return i;
u
if(i_hash == hash) return i->pok;

Funkcija treba da vraća Cvor* smešten u zapis, a ne sam zapis iz hash "tabele". Kompilator ti je sigurno napisao tačnu liniju u kojoj je greška, da si malo pogledao i sam bi rešio.
[ demon_01 @ 04.09.2010. 16:22 ] @
Citat:
Goran Rakić: Izmeni
if(i_hash == hash) return i;
u
if(i_hash == hash) return i->pok;

Funkcija treba da vraća Cvor* smešten u zapis, a ne sam zapis iz hash "tabele". Kompilator ti je sigurno napisao tačnu liniju u kojoj je greška, da si malo pogledao i sam bi rešio.
Citat:
Goran Rakić: Izmeni
if(i_hash == hash) return i;
u
if(i_hash == hash) return i->pok;

Funkcija treba da vraća Cvor* smešten u zapis, a ne sam zapis iz hash "tabele". Kompilator ti je sigurno napisao tačnu liniju u kojoj je greška, da si malo pogledao i sam bi rešio.




a jeste ali ja sam samo pocetnik pa se ne razumijem bas... hvala ti puno ali svejedno ja opet nemogu sam ovo zavrsit ne znam kako dovrsit ovu funkciju hashtable_set
[ demon_01 @ 05.09.2010. 00:38 ] @





ajd dovrsi mi jos tu funkciju molim te
[ demon_01 @ 05.09.2010. 00:40 ] @
Citat:
Goran Rakić: Izmeni
if(i_hash == hash) return i;
u
if(i_hash == hash) return i->pok;

Funkcija treba da vraća Cvor* smešten u zapis, a ne sam zapis iz hash "tabele". Kompilator ti je sigurno napisao tačnu liniju u kojoj je greška, da si malo pogledao i sam bi rešio.







ajd dovrsi mi jos tu funkciju pa da to predam... molim te
[ Goran Rakić @ 05.09.2010. 01:00 ] @
Nauči pre nego što predaš. Zapravo, ni ovo što sam ti do sada poslao uopšte nije tačno.
[ VladimirCDT @ 05.09.2010. 10:26 ] @
@demon_01

Pravo da ti kazem, kada sam video zadatak i procitao da je profa rekao kako je ovo dovoljno, pomislio sam da ja u stvari ne znam sta je hash. Ali dobro, onda sam malo razmislio.

Ovde ima nekoliko mogucih i dovoljno dobrih resenja, a prva podela medju resenjima zavisi od toga da li koristimo C ili C++. Delovi koda koji se ovde vide uglavnom upucuju na C, osim koriscenja "cout <<" sto upucuje na C++.

Nego, da analiziramo problem.

1. struct Cvor nam govori da se radi o jednostruko ulancanoj listi. Ovo je vrlo bitno da se uzme u obzir jer od toga zavisi algoritam izbacivanja elemenata iz liste, a isto tako i algoritam ubacivanja u hash listu kao i definicija na sta pokazuje atribut pok u strukturi HashZapis. Da pojasnim: da bi se uspesno izbacio element iz jednostruko ulancane liste, potrebno je imati pokazivac na prethodni element u listi; da bi to bilo moguce, HashZapis za dati kljuc mora da pokazuje na element koji prethodi elementu na koji se odnosi taj hash zapis.
Ovo ima jos jednu posledicu: prvi element u listi mora bit tzv. head, dakle Cvor kojem je jedina uloga da predstavlja vrh liste, ali ne i da nosi korisan podatak (broj). Ili to, ili da se NULL pointeri koriste kao nekakvi indikatori, sto nije bas najzdravije resenje.

2. Hash tabela, kao i hash funkcija nisu definisani postavkom zadatka. To znaci da cemo napisati resenje koje podrazumeva da su negde tabela i funkcija definisani, a kasnije mozemo da predlozimo jedno razumno resenje za te dve stvari.

3. Brisanje elemenata iz liste koji su prethodno dinamicki alocirani moze se vrsiti ili:
a) samo pozivom funkcije free(), ukoliko je u pitanju jezik C;
b) pozivom funkcije free(), ako je objekat alociran sa malloc, calloc itd, a brisace se operatorom delete ukoliko je predhodno alociran sa new, u slucaju da koristimo C++.

Da predjemo na resenje:

Prvo cemo napisati funkciju koja brise element iz jednostruko ulancane liste. Kao sto je gore napomenuto, da bi to uradili kako treba, potrebno je da imamo pokazivac na prethodni Cvor u listi, tj. Cvor koji sadrzi pokazivac na element koji zelimo da obrisemo. Razlog za to je jednostavan: kada budemo izbrisali Cvor koji zelimo, moramo Cvor koji dolazi posle njega da povezemo na Cvor koji mu je prethodio.

Code:

/*
prethodnik[in] - pokazivac na element u listi koji je prethodnik elementu koji zelimo da obrisemo
*/
void obrisiElementIzListe(Cvor *prethodnik) {
if(prethodnik == 0) return;//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; //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;// moze, a i ne mora da stoji
}

Napomena: ova funkcija je mogla da vraca neki rezultat, npr. tipa int, koji bi predstavljao kod greske u slucajevima da je argument funkcije 0 (NULL), ili da je zaBrisanje == 0. Priroda ovog problema je takva da se moze reci da su te situacije nemoguce, te da su one dve provere na NULL suvisne. Medjutim, dobra praksa defanzivnog programiranja, a posebno rada na projektima koje razvija citav tim (ili nekoliko timova), nalaze da se ovakve provere uredno vrse, jer nikad ne znas sta neko moze da prosledi tvojoj funkciji.

Da se sada pozabavimo nalazenjem odgovarajuceg hash zapisa, izbacivanjem tog zapisa iz tabele i uklanjanjem elementa na koji se taj hash zapis odnosi. Kao sto je ranije receno, ovaj hash zapis ce pokazivati na prethodnika elementa u glavnoj listi, na kojeg se zapis odnosi.

Hash tabela je zapravo niz mini-lista koje sadrze elemente za koje hash funkcija daje isti rezultat. Deklarisacemo funkciju koja nam daje pokazivac na prvi element jedne takve mini-liste (reda) u hash tabeli.

Code:
HashZapis *dajRedIzHashTabele(int kljuc);


U postavci zadatka postoji jedan problem, a to je da HashZapis ne sadrzi vrednost podatka na koji se odnosi, a to je nesto sto ce nam biti potrebno. Napisacemo jednu malu funkciju koja ce vratiti taj podatak za dati HashZapis. Napomena: razne provere na NULL koje su mozda i suvisne u ovom zadatku, ipak cemo pisati iz navedenih razloga kao i u gornjem kodu. Zbog prirode int-a i nedefinisanog opsega vrednosti za podatke, imamo problem da prijavimo gresku u ovim slucajevima. Ukoliko bi ovo bio C++, imali bismo mogucnost da bacimo exception, ali sada to necemo raditi, vec cemo se samo braniti od nedozvoljenih pristupa memoriji.

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


Sada cemo napisati funkciju koja ce na osnovu reda u hash tabeli da pronadje nase duplikate i da izbaci, cuvajuci samo jedan element sa zadatim kljucem. Iz fazona cemo dati da ta funkcija kao rezultat vrati broj obrisanih elemenata.

Code:

/*
kljuc[in] - kljuc koji se odnosi na elemente cije duplikate valja izbaciti
return broj obrisanih elemenata
*/
unsigned int izbaciDuplikate(int kljuc) {
unsigned int rezultat = 0;
HashZapis *redUHashTabeli = dajRedIzTabele(kljuc);
if(redUHashTabeli == 0) return 0;
//trazimo original
while(redUHashTabeli) {
if(kljuc == dajVrednostPodatka(redUHashTabeli)) break;//nasli smo ga
redUHashTabeli = redUHashTabeli->sljedeci;
}

if(redUHashTabeli == 0) return 0;//nismo nasli ni original
HashZapis *prethodni = redUHashTabeli;//trebace nam za brisanje duplikata iz Hash tabele
redUHashTabeli = redUHashTabeli->sljedeci;//prvi posle originala
while(redUHashTabeli) {
if(kljuc == dajVrednostPodatka(redUHashTabeli)) {
//duplikat - obrisacemo ga
obrisiElementIzListe(redUHashTabeli->pok);
//sada da izbacimo i ovaj hash zapis
prethodni->sljedeci = redUHashTabeli->sljedeci;
free(redUHashTabeli);//ili delete redUHashTabeli;
++rezultat;
} else {
prethodni = redUHashTabeli;
}
redUHashTabeli = prethodni->sljedeci;
}
return rezultat;


To bi sada trebalo da bude to.

Hajde da vidimo i neki predlog za realizaciju ove hash tabele i hash funkciju.

U principu, potreban nam je neki vektor ovih mini lista ciji elementi imaju istu vrednost hash funkcije.
Sama vrednost "broj" koja se javlja u strukturi Cvor, nepodesna je iz dva razloga: int moze biti i negativan, a to nije dozvoljena vrednost indeksa za vektore; int pokriva ogroman broj vrednosti i toliki vektor nam nije realan za implementaciju. Dakle, potreban nam je vektor ogranicene velicine, neka to bude neka vrednost VELICINA_TABELE.

Takodje, potrebna nam je i nekakva hash funkcija koja bi odgovarala int-u. U tom smislu, potrebna nam je takva funkcija koja ce dati dobru raspodelu kljuceva, ali i koja ce biti jednostavna za racunanje da ne bismo izgubili na smislu hashiranja. Rezultat funkcije mora biti ulaz u tabelu, dakle nenegativan broj. Dovoljno dobro resenje za postavku ovog zadatka bi bila sledeca hash funkcija:

Code:
#define VELICINA_TABELE 100

unsigned int hash(int vrednost) {
  return abs(vrednost) % VELICINA_TABELE;
}
(Kompajler ce ovde verovatno da izbaci beznacajno upozrenje).

Na ovaj nacin, sama tabela se konstruise sa:

Code:

HashZapis *hashTabela[VELICINA_TABELE];


E sada, ja ovo nisam ni kompajlirao, a kamo li testirao. Bez obzira sto bih da licim na C, ima ovde nekih momenata koji su rezervisani za C++.
Ako i ima neka greska, jbg. ali ovo razumi i kao neke guide lines.

[Ovu poruku je menjao Mihajlo Cvetanović dana 05.09.2010. u 12:26 GMT+1]
[ VladimirCDT @ 05.09.2010. 11:08 ] @
Ah, da, potrebno je jos i napraviti hash tabelu.

Code:

HashZapis *hashTabela[VELICINA_TABELE];

void napraviTabelu(Cvor *headListe) {
//inicijalizacija
for(int i = 0; i < VELICINA_TABELE; ++i) {
hashTabela[i] = NULL;
}
//glavna prica
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;
}


Eto, tako...
[ demon_01 @ 05.09.2010. 14:13 ] @
Citat:
VladimirCDT: Ah, da, potrebno je jos i napraviti hash tabelu. :)

Code:

HashZapis *hashTabela[VELICINA_TABELE];

void napraviTabelu(Cvor *headListe) {
//inicijalizacija
for(int i = 0; i < VELICINA_TABELE; ++i) {
hashTabela[i] = NULL;
}
//glavna prica
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;
}


Eto, tako...












Cvor *prethodnik = zapis->sljedeci;


Cvor *prethodnik = zapis->sljedeci->pok;


ovo sam promjenio jer je javljalo gresku cannot convert `HashZapis*' to ` Cvor*' in initialization
jel to uredu??
a sad imam novu gresku [Linker error] undefined reference to `dajRedIzHashTabele(int)'
sta sad da radim??
HVALA
[ VladimirCDT @ 05.09.2010. 16:45 ] @
Citat:
demon_01: Cvor *prethodnik = zapis->sljedeci;


Cvor *prethodnik = zapis->sljedeci->pok;


ovo sam promjenio jer je javljalo gresku cannot convert `HashZapis*' to ` Cvor*' in initialization
jel to uredu??
a sad imam novu gresku [Linker error] undefined reference to `dajRedIzHashTabele(int)'
sta sad da radim??
HVALA

E, izvini, bio sam savrseno neispavan jutros kada me je dete probudilo, a sve sam pisao direktno ovde na forum, pa nisam porveravao ovakve glupe greske.
Mislim da bi valjalo da stoji:

Cvor *prethodnik = zapis->pok->sljedeci.

Dalje, na jednom mestu sam napisao:
HashZapis *redUHashTabeli = dajRedIzTabele(kljuc);
umesto
HashZapis *redUHashTabeli = dajRedIzHashTabele(kljuc);

Inace, linker se sa pravom buni, jerbo nigde nismo ni definisali tu funkciju. Evo kako bi ona izgledala:
Code:

HashZapis *dajRedIzHashTabele(int kljuc) {
unsigned int indeks = hash(kljuc);
HashZapis *rezultat = hashTabela[indeks];
return rezultat
}


Kao sto vidis, te dve linije koda se javljaju i u napraviTabelu(), pa mozes i tamo da je pozoves umesto te dve linije.

Kazem ti, malo sam ovo pisao nepriseban, pa nije ni cudo ako ima bugova. U svakom slucaju, napisi neki mali testic, pa ces videti ako ima gresaka.
Celu pricu je profa zakomplikovao zbog koriscenja jednostruko ulancane liste, ali kapiram da mu je cilj da vas propita i baratanjem takvim listama, a istovremeno i primenu hashinga.
[ demon_01 @ 05.09.2010. 18:07 ] @
Citat:
VladimirCDT: E, izvini, bio sam savrseno neispavan jutros kada me je dete probudilo, a sve sam pisao direktno ovde na forum, pa nisam porveravao ovakve glupe greske.
Mislim da bi valjalo da stoji:

Cvor *prethodnik = zapis->pok->sljedeci.

Dalje, na jednom mestu sam napisao:
HashZapis *redUHashTabeli = dajRedIzTabele(kljuc);
umesto
HashZapis *redUHashTabeli = dajRedIzHashTabele(kljuc);

Inace, linker se sa pravom buni, jerbo nigde nismo ni definisali tu funkciju. Evo kako bi ona izgledala:
Code:

HashZapis *dajRedIzHashTabele(int kljuc) {
unsigned int indeks = hash(kljuc);
HashZapis *rezultat = hashTabela[indeks];
return rezultat
}


Kao sto vidis, te dve linije koda se javljaju i u napraviTabelu(), pa mozes i tamo da je pozoves umesto te dve linije.

Kazem ti, malo sam ovo pisao nepriseban, pa nije ni cudo ako ima bugova. U svakom slucaju, napisi neki mali testic, pa ces videti ako ima gresaka.
Celu pricu je profa zakomplikovao zbog koriscenja jednostruko ulancane liste, ali kapiram da mu je cilj da vas propita i baratanjem takvim listama, a istovremeno i primenu hashinga.







ajoj cuj izvini,trebam se ja izvinut sto gnjavim uvjek...
napravio sam test kod je prosao ali program ne radi kako bi trebao vjerovatno sam ja nesto pogresno pozvao u mainu
na koji nacin cu sad hashirat listu?? i da li je ova funkcija tacna za ispis liste??


void ispisiTabelu(){


for (int i=0;i<VELICINA_TABELE;i++)

cout<<hashTabela;}




[ demon_01 @ 05.09.2010. 18:49 ] @
evo ovako sam ja pokusao

case 3:{
for(int i = 0; i < VELICINA_TABELE; ++i) {
izbaciDuplikate(i);
}
napraviTabelu();
break;

}
case 4:{
int k;
cout<<"unesi kljuc"<<endl;
cin>>k;
cout<<"vrijednost tog kljuca je"<<dajVrednostPodatka(hashTabela[k]);
break;
}

kada izaberem opciju 3 vrati me na meni a kad odaberem opciju 4 ispise mi 0, znaci da ne unosi nista u tabelu
sta sad da radim??
[ demon_01 @ 05.09.2010. 19:02 ] @
#include<iostream>
using namespace std;

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

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

Cvor *headListe=NULL;

Cvor *iniCvor(int br) {
Cvor *novi=new Cvor();
novi->broj=br;
novi->sljedeci=NULL;
return novi;
}
#define VELICINA_TABELE 100

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

HashZapis *hashTabela[VELICINA_TABELE];

void dodajUlistu(Cvor *novi) {
if(headListe==NULL)
headListe=novi;
else {
novi->sljedeci=headListe;
headListe=novi;
}
}

void ispisListe() {
if(headListe==NULL)
cout<<"Prazna lista."<<endl;
else {
Cvor *temp=headListe;
while(temp!=NULL) {
cout<<temp->broj;
temp=temp->sljedeci;
}
}
}



/*
prethodnik[in] - pokazivac na element u listi koji je prethodnik elementu koji zelimo da obrisemo
*/
void obrisiElementIzListe(Cvor *prethodnik) {
if(prethodnik == 0) return;//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; //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;// moze, a i ne mora da stoji
}




int dajVrednostPodatka(HashZapis *zapis) {
if(zapis == 0) return 0;
Cvor *prethodnik = zapis->pok->sljedeci;
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;
}


/*
kljuc[in] - kljuc koji se odnosi na elemente cije duplikate valja izbaciti
return broj obrisanih elemenata
*/
unsigned int izbaciDuplikate(int kljuc) {
unsigned int rezultat = 0;
HashZapis *redUHashTabeli = dajRedIzHashTabele(kljuc);
if(redUHashTabeli == 0) return 0;
//trazimo original
while(redUHashTabeli) {
if(kljuc == dajVrednostPodatka(redUHashTabeli)) break;//nasli smo ga
redUHashTabeli = redUHashTabeli->sljedeci;
}

if(redUHashTabeli == 0) return 0;//nismo nasli ni original
HashZapis *prethodni = redUHashTabeli;//trebace nam za brisanje duplikata iz Hash tabele
redUHashTabeli = redUHashTabeli->sljedeci;//prvi posle originala
while(redUHashTabeli) {
if(kljuc == dajVrednostPodatka(redUHashTabeli)) {
//duplikat - obrisacemo ga
obrisiElementIzListe(redUHashTabeli->pok);
//sada da izbacimo i ovaj hash zapis
prethodni->sljedeci = redUHashTabeli->sljedeci;
free(redUHashTabeli);//ili delete redUHashTabeli;
++rezultat;
} else {
prethodni = redUHashTabeli;
}
redUHashTabeli = prethodni->sljedeci;
}
return rezultat;


}

void napraviTabelu(Cvor *headListe) {
//inicijalizacija
for(int i = 0; i < VELICINA_TABELE; ++i) {
hashTabela = NULL;
}
//glavna prica
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;
}

int main(){

int opcija;
int b;
while(opcija!=0){
cout<<"<<MENI>>"<<endl;
cout<<"1.DODAJ CVOR NA POCETAK."<<endl;
cout<<"2.ISPIS LISTE."<<endl;
cout<<"3. hashiraj "<<endl;
cout<<"4. ispisi vrijednost na osnovu unesenog kljuca:"<<endl;


cout<<"0.IZLAZ."<<endl;
cin>>opcija;
switch(opcija) {

case 1: {
Cvor *n=new Cvor();
cout<<"Unesi broj:"<<endl;
cin>>b;
n=iniCvor(b);
dodajUlistu(n);
cout<<endl;
break;
}


case 2: {
cout<<"ISPIS LISTE:"<<endl;
ispisListe();
cout<<endl;
break;
}
case 3:{
//for(int i = 0; i < VELICINA_TABELE; ++i) {
// izbaciDuplikate(i);
//}
napraviTabelu(headListe);
break;

}
case 4:{
int k;
cout<<"unesi kljuc"<<endl;
cin>>k;
cout<<"vrijednost tog kljuca je"<<dajVrednostPodatka(hashTabela[k]);
break;
}

}
}

cout<<endl;

system("pause");
return 0;

}





ewo cjeli program sto sam sklopio, ako moze neko naci gresku bio bih zahvalan
[ VladimirCDT @ 05.09.2010. 23:11 ] @
Citat:
demon_01: ajoj cuj izvini,trebam se ja izvinut sto gnjavim uvjek...
napravio sam test kod je prosao ali program ne radi kako bi trebao vjerovatno sam ja nesto pogresno pozvao u mainu
na koji nacin cu sad hashirat listu?? i da li je ova funkcija tacna za ispis liste??


void ispisiTabelu(){


for (int i=0;i<VELICINA_TABELE;i++)

cout<<hashTabela<i>;}


Zdravo, evo mene opet.

Konacno sam se dohvatio alata, pa sam imao priliku i da vidim kakve sam sve gluposti nalupetao. Ali dobro, ocistio sam musice, video glavni nedostatak (pored ostalih bugova), te sredio.
Glavni nedostatak je bio u tome sto, posle izbacivanja jednog elementa iz liste, nije azuriran hash zapis onog koji dolazi posle njega.
Takodje, promenio sam funkciju izbaciDuplikate jer sam shvatio da ce na ovaj nacin, izbacivanje biti brze i korektnije.

Elem, evo ti kompletnog resenja, uglavnom baziranog na prethodnoj prici:

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);
}



Zao mi je sto sam te samo smorio sa onom gomilom pogresnog i nabrzinu nakucanog koda. I ja sebe zovem programerom... e moj Vladimire...

Uzgred budi receno: primena jednostruko ulancane liste, kao sto vidis, prilicno komplikuje stvar. Sa dvostruko ulancanom listom, sve bi bilo daleko korektnije, jednostavnije i ne tako podlozno greskama. Zbog azuriranja hash zapisa elementa koji dolazi nakon obrisanog, bilo je potrebno izvrsiti poziv hash funkcije. Ova hash funkcija u ovom resenju je jednostavna i ne smatra se dobrom u praksi i realnim primenama. Hash funkcije znaju nekada biti dovoljno "skupe" i isplative su samo zbog indeksiranja ogromnog broja podataka.

Iskompajliraj, poteraj...

Eh, da... ako ovo budes davao profi, malo regulisi nazive promenljivih i funkcija i same komentare. Bilo bi glupo da, ako ti pricas jekavicom, da se naleti na ekavicu.

Inace, ono "cout << hashTabela<i>" ce ti samo ispisati vrednosti pointera, dakle adrese, a ne smislene podatke.
[ demon_01 @ 05.09.2010. 23:28 ] @
svaka cast majstore
hvala ti puno sto si mi pomogao i potrosio svoje vrijeme
najbolji si
[ demon_01 @ 05.09.2010. 23:37 ] @
Citat:
VladimirCDT: Zdravo, evo mene opet.

Konacno sam se dohvatio alata, pa sam imao priliku i da vidim kakve sam sve gluposti nalupetao. Ali dobro, ocistio sam musice, video glavni nedostatak (pored ostalih bugova), te sredio.
Glavni nedostatak je bio u tome sto, posle izbacivanja jednog elementa iz liste, nije azuriran hash zapis onog koji dolazi posle njega.
Takodje, promenio sam funkciju izbaciDuplikate jer sam shvatio da ce na ovaj nacin, izbacivanje biti brze i korektnije.

Elem, evo ti kompletnog resenja, uglavnom baziranog na prethodnoj prici:

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);
}



Zao mi je sto sam te samo smorio sa onom gomilom pogresnog i nabrzinu nakucanog koda. I ja sebe zovem programerom... e moj Vladimire... :D

Uzgred budi receno: primena jednostruko ulancane liste, kao sto vidis, prilicno komplikuje stvar. Sa dvostruko ulancanom listom, sve bi bilo daleko korektnije, jednostavnije i ne tako podlozno greskama. Zbog azuriranja hash zapisa elementa koji dolazi nakon obrisanog, bilo je potrebno izvrsiti poziv hash funkcije. Ova hash funkcija u ovom resenju je jednostavna i ne smatra se dobrom u praksi i realnim primenama. Hash funkcije znaju nekada biti dovoljno "skupe" i isplative su samo zbog indeksiranja ogromnog broja podataka.

Iskompajliraj, poteraj...

Eh, da... ako ovo budes davao profi, malo regulisi nazive promenljivih i funkcija i same komentare. :) Bilo bi glupo da, ako ti pricas jekavicom, da se naleti na ekavicu. :)

Inace, ono "cout << hashTabela<i>" ce ti samo ispisati vrednosti pointera, dakle adrese, a ne smislene podatke.








profa ima primjedbu na rad :
staticnu velicinu hash tabele tj. max 100 zapisa u hash tabeli. Hash tabela je druga lista sto znaci morate imati metode koja ce dodati novi zapis u hash tabelu (povezati pokazivac *sljedeci iz zapisa sa ostatkom tabele), isprazniti hashtabelu, i nije vam potreban nikakav niz. Broj zapisa u hashtabeli striktno ovisi o broju jedinstvenih cvorova (svaki cvor ima razlicit broj) u listi.
[ Goran Rakić @ 05.09.2010. 23:43 ] @
Citat:

6. Ne tražite da Vam neko radi domaći zadatak

Ne očekujte da bilo ko obavezno odradi sav posao umesto Vas! Rado ćemo pomoći oko svakog problema u slučaju da Vam "gori pod nogama", pred neki ispit ili posao, ali morate da pokažete na delu da ste u stvari krenuli sa radom i zastali pošto ne znate kako dalje. Ako samo navedete zadatak i specifikacije, u zavisnosti od raspoloženja članova na forumu, možda će se naći neko da odradi kompletan posao, ali pošto to zavisi od entuzijazma samih članova, ne postoji garancija da će se i dogoditi! [ES] posetioci će Vam pomoći da bolje SHVATITE problem sa kojim ste suočeni, ali ponešto morate i sami da uradite!


ES pravilnik http://www.elitesecurity.org/o/pravilnik/korisnici/
[ VladimirCDT @ 06.09.2010. 00:12 ] @
@demon_01

Ako profa ima primedbe, onda je mogao bolje da definise zadatak.
Ja sam hash tabelu i samu hash funkciju dao kao jednostavan predlog. Uopste nisam razumeo da je za sam zadatak veoma bitno sada praviti posebnu klasu za hash tabelu, opremljenu svim mogucim metodama itd. Ako bi se pravio dinamicki niz, onda bi zarad brzog pronalazenja hash zapisa morala da se implementira sortirana lista i metoda binarnog pretrazivanja. Sa takvim resenjem bismo opet opalili u problem brisanja elemenata iz jednostruko ulancane liste. Ali opet, profesor bi morao mnogo bolje da definise zadatak, ako zeli resenje koje ce ga zadovoljiti. Ovako, ne moze da se gleda u pasulj sta on zeli.

Verovatno postoji neko optimalnije resenje od onoga sto sam ja ponudio, koje bi uz to jos i pogodilo profesorovu nameru. Ja bih voleo da ga vidim, posto mi je ovako prica pomalo rebus.

Inace, niz u main metodi je samo zarad punjenja liste nekim glupo izmisljenim vrednostima, na neki smesan nacin, bez zelje da se na tom mestu nesto pravim pametan.
[ demon_01 @ 10.09.2010. 17:48 ] @
Citat:
VladimirCDT: @demon_01

Ako profa ima primedbe, onda je mogao bolje da definise zadatak.
Ja sam hash tabelu i samu hash funkciju dao kao jednostavan predlog. Uopste nisam razumeo da je za sam zadatak veoma bitno sada praviti posebnu klasu za hash tabelu, opremljenu svim mogucim metodama itd. Ako bi se pravio dinamicki niz, onda bi zarad brzog pronalazenja hash zapisa morala da se implementira sortirana lista i metoda binarnog pretrazivanja. Sa takvim resenjem bismo opet opalili u problem brisanja elemenata iz jednostruko ulancane liste. Ali opet, profesor bi morao mnogo bolje da definise zadatak, ako zeli resenje koje ce ga zadovoljiti. Ovako, ne moze da se gleda u pasulj sta on zeli.

Verovatno postoji neko optimalnije resenje od onoga sto sam ja ponudio, koje bi uz to jos i pogodilo profesorovu nameru. Ja bih voleo da ga vidim, posto mi je ovako prica pomalo rebus.

Inace, niz u main metodi je samo zarad punjenja liste nekim glupo izmisljenim vrednostima, na neki smesan nacin, bez zelje da se na tom mestu nesto pravim pametan.
Citat:
VladimirCDT: @demon_01

Ako profa ima primedbe, onda je mogao bolje da definise zadatak.
Ja sam hash tabelu i samu hash funkciju dao kao jednostavan predlog. Uopste nisam razumeo da je za sam zadatak veoma bitno sada praviti posebnu klasu za hash tabelu, opremljenu svim mogucim metodama itd. Ako bi se pravio dinamicki niz, onda bi zarad brzog pronalazenja hash zapisa morala da se implementira sortirana lista i metoda binarnog pretrazivanja. Sa takvim resenjem bismo opet opalili u problem brisanja elemenata iz jednostruko ulancane liste. Ali opet, profesor bi morao mnogo bolje da definise zadatak, ako zeli resenje koje ce ga zadovoljiti. Ovako, ne moze da se gleda u pasulj sta on zeli.

Verovatno postoji neko optimalnije resenje od onoga sto sam ja ponudio, koje bi uz to jos i pogodilo profesorovu nameru. Ja bih voleo da ga vidim, posto mi je ovako prica pomalo rebus.

Inace, niz u main metodi je samo zarad punjenja liste nekim glupo izmisljenim vrednostima, na neki smesan nacin, bez zelje da se na tom mestu nesto pravim pametan.



ma nek on prica sta hoce vi ste najbolji forum na koji sam dosad naletio,zahvaljujem vam se puno!!!
imali neko ideju kako da promjenim staticnu vrijednost hashTabele?
[ demon_01 @ 10.09.2010. 20:18 ] @
Citat:
VladimirCDT: @demon_01

Ako profa ima primedbe, onda je mogao bolje da definise zadatak.
Ja sam hash tabelu i samu hash funkciju dao kao jednostavan predlog. Uopste nisam razumeo da je za sam zadatak veoma bitno sada praviti posebnu klasu za hash tabelu, opremljenu svim mogucim metodama itd. Ako bi se pravio dinamicki niz, onda bi zarad brzog pronalazenja hash zapisa morala da se implementira sortirana lista i metoda binarnog pretrazivanja. Sa takvim resenjem bismo opet opalili u problem brisanja elemenata iz jednostruko ulancane liste. Ali opet, profesor bi morao mnogo bolje da definise zadatak, ako zeli resenje koje ce ga zadovoljiti. Ovako, ne moze da se gleda u pasulj sta on zeli.

Verovatno postoji neko optimalnije resenje od onoga sto sam ja ponudio, koje bi uz to jos i pogodilo profesorovu nameru. Ja bih voleo da ga vidim, posto mi je ovako prica pomalo rebus.

Inace, niz u main metodi je samo zarad punjenja liste nekim glupo izmisljenim vrednostima, na neki smesan nacin, bez zelje da se na tom mestu nesto pravim pametan.




opet ja ;-)

uspio sam napraviti nesto ali program ne radi bas kako treba jer ako se ponavlja prvi clan liste npr. ako imam listu 4,4,5,7,7 program ce ispisat 4,4,5,7,negdje bi trebalo dodat jos neku provjeru,ako mozes pomagaj! hvala