// Implementacija liste pomocu polja

L#define ERROR -1

struct tDatum {
	short dan, mjesec, godina;
};
typedef tDatum Datum;

struct tZiv {
	int sifra;
	char vrsta[50], naziv[50];
	float cijena;
	tDatum datum;
};
typedef tZiv Zivotinja;

struct tLista {
	tZiv el[10000];
	int kursor;
};
typedef int Element;
typedef tLista Lista;

bool operator==(Zivotinja z, Zivotinja z2) {
	if(z.sifra != z2.sifra)
		return false;
	else if(z.cijena != z2.cijena)
		return false;
	else if(z.sifra != z2.sifra)
		return false;
	else if(z.sifra != z2.sifra)
		return false;
	else if(z.datum.dan!=z2.datum.dan || z.datum.mjesec!=z2.datum.mjesec || 
    z.datum.godina!=z2.datum.godina)
		return false;
	else
		return true;
}

Element FirstL(Lista* L) {
	return 0;
}
Element EndL(Lista* L) {
	return L->kursor;
}

Element NextL(Element p, Lista* L) {
	if(p==EndL(L) )
		return ERROR;
	return p+1;
}
Element PreviousL(Element p, Lista* L) {
	if(p==FirstL(L) )
		return ERROR;
	return p-1;
}

Element LocateL(Zivotinja x, Lista* L) {
	int i=0;
	while(i<L->kursor) {
		if(L->el[i] == x)
			return i;
		i++;
	}
	return EndL(L);
}
bool InsertL(Zivotinja x, Element p, Lista* L) {
	if(p<0 || p>L->kursor)
		return 0;
	
	int i=L->kursor;
	L->kursor++;
	while(i>p) {
		L->el[i] = L->el[i-1];
		i--;
	}
	L->el[p] = x;
	return 1;
}

bool DeleteL(Element p, Lista* L) {
	if(p<0 || p>L->kursor)
		return 0;
	
	int i = p+1;
	while(i<L->kursor) {
		L->el[i-1] = L->el[i];
		i++;
	}
	L->kursor--;
	return 1;
}
Zivotinja RetrieveL(Element p, Lista* L) {
	return L->el[p];
}

void DeleteAllL(Lista* L) {
	L->kursor = 0;
}
void InitL(Lista* L) {
	L->kursor = 0;
}

// Implementacija liste pomocu pokazivaca

#define ERROR NULL

struct tDatum {
	short dan, mjesec, godina;
};
typedef tDatum Datum;

struct tZiv {
	int sifra;
	char vrsta[50], naziv[50];
	float cijena;
	tDatum datum;
};
typedef tZiv Zivotinja;

struct tEl {
	tZiv el;
	tEl* sljedeci;
};
typedef tEl* Element;
typedef tEl Lista;

bool operator==(Zivotinja z, Zivotinja z2) {
	if(z.sifra != z2.sifra)
		return false;
	else if(z.cijena != z2.cijena)
		return false;
	else if(z.sifra != z2.sifra)
		return false;
	else if(z.sifra != z2.sifra)
		return false;
	else if(z.datum.dan!=z2.datum.dan || z.datum.mjesec!=z2.datum.mjesec || 
    z.datum.godina!=z2.datum.godina)
		return false;
	else
		return true;
}

Element FirstL(Lista* L) {
	return L;
}

Element EndL(Lista* L) {
	Element trenutni = L;
	while(trenutni->sljedeci)
		trenutni=trenutni->sljedeci;
	
	return trenutni;
}

Element NextL(Element p, Lista* L) {
	if(p->sljedeci)
		return p->sljedeci;
	return ERROR;
}

Element PreviousL(Element p, Lista* L) {
	if(p==FirstL(L) )
		return ERROR;
	
	Element trenutni = FirstL(L);
	while(trenutni->sljedeci!=p)
		trenutni=trenutni->sljedeci;
	
	return trenutni;
}

Element LocateL(Zivotinja x, Lista* L) {
	Element trenutni=L;
	while(trenutni->sljedeci) {
		if(trenutni->sljedeci->el == x)
			return trenutni;
		trenutni = trenutni->sljedeci;
	}
	return EndL(L);
}

