From a8689cb0bd8293474847fd23190b5d0094c2d3f8 Mon Sep 17 00:00:00 2001
From: Doni Pracner <donny@rarogl>
Date: Tue, 14 Apr 2015 18:12:34 +0200
Subject: [PATCH] Konverzija liste u i iz niza, lista koja se deli na dve

---
 kodovi/liste/ListeKonverzija.java | 167 +++++++++++++++
 kodovi/liste/ListePodela.java     | 339 ++++++++++++++++++++++++++++++
 2 files changed, 506 insertions(+)
 create mode 100644 kodovi/liste/ListeKonverzija.java
 create mode 100644 kodovi/liste/ListePodela.java

diff --git a/kodovi/liste/ListeKonverzija.java b/kodovi/liste/ListeKonverzija.java
new file mode 100644
index 0000000..a353cbd
--- /dev/null
+++ b/kodovi/liste/ListeKonverzija.java
@@ -0,0 +1,167 @@
+/**
+ * Primer pravljanja liste koja moze da se napravi od niza istog tipa elemenata
+ * i koja moze da napravi niz od svog sadrzaja.
+ *
+ */
+public class ListeKonverzija {
+
+	public static void main(String[] args) {
+		// demonstracija kako izgleda stampajniz
+		String[] ptice = new String[]{"golub", "vrana", "vrabac"};
+		System.out.println("niz:" + ptice); //toString od niza
+		stampajNiz(ptice);
+		
+		System.out.println();
+		
+		// pravimo novu listu od postojeceg niza
+		ListaN listaP = new ListaN();
+		listaP.dodajSve(ptice);
+		System.out.println(listaP);
+		listaP.dodaj("sova");
+		System.out.println(listaP);
+
+		System.out.println();
+
+		// ako nam je bitan redosled, onda koristimo drugi metod
+		ListaN druga = new ListaN();
+		druga.dodajSveUIstomRedosledu(ptice);
+		System.out.println(druga);
+
+		// mozemo dodavati i elemente druge liste
+		druga.dodajSve(listaP);
+		System.out.println(druga);
+		
+		System.out.println();
+		
+		// mozemo direktno u konstruktor da prosledimo niz
+		ListaN treca = new ListaN(ptice);
+		System.out.println(treca);
+		
+		System.out.println();
+		
+		// pravimo listu koju cemo pretvarati u niz
+		ListaN lista = new ListaN();
+
+		lista.dodaj("vrabac");
+		lista.dodaj("vrana");
+		lista.dodaj("golub");
+		lista.dodaj("albatros");
+
+		System.out.println(lista);
+
+		String[] niz = lista.napraviNiz();
+		System.out.println("niz:" + niz); //toString od niza
+		stampajNiz(niz);
+
+		String[] niz2 = lista.napraviNiz();
+		System.out.println("niz:" + niz2); //toString od niza
+		stampajNiz(niz2);
+		System.out.println("nizovi su jednaki:"+niz.equals(niz2));
+		
+		System.out.println();				
+	}
+
+	public static void stampajNiz(String[] niz) {
+		System.out.print("sadzaj niza:");
+		for (String s : niz) {
+			System.out.print('"' + s + '"' + ' ');
+		}
+		System.out.println();
+	}
+
+}
+
+/**
+ * Lista strigova koja omogucava da njen sadrzaj pretvori u niz, kao i da se
+ * lista napravi od niza, ili da se dodaju svi elementi iz nekog niza.
+ */
+class ListaN {
+
+	class Element {
+		String info;
+		Element veza;
+
+		public Element(String s) {
+			info = s;
+			veza = null;
+		}
+	}
+
+	// pokazivac na prvi element liste
+	Element prvi;
+
+	// interni brojac koji pomaze kod nekih operacija
+	int brojElemenata;
+
+	/** Kreira praznu listu. */
+	public ListaN() {
+		this.prvi = null;
+		this.brojElemenata = 0;
+	}
+
+	/** Kreira listu u kojoj je pocetni sadrzaj iskopiran iz prosledjenog niza */
+	public ListaN(String[] stringovi) {
+		this.dodajSveUIstomRedosledu(stringovi);
+	}
+
+	public String toString() {
+		String rez = "ListaN: [ ";
+		Element tekuci = prvi;
+		while (tekuci != null) {
+			rez += '"' + tekuci.info + "\" ";
+			tekuci = tekuci.veza;
+		}
+		rez += "]";
+		return rez;
+	}
+
+	/** vraca broj elemenata u listi */
+	public int velicina() {
+		return brojElemenata;
+	}
+
+	/** Vraca da li je lista prazna */
+	public boolean jePrazna() {
+		return prvi == null;
+	}
+
+	public void dodaj(String str) {
+		Element novi = new Element(str);
+		novi.veza = prvi;
+		prvi = novi;
+		brojElemenata++;
+	}
+
+	public void dodajSve(String[] stringovi) {
+		for (String s : stringovi) {
+			dodaj(s);
+		}
+	}
+
+	public void dodajSveUIstomRedosledu(String[] stringovi) {
+		for (int i = stringovi.length - 1; i >= 0; i--) {
+			dodaj(stringovi[i]);
+		}
+	}
+
+	public String[] napraviNiz() {
+		String[] niz = new String[brojElemenata];
+		Element tekuci = prvi;
+		int br = 0;
+		while (tekuci != null) {
+			niz[br] = tekuci.info;
+			br++;
+			tekuci = tekuci.veza;
+		}
+		return niz;
+	}
+	
+	public void dodajSve(ListaN lista) {
+		Element tekuci = lista.prvi;
+		while (tekuci != null) {
+			dodaj(tekuci.info);
+			tekuci = tekuci.veza;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/kodovi/liste/ListePodela.java b/kodovi/liste/ListePodela.java
new file mode 100644
index 0000000..fa71786
--- /dev/null
+++ b/kodovi/liste/ListePodela.java
@@ -0,0 +1,339 @@
+/**
+ * Progam predstavlja primere podele liste na dve, samo premestanje pokazivaca,
+ * odnosno bez zauzimanja memorije za nove elemente.
+ */
+public class ListePodela {
+
+	static void testNaizmenicnoPrviParan() {
+		DeljivaLista l = new DeljivaLista();
+		int n = 5;
+		for (int i = 0; i < n; i++) {
+			l.dodaj(i);
+		}
+		System.out.println("originalna lista:");
+		System.out.println(l);
+
+		System.out.println("nove liste:");
+		DeljivaLista l2 = l.izdvojParne();
+		System.out.println(l);
+		System.out.println(l2);
+	}
+
+	static void testNaizmenicnoPrviNeParan() {
+		DeljivaLista l = new DeljivaLista();
+		int n = 5;
+		for (int i = 0; i < n; i++) {
+			l.dodaj(i + 1);
+		}
+		System.out.println("originalna lista:");
+		System.out.println(l);
+
+		System.out.println("nove liste:");
+		DeljivaLista l2 = l.izdvojParne();
+		System.out.println(l);
+		System.out.println(l2);
+	}
+
+	static void testSviParni() {
+		DeljivaLista l = new DeljivaLista();
+		int n = 5;
+		for (int i = 0; i < n; i++) {
+			l.dodaj(i * 2);
+		}
+		System.out.println("originalna lista:");
+		System.out.println(l);
+
+		System.out.println("nove liste:");
+		DeljivaLista l2 = l.izdvojParne();
+		System.out.println(l);
+		System.out.println(l2);
+	}
+
+	static void testSviNeparni() {
+		DeljivaLista l = new DeljivaLista();
+		int n = 5;
+		for (int i = 0; i < n; i++) {
+			l.dodaj(i * 2 + 1);
+		}
+		System.out.println("originalna lista:");
+		System.out.println(l);
+
+		System.out.println("nove liste:");
+		DeljivaLista l2 = l.izdvojParne();
+		System.out.println(l);
+		System.out.println(l2);
+	}
+
+	static void testUzastopniParni() {
+		DeljivaLista l = new DeljivaLista();
+		l.dodaj(7);
+		int n = 3;
+		for (int i = 0; i < n; i++) {
+			l.dodaj(i * 2);
+		}
+		l.dodaj(5);
+		l.dodaj(8);
+		l.dodaj(5);
+
+		System.out.println("originalna lista:");
+		System.out.println(l);
+
+		System.out.println("nove liste:");
+		DeljivaLista l2 = l.izdvojParne();
+		System.out.println(l);
+		System.out.println(l2);
+	}
+
+	static void testPrvihN1() {
+		DeljivaLista l = new DeljivaLista();
+		int n = 5;
+		for (int i = 0; i < n; i++) {
+			l.dodaj(i);
+		}
+
+		System.out.println("originalna lista:");
+		System.out.println(l);
+
+		System.out.println("nove liste:");
+		DeljivaLista l2 = l.izdvojPrvihN(1);
+		System.out.println(l);
+		System.out.println(l2);
+	}
+	
+	static void testPrvihN0() {
+		DeljivaLista l = new DeljivaLista();
+		int n = 5;
+		for (int i = 0; i < n; i++) {
+			l.dodaj(i);
+		}
+
+		System.out.println("originalna lista:");
+		System.out.println(l);
+
+		System.out.println("nove liste:");
+		DeljivaLista l2 = l.izdvojPrvihN(0);
+		System.out.println(l);
+		System.out.println(l2);
+	}
+	
+	static void testPrvihN3() {
+		DeljivaLista l = new DeljivaLista();
+		int n = 5;
+		for (int i = 0; i < n; i++) {
+			l.dodaj(i);
+		}
+
+		System.out.println("originalna lista:");
+		System.out.println(l);
+
+		System.out.println("nove liste:");
+		DeljivaLista l2 = l.izdvojPrvihN(3);
+		System.out.println(l);
+		System.out.println(l2);
+	}
+	
+	static void testPrvihNN() {
+		DeljivaLista l = new DeljivaLista();
+		int n = 5;
+		for (int i = 0; i < n; i++) {
+			l.dodaj(i);
+		}
+
+		System.out.println("originalna lista:");
+		System.out.println(l);
+
+		System.out.println("nove liste:");
+		DeljivaLista l2 = l.izdvojPrvihN(n);
+		System.out.println(l);
+		System.out.println(l2);
+	}
+	
+	static void testPrvihNN1() {
+		DeljivaLista l = new DeljivaLista();
+		int n = 5;
+		for (int i = 0; i < n; i++) {
+			l.dodaj(i);
+		}
+
+		System.out.println("originalna lista:");
+		System.out.println(l);
+
+		System.out.println("nove liste:");
+		DeljivaLista l2 = l.izdvojPrvihN(n+1);
+		System.out.println(l);
+		System.out.println(l2);
+	}
+	
+	static void testPrvihN2N() {
+		DeljivaLista l = new DeljivaLista();
+		int n = 5;
+		for (int i = 0; i < n; i++) {
+			l.dodaj(i);
+		}
+
+		System.out.println("originalna lista:");
+		System.out.println(l);
+
+		System.out.println("nove liste:");
+		DeljivaLista l2 = l.izdvojPrvihN(2*n);
+		System.out.println(l);
+		System.out.println(l2);
+	}
+	
+	public static void main(String[] args) {
+		testNaizmenicnoPrviParan();
+		System.out.println();
+		testNaizmenicnoPrviNeParan();
+		System.out.println();
+		testSviParni();
+		System.out.println();
+		testSviNeparni();
+		System.out.println();
+		testUzastopniParni();
+		System.out.println();
+		System.out.println("Izdvajanje prvih 0:");
+		testPrvihN0();
+		System.out.println("Izdvajanje prvih 1:");
+		testPrvihN1();
+		System.out.println("Izdvajanje prvih 3:");
+		testPrvihN3();
+		System.out.println("Izdvajanje prvih N:");
+		testPrvihNN();
+		System.out.println("Izdvajanje prvih N+1:");
+		testPrvihNN1();
+		System.out.println("Izdvajanje prvih 2*N:");
+		testPrvihN2N();
+	}
+
+}
+
+/**
+ * Lista brojeva koja omogucava da se iz nje izdvoji nova lista u kojoj se
+ * nalaze samo parni brojevi.
+ */
+class DeljivaLista {
+
+	class Element {
+		int info;
+		Element veza;
+
+		public Element(int br) {
+			info = br;
+			veza = null;
+		}
+
+		public String toString() {
+			return info + "";
+		}
+
+	}
+
+	Element prvi;
+
+	public DeljivaLista() {
+		prvi = null;
+	}
+
+	public void dodaj(int br) {
+		Element novi = new Element(br);
+		novi.veza = prvi;
+		prvi = novi;
+	}
+
+	public String toString() {
+		String rez = "DeljivaLista: [ ";
+		Element tekuci = prvi;
+		while (tekuci != null) {
+			rez += tekuci.info + " ";
+			tekuci = tekuci.veza;
+		}
+		rez += "]";
+		return rez;
+	}
+
+	/**
+	 * Metod pravi novu listu koja se sastoji od izdvojenih parnih elemenata ove
+	 * liste, pri cemu se ne zauzima nova memorija. Nakon poziva ovog metoda
+	 * lista na kojoj je pozvan se sastoji samo od neparnih elemenata.
+	 * 
+	 * @return lista parnih elemenata ove liste
+	 */
+	public DeljivaLista izdvojParne() {
+		// buduci rezultat operacije
+		DeljivaLista parni = new DeljivaLista();
+
+		// da bi dodavali na kraj mozemo imati lokalnu
+		// promenljivu koja pamti gde je kraj
+		Element parniKraj = null;
+
+		Element tek, pret;
+
+		while (prvi != null && prvi.info % 2 == 0) {
+			tek = prvi;
+			prvi = prvi.veza;
+			if (parni.prvi == null) {
+				parni.prvi = tek;
+				parniKraj = tek;
+				tek.veza = null;
+			} else {
+				parniKraj.veza = tek;
+				tek.veza = null;
+				parniKraj = tek;
+			}
+		}
+
+		if (prvi != null) {
+			tek = prvi;
+			while (tek.veza != null) {
+				pret = tek;
+				tek = tek.veza;
+				if (tek.info % 2 == 0) {
+					pret.veza = tek.veza;
+					if (parni.prvi == null) {
+						parni.prvi = tek;
+						tek.veza = null;
+						parniKraj = tek;
+					} else {
+						parniKraj.veza = tek;
+						tek.veza = null;
+						parniKraj = tek;
+					}
+					tek = pret;
+				}
+			}
+		}
+
+		return parni;
+	}
+
+	/**
+	  * Vraca novu listu koja se sastoji od prvih `n` elemenata
+	  * ove liste, a ova lista se nakon poziva sastoji od ostatka.
+	  * U slucaju da je `n` nepozitivan broj bice vracena prazna lista,
+	  * a u slucaju da je `n` vece ili jednako broju elemenata u listi
+	  * nova lista ce se sastojati od cele ove liste, a ova ce ostati
+	  * prazna.
+	  */
+	public DeljivaLista izdvojPrvihN(int n) {
+		DeljivaLista rezultat = new DeljivaLista();
+		if (n <= 0) {
+			return rezultat;
+		}
+		
+		rezultat.prvi = prvi;
+
+		int brojac = 0;
+		Element poslednji = prvi;
+		while (poslednji != null && brojac < n - 1) {
+			poslednji = poslednji.veza;
+			brojac++;
+		}
+		if (poslednji != null) {
+			prvi = poslednji.veza;
+			poslednji.veza = null;
+		} else {
+			prvi = null;
+		}
+		return rezultat;
+	}
+}
-- 
2.17.1