Advanced Search

Strukture podataka/Evidencija životinja/Lista polja

/ Published in: C++
Save to your folder(s)
Ovo je moja lista polja koju sam koristio u svom glavnom programu koja je implementirana kao lista pomoću polja

Expand | Embed | Plain Text

Copy this code and paste it in your HTML 
  1. #include<iostream>
  2.     using namespace std;
  3.     typedef int clan;
  4.     struct zivine{
  5.        int sifra;
  6.        char vrsta[40];
  7.        char naziv[40];
  8.        float cijena;
  9.        int dat[3];
  10.     };
  11.     struct Zapis_L{
  12.        zivine vrj[1000];
  13.        int k;
  14.     };
  15.     typedef struct Zapis_L lis;
  16.     clan EndL(lis *L){
  17.        return (L->k);
  18.     }
  19.     clan FirstL(lis *L){
  20.        if(L->k==0)
  21.           return EndL(L);
  22.        else
  23.           return 0;
  24.     }
  25.     zivine RetreiveL(clan p, lis *L){
  26.        return L->vrj[p];
  27.     }  
  28.     clan InsertL(zivine x,clan p,lis *L){
  29.        if(p>L->k || p<0) return 0;
  30.        else{
  31.           for( int q=L->k;q>=p;q--)
  32.              L->vrj[q+1]=L->vrj[q];
  33.           L->k++;
  34.           L->vrj[p]=x;
  35.           return 1; 
  36.        }
  37.     }
  38.     lis *InitL(lis *L){
  39.        L=new lis;
  40.        L->k=0;
  41.        return L;
  42.     }
  43.     clan NextL(clan p, lis *L){
  44.        if(p==EndL(L)-1) return EndL(L);
  45.        if(p==EndL(L)) return 0;
  46.        else
  47.           return p+1;
  48.     }
  49.     clan PreviousL(clan p, lis *L){
  50.        if(p==FirstL(L)) return -1;
  51.        if(p==EndL(L)) return p-1;
  52.        return p-1;
  53.     }
  54.  
  55.     clan DeleteL(clan p, lis *L){
  56.        if((L->k==0))
  57.           return 0;
  58.        if((p>=L->k)||(p<0))
  59.           return 0;
  60.        if(p==EndL(L))
  61.           return 0;
  62.        if(p==FirstL(L)){
  63.           L->k--;
  64.           for( int i=p; i<L->k; i++)
  65.              L->vrj[i]=L->vrj[i+1];
  66.           return 1;
  67.        }
  68.        else{
  69.           L->k--;
  70.           for( int i=p; i<L->k; i++)
  71.              L->vrj[i]=L->vrj[i+1];
  72.        }
  73.        return 1;
  74.     }
  75.     clan DeleteAll(lis *L){
  76.        return L->k==0;
  77. }
  78.     clan LocateL(zivine x, lis *L){
  79.        clan pozicija=EndL(L);
  80.        pozicija=PreviousL(pozicija,L);
  81.        if(strlen(x.naziv)>0){
  82.           if(FirstL(L)!=EndL(L)){
  83.              while(5){
  84.                 zivine tekuci=RetreiveL(pozicija,L);
  85.                 if(strcmp(x.naziv,tekuci.naziv)==0)
  86.                    return pozicija;
  87.                 if(pozicija==FirstL(L))break;
  88.                 pozicija=PreviousL(pozicija,L);
  89.              }
  90.           }
  91.        }
  92.        if(strlen(x.vrsta)>0){
  93.           if(FirstL(L)!=EndL(L)){
  94.              while(5){
  95.                 zivine tekuci=RetreiveL(pozicija,L);
  96.                 if(strcmp(x.vrsta,tekuci.vrsta)==0)
  97.                    return pozicija;
  98.                 if(pozicija==FirstL(L))break;
  99.                 pozicija=PreviousL(pozicija,L);
  100.              }
  101.           }
  102.        }
  103.        return EndL(L);
  104.     }
  105.     void Merge(lis *L,int i,int k,int j){
  106.          int start=i, zad=k+1, br=0, vel=j-i+1;
  107.          zivine *pom = new zivine [j-i+1];
  108.          while (start<=k && zad<=j){
  109.             if(L->vrj[start].cijena>L->vrj[zad].cijena)
  110.                pom[br++]=L->vrj[start++];
  111.             else if(L->vrj[start].cijena<L->vrj[zad].cijena)
  112.                pom[br++]=L->vrj[zad++];
  113.             if(L->vrj[start].cijena==L->vrj[zad].cijena){
  114.                if(strcmp(L->vrj[start].naziv,L->vrj[zad].naziv)==1)
  115.                   pom[br++]=L->vrj[start++];
  116.                else
  117.                pom[br++]=L->vrj[zad++];
  118.             }
  119.          }
  120.          while(start<=k)
  121.             pom[br++]=L->vrj[start++];
  122.          while(zad<=j)
  123.             pom[br++]=L->vrj[zad++];
  124.          for(int I=0;I<vel;I++)
  125.             L->vrj[i+I]=pom[I];
  126.          delete []pom;
  127.     }
  128.  
  129.     void Sort(lis *L, int i,int j){
  130.          int sred;
  131.          if(i<j){
  132.             sred=(i+j)/2;
  133.             Sort(L,i,sred);
  134.             Sort(L,sred+1,j);
  135.             Merge(L,i,sred,j);
  136.          }
  137.     }
  138.     void Merge(lis *L,int i,int j){
  139.          if(FirstL(L)==EndL(L)){
  140.             cout<<"Prazna lista! "<<endl;
  141.             return;
  142.          }
  143.          Sort(L,0,EndL(L)-1);
  144.          zivine tekuci;
  145.          for(int i=0;i<=EndL(L)-1;i++){
  146.             tekuci=L->vrj[i];
  147.             cout<<"Sifra: "<<tekuci.sifra<<endl;
  148.             cout<<"Naziv: "<<tekuci.naziv<<endl;
  149.             cout<<"Datum: "<<tekuci.dat[0]<<"."<<tekuci.dat[1]<<"."<<tekuci.dat[2]<<endl;
  150.             cout<<"Vrsta: "<<tekuci.vrsta<<endl;
  151.             cout<<"Cijena: "<<tekuci.cijena<<endl;
  152.             cout<<endl; }
  153.     }

Report this snippet


Comments

RSS Icon Subscribe to comments

You need to login to post a comment.