bool InsertL(Zivotinja x, Element p, Lista* L) {
	if(!L) return 0;
	Element novi = new tEl;
	
	memcpy(novi, &x, sizeof(Zivotinja) );
	
	novi->sljedeci = p->sljedeci;
	p->sljedeci = novi;
	return 1;
}

bool DeleteL(Element p, Lista* L) {
	if(!L) return 0;
	Element trenutni = p->sljedeci;
	p->sljedeci = trenutni->sljedeci;
	delete trenutni;
	return 1;
}
Zivotinja RetrieveL(Element p, Lista* L) {
	return p->sljedeci->el;
}

void DeleteAllL(Lista* L) {
	if(!L) return;
	if(!L->sljedeci) return;
	Element prethodni = L->sljedeci;
	Element trenutni=prethodni->sljedeci;
	while(trenutni!=NULL) {
		delete prethodni;
		prethodni = trenutni;
		trenutni = prethodni->sljedeci;
	}
	delete prethodni;
	L->sljedeci = NULL;
}
void InitL(Lista* L) {
	L->sljedeci = NULL;
}

// Glavni dio programa

#include <iostream>
//#include "l_polje.h"
#include "l_pokazivaci.h"
using namespace std;

                                                                                      // mog 1 - Unos
bool U(Lista* L) {
	cout << endl;
	cout << " Dodavanje zivotinje u listu " << endl;
	cout << "#############################" << endl;
	
	static int sifra = 100;
	
	Zivotinja* ziv = new Zivotinja;
	ziv->sifra = sifra;
	
	sifra++;
	cout << "Sifra(*auto): " << ziv->sifra << endl;
	
	cin.ignore();
	cout << "Naziv: ";
	cin.getline(ziv->naziv, 50);
	
	cout << "Vrsta: ";
	cin.getline(ziv->vrsta, 50);
	
	cout << "Cijena: ";
	cin >> ziv->cijena;
	
	
	cout << "Dan: ";
	cin >> ziv->datum.dan;
	
	cout << "Mjesec: ";
	cin >> ziv->datum.mjesec;
	
	cout << "Godina: ";
	cin >> ziv->datum.godina;
	
	
	int ok = InsertL(*ziv, EndL(L), L);
	return ok;
}

                                                                                           // mog 3-1 - Ispis cijele liste
void I1(Lista* L) {
	cout << endl;
	cout << " Ispis svih zivotinja iz liste " << endl;
	cout << "###############################" << endl;
	
	Zivotinja ziv;
	
	                                                                                              // prolazenje kroz cijelu listu i ispis
	Element trenutni = PreviousL(EndL(L), L) ;
	while(trenutni != ERROR) {
		ziv = RetrieveL(trenutni, L);
		
		cout << endl;
		cout << "......................................" << endl;
		
		cout << "Sifra: " << ziv.sifra << endl;
		cout << "Naziv: " << ziv.naziv << endl;
		cout << "Vrsta: " << ziv.vrsta << endl;
		cout << "Cijena: " << ziv.cijena << endl;
		cout << "Datum: " << ziv.datum.dan << ".";
		
		cout << ziv.datum.mjesec << "." << ziv.datum.godina << "." << endl;
		
		cout << endl;
		
		trenutni = PreviousL(trenutni, L) ;
	}
}

                                                                                      // mog 3-2 - Ispis svih zivotinja dostavljenih nakon 23.9.2012
