consolidate all repos to one for archive

semester_2/podatkovne_strukture/naloga_1/.gitignore

@@ -0,0 +1,3 @@
+.idea/*
+cmake-build-debug/*
+CMakeLists.txt

semester_2/podatkovne_strukture/naloga_1/README.md

@@ -0,0 +1 @@
+Navodila v folder navodila

semester_2/podatkovne_strukture/naloga_1/main.cpp

@@ -0,0 +1,131 @@
+#include <iostream>
+#include <string>
+#include <list>
+
+using namespace std;
+
+struct Student {
+	string Ime;
+	string Priimek;
+	string IDUM; };
+
+// prototipi
+void izpisi_seznam(list<Student>);
+void izpisi_studenta(Student);
+void vstavi(list<Student> &, int, Student);
+Student vrni(list<Student>, int);
+void vrini(list<Student> &, int, Student);
+Student odstrani(list<Student> &, int);
+
+void izpisi_seznam(list<Student> seznam)
+{
+	for (list<Student>::iterator it = seznam.begin(); it != seznam.end(); ++it)
+	{
+		Student st = *it;
+		izpisi_studenta(st);
+	}
+}
+
+void izpisi_studenta(Student st)
+{
+	cout << "Ime: " << st.Ime << endl << "Priimek: " << st.Priimek << endl << "IDUM: " << st.IDUM << endl << endl;
+}
+
+void vstavi(list<Student> &seznam, int indeks, Student podatek)
+{
+	if (indeks < 0 || indeks >= seznam.size() || seznam.empty()) {
+        return;
+    }
+    auto index = seznam.begin();
+    advance(index, indeks);
+    *index = podatek;
+}
+
+Student vrni(const list<Student> seznam, int indeks) 
+{
+	Student student;
+    if (indeks < 0 || indeks >= seznam.size() || seznam.empty()) return student;
+    auto index = seznam.begin();
+    advance(index, indeks);
+    student = *index;
+    return student;
+	return Student();
+}
+
+void vrini(list<Student> &seznam, int indeks, Student podatek) 
+{
+	if (indeks < 0) {
+        return;
+    }
+    else if(indeks >= seznam.size() || seznam.empty()){
+        seznam.push_back(podatek);
+        return;
+    }
+    auto index = seznam.begin();
+    advance(index, indeks);
+    seznam.insert(index, podatek);
+}
+
+Student odstrani(list<Student> &seznam, int indeks) 
+{
+	Student student;
+    if (indeks < 0 || indeks >= seznam.size() || seznam.empty()) return student;
+    auto index = seznam.begin();
+    advance(index, indeks);
+    student = *index;
+    seznam.erase(index);
+    return student;	
+	return Student();
+}
+
+int main() 
+{
+    int tmp;
+
+    list<Student> students;
+
+    Student st1 = {"jan", "bel", "243"};
+    Student st2 = {"pet" , "jsad", "324"};
+    Student st3 = {"asndlk", "ndsia", "345"};
+    Student st4 = {"nilp", "dsag", "365"};
+    Student st5 = {"dsag", "sadgn", "268"};
+    Student tmpStud;
+
+
+    students.push_back(st1);
+    students.push_back(st2);
+    students.push_back(st3);
+
+    izpisi_seznam(students);
+
+
+    cout<<"Naloga 1:"<<endl;
+    cin >> tmp;
+
+    vstavi(students, tmp, st4);
+    izpisi_seznam(students);
+
+    cout<<"Naloga 2:"<<endl<<endl;
+    cin >> tmp;
+
+    tmpStud=vrni(students, tmp);
+    izpisi_studenta(tmpStud);
+
+    cout<<"Naloga 3:"<<endl<<endl;
+    cin >> tmp;
+
+    vrini(students, tmp, st5);
+    izpisi_seznam(students);
+
+    cout<<"Naloga 4:"<<endl<<endl;
+    cin >> tmp;
+
+    tmpStud=odstrani(students, tmp);
+    izpisi_studenta(tmpStud);
+
+
+    izpisi_seznam(students);
+
+	return 0;
+}
+

semester_2/podatkovne_strukture/naloga_2/.gitignore

@@ -0,0 +1,3 @@
+.idea/*
+cmake-build-debug/*
+CMakeLists.txt

semester_2/podatkovne_strukture/naloga_2/README.md

@@ -0,0 +1 @@
+Navodila v folder navodila

semester_2/podatkovne_strukture/naloga_2/main.cpp

@@ -0,0 +1,198 @@
+#include <iostream>
+#include <string>
+#include <math.h>
+#include <queue>
+#include <stack>
+
+using namespace std;
+
+// prototipi
+bool jeOperand(char);
+
+bool jeOperator(char);
+
+int prioritetaOperatorja(char);
+
+queue<char> pretvori_niz_v_vrsto(string);
+
+queue<char> pretvorba_infiks_v_postfiks(queue<char>);
+
+double izracunaj_skladovni_stroj(queue<char>);
+
+double izracunaj_izraze(string);
+
+bool jeOperand(char c) {
+    if (c >= '0' && c <= '9')
+        return true;
+    return false;
+}
+
+bool jeOperator(char c) {
+    if (c == '+' || c == '-' || c == '*' || c == '/' || c == '^' || c == '(' || c == ')')
+        return true;
+    return false;
+}
+
+int prioritetaOperatorja(char c) {
+    switch (c) {
+        case '(':
+            return 4;
+        case ')':
+            return 4;
+        case '^':
+            return 3;
+        case '*':
+            return 2;
+        case '/':
+            return 2;
+        case '+':
+            return 1;
+        case '-':
+            return 1;
+
+        default:
+            return -1;
+    }
+}
+
+queue<char> pretvori_niz_v_vrsto(string izraz) {
+    queue<char> infiksni_izraz;
+
+    // TODO
+    for (int i = 0; i < izraz.size(); i++) {
+        if (jeOperand(izraz[i]) || jeOperator(izraz[i])) {
+            infiksni_izraz.push(izraz[i]);
+        }
+    }
+
+    return infiksni_izraz;
+}
+
+queue<char> pretvorba_infiks_v_postfiks(queue<char> infiksni_izraz) {
+    queue<char> postfiksni_izraz;
+    stack<char> pomozni_sklad;
+
+    char operator1;
+    char precitaniPodatek;
+
+    while (!infiksni_izraz.empty()) {
+        precitaniPodatek = infiksni_izraz.front();
+        infiksni_izraz.pop();
+        if (precitaniPodatek != ')') {
+            if (jeOperand(precitaniPodatek)) {
+                postfiksni_izraz.push(precitaniPodatek);
+            } else {
+                if (precitaniPodatek == '(') {
+                    pomozni_sklad.push(precitaniPodatek);
+                } else {
+                        while (!pomozni_sklad.empty() && pomozni_sklad.top() != '(' && prioritetaOperatorja(precitaniPodatek) <= prioritetaOperatorja(pomozni_sklad.top())) {
+                            operator1 = pomozni_sklad.top();
+                            pomozni_sklad.pop();
+                            postfiksni_izraz.push(operator1);
+
+                        }
+                    pomozni_sklad.push(precitaniPodatek);
+                }
+            }
+        } else {
+            operator1 = pomozni_sklad.top();
+            pomozni_sklad.pop();
+            while (operator1 != '(') {
+                postfiksni_izraz.push(operator1);
+                operator1 = pomozni_sklad.top();
+                pomozni_sklad.pop();
+            }
+        }
+    }
+    while (!pomozni_sklad.empty()) {
+        operator1 = pomozni_sklad.top();
+        pomozni_sklad.pop();
+        postfiksni_izraz.push(operator1);
+    }
+
+    return postfiksni_izraz;
+}
+
+double izracunaj_skladovni_stroj(queue<char> postfiksni_izraz) {
+    stack<double> skladovni_stroj;
+
+    char precitaniPodatek;
+    double rezultat, num1, num2;
+
+    while (!postfiksni_izraz.empty()) {
+        precitaniPodatek = postfiksni_izraz.front();
+        postfiksni_izraz.pop();
+        if (jeOperand(precitaniPodatek)) {
+            string tmp_string(1, precitaniPodatek);
+            skladovni_stroj.push(stod(tmp_string));
+        } else {
+            num1 = skladovni_stroj.top();
+            skladovni_stroj.pop();
+            num2 = skladovni_stroj.top();
+            skladovni_stroj.pop();
+            switch (precitaniPodatek) {
+                case '^':
+                    rezultat = pow(num2, num1);
+                    break;
+                case '*':
+                    rezultat = num2 * num1;
+                    break;
+                case '/':
+                    rezultat = num2 / num1;
+                    break;
+                case '+':
+                    rezultat = num1 + num2;
+                    break;
+                case '-':
+                    rezultat = num2 - num1;
+                    break;
+            }
+            skladovni_stroj.push(rezultat);
+        }
+    }
+    // na skladu mora ostat samo rezultat
+    return (skladovni_stroj.size() != 0) ? skladovni_stroj.top() : INT32_MIN;
+}
+
+double izracunaj_izraz(string izraz) {
+    // podprogram pretvori_niz_v_vrsto()
+    queue<char> infiksni_izraz = pretvori_niz_v_vrsto(izraz);
+
+    // podprogram pretvorba_infiks_v_postfiks()
+    queue<char> postfiksni_izraz = pretvorba_infiks_v_postfiks(infiksni_izraz);
+
+    // podprogram izracunaj_skladovni_stroj()
+    double rezultat = izracunaj_skladovni_stroj(postfiksni_izraz);
+
+    return rezultat;
+}
+
+int main() {
+    string izrazi[] = {
+            "2^(2-2)+1",
+            "4*( 9 - 5 )",
+            "2-2*2+2",
+            "2*6/3-2+2"
+    };
+
+    double rezultati[] = {
+            2.0,
+            16.0,
+            0.0,
+            4.0
+    };
+
+    int N = sizeof(izrazi) / sizeof(string);
+
+    for (int i = 0; i < N; i++) {
+        double rezultat = izracunaj_izraz(izrazi[i]);
+
+        if (rezultati[i] == rezultat)
+            cout << "OK" << endl;
+        else
+            cout << "Napacen rezultat za izraz " << izrazi[i] << ": " << rezultat << " (pricakovan rezultat: " << rezultati[i] << ")." << endl;
+    }
+
+    return 0;
+}
+

semester_2/podatkovne_strukture/naloga_3/.gitignore

@@ -0,0 +1,3 @@
+.idea/*
+cmake-build-debug/*
+CMakeLists.txt

semester_2/podatkovne_strukture/naloga_3/README.md

@@ -0,0 +1 @@
+Navodila v folder navodila

semester_2/podatkovne_strukture/naloga_3/main.cpp

@@ -0,0 +1,304 @@
+
+#include <iostream>
+#include <queue>
+#include <limits>
+
+using namespace std;
+
+// razred IskalnoDrevo
+class IskalnoDrevo
+{
+	// razred Vozlisce
+	class Vozlisce
+	{
+		double podatek;
+		Vozlisce *levo;
+		Vozlisce *desno;
+
+		public:
+
+			Vozlisce(double podatek)
+			{
+				this->podatek = podatek;
+				this->levo = NULL;
+				this->desno = NULL;
+			}
+
+			void vstavi(double podatek)
+			{
+				if (podatek < this->podatek)
+				{
+					if (levo == NULL)
+						levo = new Vozlisce(podatek);
+					else
+						levo->vstavi(podatek);
+				}
+				else
+				{
+					if (desno == NULL)
+						desno = new Vozlisce(podatek);
+					else
+						desno->vstavi(podatek);
+				}
+			}
+
+			int stevilo_vozlisc()
+			{
+                int stevilo = 1;
+                if(desno != NULL)
+                    stevilo += desno->stevilo_vozlisc();
+
+                if(levo != NULL)
+                    stevilo += levo->stevilo_vozlisc();
+
+				return stevilo;
+			}
+
+			int visina_drevesa(int globina)
+			{
+                int desnoVisina = 0;
+                int levoVisina = 0;
+
+                if(desno != NULL)
+                    desnoVisina += desno->visina_drevesa(globina + 1);
+
+                if(levo != NULL)
+                    levoVisina += levo->visina_drevesa(globina + 1);
+
+                if(levoVisina == 0 and desnoVisina == 0)
+                    return globina;
+                else if(levoVisina < desnoVisina)
+                    return desnoVisina;
+                else
+                    return levoVisina;
+			}
+
+			double najvecji()
+			{
+                double najvec = this->podatek;
+                if(desno != NULL)
+                    najvec = desno->najvecji();
+
+				return najvec;
+			}
+
+			double najmanjsi()
+			{
+                double najmanj = this->podatek;
+
+                if(levo != NULL)
+                    najmanj = levo->najmanjsi();
+
+                return najmanj;
+			}
+
+			void premi_pregled(queue<double> &vrsta)
+			{
+                vrsta.push(podatek);
+                if(levo != NULL)
+                    levo->premi_pregled(vrsta);
+
+                if(desno != NULL)
+                    desno->premi_pregled(vrsta);
+
+            }
+
+			void vmesni_pregled(queue<double> &vrsta)
+			{
+
+                if(levo != NULL)
+                    levo->vmesni_pregled(vrsta);
+
+                vrsta.push(podatek);
+                if(desno != NULL)
+                    desno->vmesni_pregled(vrsta);
+
+            }
+
+			void obratni_pregled(queue<double> &vrsta)
+			{
+                if(levo != NULL)
+                    levo->obratni_pregled(vrsta);
+
+                if(desno != NULL)
+                    desno->obratni_pregled(vrsta);
+
+                vrsta.push(podatek);
+            }
+
+			bool iskanje(double stevilo)
+			{
+                if(stevilo == podatek)
+                    return true;
+
+                if (stevilo < podatek)
+                {
+                    if (levo == NULL)
+                        return false;
+                    else
+                        return levo->iskanje(stevilo);
+                }
+                else
+                {
+                    if (desno == NULL)
+                        return false;
+                    else
+                        return desno->iskanje(stevilo);
+                }
+
+			}
+
+			double vsota()
+			{
+                double stevilo = podatek;
+                if(desno != NULL)
+                    stevilo += desno->vsota();
+
+                if(levo != NULL)
+                    stevilo += levo->vsota();
+
+                return stevilo;
+			}
+	};
+
+	// nadaljevanje razreda IskalnoDrevo
+	Vozlisce *koren;
+
+	public:
+		IskalnoDrevo()
+		{
+			koren = NULL;
+		}
+
+		void vstavi(double podatek)
+		{
+			if (koren == NULL)
+				koren = new Vozlisce(podatek);
+			else
+				koren->vstavi(podatek);
+		}
+
+		int stevilo_vozlisc() const
+		{
+			if (koren == NULL)
+				return 0;
+			else
+				return koren->stevilo_vozlisc();
+		}
+
+		int visina_drevesa() const
+		{
+			if (koren == NULL)
+				return 0;
+			else
+				return koren->visina_drevesa(1);
+		}
+		double najvecji() const
+		{
+			if (koren == NULL)
+				return numeric_limits<double>::quiet_NaN();
+			return koren->najvecji();
+		}
+
+		double najmanjsi() const
+		{
+			if (koren == NULL)
+				return numeric_limits<double>::quiet_NaN();
+			return koren->najmanjsi();
+		}
+
+		queue<double> premi_pregled() const
+		{
+			queue<double> prefiks;
+			if (koren != NULL)
+				koren->premi_pregled(prefiks);
+			return prefiks;
+		}
+
+		queue<double> vmesni_pregled() const
+		{
+			queue<double> infiks;
+			if (koren != NULL)
+				koren->vmesni_pregled(infiks);
+			return infiks;
+		}
+
+		queue<double> obratni_pregled() const
+		{
+			queue<double> postfiks;
+			if (koren != NULL)
+				koren->obratni_pregled(postfiks);
+			return postfiks;
+		}
+
+		bool iskanje(double stevilo) const
+		{
+			if (koren != NULL)
+				return koren->iskanje(stevilo);
+
+			return false;
+		}
+
+		double vsota() const
+		{
+			if (koren != NULL)
+				return koren->vsota();
+
+			return numeric_limits<double>::quiet_NaN();
+		}
+};
+
+int main(int argn, char **args)
+{
+	double zaporedje[] = {5,2,8,10,4,6,1,12,-5,-3,-6,-8,7 };
+	int dolzina = 13;
+
+	// ustvarimo nov objekt
+	IskalnoDrevo id;
+
+	// napolnimo drevo
+	for (int i = 0; i < dolzina; i++)
+		id.vstavi((zaporedje[i]));
+
+	// pričakovan izhod
+	double pricakovan_izhod = 7;
+
+	// dobljen izhod
+	double dobljen_izhod = id.najvecji();
+
+	// preverimo, če dobimo pravilen izhod
+	if (pricakovan_izhod == dobljen_izhod)
+		cout << "OK" << endl;
+	else 
+		cout << "Napaka! Pricakovan izhod: " << pricakovan_izhod << ", dobljen izhod: " << dobljen_izhod << endl;
+
+
+    cout << "Stevilo vozlisc: " << id.stevilo_vozlisc() << "\n";
+
+    cout << "Najdi stevilo 2: " << (id.iskanje(2) ? "true" : "false") << "\n";
+    cout << "Najdi stevilo 1: " << (id.iskanje(1) ? "true" : "false") << "\n";
+
+    cout << id.vsota() << endl;
+
+    cout << id.visina_drevesa() << endl;
+
+    queue<double> ha = id.premi_pregled();
+    for (int i = 0; i < dolzina; ++i) {
+        cout << ha.front() << " ";
+        ha.pop();
+    }
+    cout << "\n";
+    ha = id.vmesni_pregled();
+    for (int i = 0; i < dolzina; ++i) {
+        cout << ha.front() << " ";
+        ha.pop();
+    }
+    cout << "\n";
+    ha=id.obratni_pregled();
+    for (int i = 0; i < dolzina; ++i) {
+        cout << ha.front() << " ";
+        ha.pop();
+    }
+
+	return 0;
+}

semester_2/podatkovne_strukture/naloga_4/.gitignore

@@ -0,0 +1,3 @@
+.idea/*
+cmake-build-debug/*
+CMakeLists.txt

semester_2/podatkovne_strukture/naloga_4/README.md

@@ -0,0 +1 @@
+Navodila v folder navodila

semester_2/podatkovne_strukture/naloga_4/main.cpp

@@ -0,0 +1,98 @@
+
+
+#include <iostream>
+#include <string>
+#include <map>
+#include <assert.h>     /* assert */
+
+using namespace std;
+
+struct Oseba
+{
+    string Ime;
+    string Priimek;
+    int IDUM;	// 9-mestna unikatna številka
+
+    void print(){
+        cout << Ime << " " << Priimek << " " << to_string(IDUM) << "\n";
+    }
+};
+
+// prototipi
+void dobi_prvo_crko(Oseba, char &);
+void dobi_slovar_s_crko(map<char, map<int, Oseba>>, char, map<int, Oseba> &);
+void vstavi_osebo_v_slovar_oseb(map<int, Oseba> &, Oseba);
+void posodobi_slovar_oseb_v_slovarju(map<char, map<int, Oseba>> &, char, map<int, Oseba>);
+void napolni_slovar(Oseba [], int, map<char, map<int, Oseba>> &);
+
+void dobi_prvo_crko(Oseba oseba, char &prva_crka)
+{
+    // TODO
+    prva_crka = oseba.Priimek[0];
+}
+
+void dobi_slovar_s_crko(map<char, map<int, Oseba>> slovar, char prva_crka, map<int, Oseba> &slovar_oseb)
+{
+    // TODO
+    slovar_oseb = slovar[prva_crka];
+}
+
+void vstavi_osebo_v_slovar_oseb(map<int, Oseba> &slovar_oseb, Oseba os)
+{
+    // TODO
+    slovar_oseb.insert(std::pair<int,Oseba>(os.IDUM, os));
+}
+
+void posodobi_slovar_oseb_v_slovarju(map<char, map<int, Oseba>> &slovar, char prva_crka, map<int, Oseba> slovar_oseb)
+{
+    // TODO
+    slovar[prva_crka].swap(slovar_oseb);
+}
+
+void napolni_slovar(Oseba seznam[], int N, map<char, map<int, Oseba>> &slovar)
+{
+    for (int i = 0; i < N; i++)
+    {
+        // pridobimo prvo črko
+        char prva_crka;
+        dobi_prvo_crko(seznam[i], prva_crka);
+
+        // pridobimo slovar oseb s prvo črko
+        map<int, Oseba> slovar_oseb;
+        dobi_slovar_s_crko(slovar, prva_crka, slovar_oseb);
+
+        // vstavimo osebo v slovar
+        vstavi_osebo_v_slovar_oseb(slovar_oseb, seznam[i]);
+
+        // posodobi slovar
+        posodobi_slovar_oseb_v_slovarju(slovar, prva_crka, slovar_oseb);
+    }
+}
+
+int main()
+{
+    Oseba seznam[] = {
+            Oseba {"Jani", "Dugonik", 123456789 },
+            Oseba{"Nikola", "Petrov", 1002525225},
+            Oseba{"Nikollll", "Petttr", 1223625123},
+            Oseba{"Ozan", "Zef",1001234567},
+            Oseba{"Zan", "Burger", 1002345678},
+            Oseba{"Marko", "Novak", 1003456789}
+    };
+    int N = sizeof(seznam) / sizeof(Oseba);
+    map<char, map<int, Oseba>> slovar;
+    napolni_slovar(seznam, N, slovar);
+    map<int,Oseba> slovarOseb;
+    Oseba tmp;
+
+    for (auto it=slovar.begin(); it!=slovar.end(); ++it) {
+        slovarOseb = it->second;
+        cout << it->first << endl;
+        for (auto at=slovarOseb.begin(); at!=slovarOseb.end(); ++at) {
+            at->second.print();
+        }
+    }
+
+    return 0;
+}
+