void I2(Lista* L) {
	cout << endl;
	cout << " Ispis zivotinja - svih poslije 23.9.2012. " << endl;
	cout << "###########################################" << endl;
	
	Zivotinja ziv;
	int br = 0;
	
	Element trenutni=FirstL(L);
	while(trenutni!=EndL(L)) {
		ziv = RetrieveL(trenutni, L);
		int dd = (ziv.datum.godina*10000) + (ziv.datum.mjesec*100) + ziv.datum.dan;
		
		                                                                               // ako je datum poslije (2012 09 23) - broj u if-u : ispis
		if(dd>20120923){
			cout << endl;
			cout << "Sifra: " << ziv.sifra << endl;
			cout << "Naziv: " << ziv.naziv << endl;
			cout << "Vrsta: " << ziv.vrsta << endl;
			cout << "Cijena: " << ziv.cijena << endl;
			cout << "Datum: " << ziv.datum.dan << ".";
			cout << ziv.datum.mjesec << "." << ziv.datum.godina << endl;
			cout << endl;
			br++;
		}
		
		trenutni = NextL(trenutni, L);
	}
	
	cout << "Broj ispisanih zivotinja: " << br << endl;
}

bool StrJednako(char* s1, char* s2, int n, int n2) {
	                                                                                   // ako su rijeci razlicite duzine - onda nisu iste :D
	if(n != n2)
		return 0;
	
	                                                                                  // prolazenje kroz sve znakova - ako postoji                                                                                //razliciti znak - rijeci nisu iste
	int i=0;                                                                                //razliciti znak - rijeci nisu iste
	while(i<n) {
		if(s1[i] != s2[i])
			return 0;
		i++;
	}
	
	                                                                                    // ako do sad funkcija nije zavrsena - rijeci su iste (konacno iste)
	return 1;                                                                           //su iste (konacno iste)
}

                                                                                         // mog 5-1 - Brisanje prema nazivu
int B1(Lista* L) {
	cout << endl;
	cout << " Brisanje unosa prema nazivu " << endl;
	cout << "#############################" << endl;
	
	                                                                                       // unos naziva
	char naziv[50];
	cin.ignore();
	
	cout << "Naziv zivotinje koja se zeli obrisati: ";
	cin.getline(naziv, 50);
	
	                                                                                     // pretrazivanje liste sa zivotinjama
	Zivotinja ziv;
	
	Element trenutni=FirstL(L);
	while(trenutni!=EndL(L)) {
		ziv = RetrieveL(trenutni, L);
		
                                                                                         // provjeri da li je naziv zivotinje jednak unesenom nazivu
		if(StrJednako(naziv, ziv.naziv, strlen(naziv), strlen(ziv.naziv))) {
			int ok = DeleteL(LocateL(ziv, L), L);
			if(ok==-1) return 0;
			else return 1;
		}
		
		trenutni = NextL(trenutni, L);
	}
	return 0;
}

                                                                                         // mog 5-2 - Brisanje prema vrsti
int B2(Lista* L) {
	cout << endl;
	cout << " Brisanje vrste " << endl;
	cout << "################" << endl;
	
	char vrsta[50];
	cin.ignore();
	
	cout << "Vrsta zivotinja koja se zeli obrisati: ";
	cin.getline(vrsta, 50);
	
	int br = 0;
	Zivotinja ziv;
	
	                                                                                     
	Element trenutni=FirstL(L);
	while(trenutni!=EndL(L)) {
		ziv = RetrieveL(trenutni, L);
		
  
		if(StrJednako(vrsta,ziv.vrsta,strlen(vrsta), strlen(ziv.vrsta))) {
			
		                                                                                    	
			int ok = DeleteL(LocateL(ziv, L), L);
			if(ok==1) {
				br++;
				continue;
			}
		}
		trenutni=NextL(trenutni,L);
	}
	
	cout << "Ukupno izbrisano " << br << " unosa." << endl;
	
	if(br>0)
		return 1;
	else
		return 0;
}

bool Provjera(Zivotinja z, Zivotinja z2) {
                                                                                      
	if(z.cijena<z2.cijena)                                                                    
		return 1;
	
	                                                                                            
	if(z.cijena==z2.cijena) {
		int manji = (strlen(z.naziv)<strlen(z2.naziv)) ? strlen(z.naziv) : 
            strlen(z2.naziv);
		
		                                                                              
		                                                                            
		for(int i=0; i<manji; i++)
			
			if(z.naziv[i]>z2.naziv[i])
				return 0;
				
			else if(z.naziv[i]<z2.naziv[i])
				return 1;
	}
	
	                                                                                   
	return 0;
}

                                                                                          
void SortiranjeSpoji(Zivotinja p[], int i, int k, int j) {
	int I=i, J=k+1, K=0;
	Zivotinja* p2 = new Zivotinja[j-i+1];
	
	while(I<=k && J<=j)
		if(Provjera(p[I], p[J]))
			p2[K++]=p[I++];
		else
			p2[K++]=p[J++];
	
	if(I>k)
		while(J<=j)
			p2[K++]=p[J++];
	else
		while(I<=k)
			p2[K++]=p[I++];
	
	for(int m=i; m<=j; m++)
		p[m]=p2[m-i];
	
	delete[] p2;
}
void SortiranjeSpajanjem(Zivotinja p[], int i, int j) {
	if(i<j) {
		int k = (i+j) / 2;
		SortiranjeSpajanjem(p, i, k);
		SortiranjeSpajanjem(p, k+1, j);
		SortiranjeSpoji(p, i, k, j);
	}
}

                                                                                            
void S(Lista* L) {
	cout << endl;
	cout << " Sortiranje liste zivotinja " << endl;
	cout << "############################" << endl;
	
	int brojac=0, i=0;
	
                                                                                                	
	Element trenutni=FirstL(L);
	while(trenutni!=EndL(L)) {
		brojac++;
		trenutni=NextL(trenutni, L);
	}
	
	// 
	Zivotinja* zivotinje = new Zivotinja[brojac];
	Element nova=FirstL(L);
	while( nova!=EndL(L)) {
		zivotinje[i++]=RetrieveL(nova, L);
		
		nova=NextL(nova, L);
	}
	
	                                                                                              
	SortiranjeSpajanjem(zivotinje, 0, brojac-1);
	
	                                                                                                  
	DeleteAllL(L);
	
	                                                                                                     
	for(int i=brojac-1; i>=0; i--)
		InsertL(zivotinje[i], EndL(L), L);
	
	                                                                                                    
	delete[] zivotinje;
}

int main() {
	Lista* L = new Lista;
	
	InitL(L);
	
	short od;
	
	do {
		cout << endl;
		cout << "#############################" << endl;
		cout << "       Glavni izbornik       " << endl;
		cout << "#############################" << endl;
		cout << " 1. Dodavanje zivotinje" << endl;
		cout << " 3. Ispis" << endl;
		cout << " 5. Brisanje vrste zivotinja" << endl;
		cout << " 7. Sortiranje" << endl;
		cout << " 9. Izlaz" << endl;
		cout << "Vas izbor:  ";
		cin >> od;
		
		switch(od) {
			case 1: {
				int ok = U(L);
				if(ok==1)
					cout << endl << "Unos je dodan u listu." << endl;
				break;
			}
			case 3: {
				int a;
				do {
					cout << "1. Ispis cijele liste" << endl;
					cout << "2. samo zivotinja s datumom poslije 23.9.2012." << endl;
					cin >> a;
					
					if(a==1)
						I1(L);
					
					if(a==2)
						I2(L);
				} while(a!=1 && a!=2);
				
				break;
			}
			
			case 5: {
				int a;
				do {
					cout << "1. Brisanje 1 zivotinje prema nazivu" << endl;
					cout << "2. Brisanje svih zivotinja prema vrsti" << endl;
					cin >> a;
					
					if(a==1) {
						int ok = B1(L);
						if(ok==1)
							cout << "Brisanje je uspjesno obavljeno." << endl;
					}
					
					if(a==2) {
						int ok = B2(L);
						if(ok)
							cout << "Brisanje je uspjesno obavljeno." << endl;
					}
				} while(a!=1 && a!=2);
				
				break;
			}
			
			case 7:
				S(L);
				break;
			
			case 9:
				break;
			
			default:
				cout << "Pogresan unos. Ponovite unos" << endl;
		}
	} while(od!=9);
	
	return 0;
}

Datoteke zaglavlja (implementacija liste pomoću polja i pokazivača), te glavni dio programa

Drazen_Hrgar_Zadatak_1_Strukture_Podataka

C++