$$ \newcommand{\floor}[1]{\left\lfloor{#1}\right\rfloor} \newcommand{\ceil}[1]{\left\lceil{#1}\right\rceil} \newcommand{\mod}{\,\mathrm{mod}\,} \renewcommand{\div}{\,\mathrm{div}\,} \newcommand{\metar}{\,\mathrm{m}} \newcommand{\cm}{\,\mathrm{cm}} \newcommand{\dm}{\,\mathrm{dm}} \newcommand{\litar}{\,\mathrm{l}} \newcommand{\km}{\,\mathrm{km}} \newcommand{\s}{\,\mathrm{s}} \newcommand{\h}{\,\mathrm{h}} \newcommand{\minut}{\,\mathrm{min}} \newcommand{\kmh}{\,\mathrm{\frac{km}{h}}} \newcommand{\ms}{\,\mathrm{\frac{m}{s}}} \newcommand{\mmin}{\,\mathrm{\frac{m}{min}}} \newcommand{\smin}{\,\mathrm{\frac{s}{min}}} $$

Nizovi

  • Dozvoljeno polaganje
  • -
  • Nema
  • Jovan Popović
  • 2/10/2017

Do sada smo koristili jednostavne promenljive, koje sadrže jedan podatak (npr. vrednost jednog broja ili stringa). Zamislite sada da imamo grupu sličnih objekata, koje želimo da koristimo zajedno – u tom slučaju bi nam trebao neki mehanizam da ih grupišemo. Na primer, potrebno je da imamo skup ocena koje je dobio neki učenik. Mi možemo da napravimo 10 promenljivih kao što su ocena0, ocena1, ocena2, itd. gde bi svaka promenljiva predstavljala jednu ocenu učenika, a u svaku od njih bi bila upisana odgovarajuća ocena. Mogli bismo da nađemo najveću ocenu, ili srednju ocenu tako što bismo ih pojedinačno sabirali ili poredili. Međutim, u slučaju da imamo veliki broj podataka (ocena), umesto ovakvih promenljivih potrebna nam je neka promenljiva koja bi sadržala sve ocene, gde bismo mogli da uzmemo svaku od pojedinačnih ocena po rednom broju. Nizovi su upravo ovakve promenljive. Niz je složena promenljiva koja sadrži više drugih promenljivih u sebi. Svaka promenljiva u nizu ima svoj redni broj (ili indeks, kako ćemo ga zvati u nastavku), pomoću kog se može naći vrednost koja nam treba. Kao što promenljive možemo da zamislimo kao kutije u kojima se nalaze vrednosti, nizove možemo da zamislimo kao grupe kutija gde svaka kutija ima svoj redni broj (koje ćemo od sada zvati indeksi):

Promenljive u nizu su kao kutije na polici

Svakoj pojedinačnoj promenljivoj u nizu (zvaćemo ih elementi niza) možemo pristupiti po njenom rednom broju tj. indeksu i u nju se može ili ubaciti neka vrednost ili pročitati vrednost iz nje. Treba imati na umu da PRVI element u nizu ima indeks 0 – ovo pravilo je karakteristično za većinu programskih jezika. Ako imamo promenljivu koja se zove brojevi i predstavlja niz, onda možemo da dođemo do elemenata u tom nizu tako što iza imena niza stavimo uglaste zagrade i u njih redni broj. U sledećem primeru ćemo u elemente niza sa redim brojevima 0, 1 i 2 upisati neke brojeve, a onda ćemo pročitati vrednosti iz tih elemenata, da bismo ih sabrali i zbir ćemo upisati u promenljivu zbir:

br[0] = 10
br[1] = 3
br[2] = 200
zbir = br[0]  + br[1] + br[2]

Niz se pravi tako što se unutar uglastih zagrada navedu vrednosti koje će biti upisane u elemente niza:

br = [10, 8, 26, 5, 3, 12]

Još jedna korisna mogućnost: ako iza imena niza stavimo .length dobićemo koliko ima elemenata u nizu (npr. br.length predstavlja broj elemenata u nizu br). Sledeći program će prikazati u poruci koliko ima elemenata u nizu:

alert("Niz ima " + br.length + " elemenata")

Jedan potpuni program koji pravi novi niz brojeva, prikazuje koliko ima elemenata, i petljom ponavlja naredbu koja prikazuje vrednost elementa je prikazan u sledećem programu:

br = [10, 8, 26, 5, 3, 12]
console.log("Broj elemenata u nizu je: " + br.length)
i = 0
while ( i < br.length ) {
  console.log("Broj: " + br[i])
  i = i + 1
}

Vratimo se na naš primer sa ocenama učenika. Pretpostavimo da je učenik dobio ocene 4, 5, 2 i 5. Program koji bi prikazao koliko učenik ima ocena, koja je prva ocena i koja je srednja ocena je prikazan u sledećem primeru:

ocene = [4, 5, 2, 5]
console.log("Broj ocena je: " + ocene.length)
console.log("Prva ocena koju je dobio ucenik je: " + ocene[0])
srednjaOcena = 0
i=0
while(i<ocene.length)
{
	srednjaOcena = srednjaOcena + ocene[i]
	i = i + 1
}
srednjaOcena = srednjaOcena / ocene.length

Da smo umesto niza ocena napravili posebne promenljive ocena1, ocena2, ocena3 i ocena4 program bi bio mnogo teži, a bilo bi potrebno više prepravljanja ako bismo imali drugačiji (mnogo veći) broj ocena.

U nekim jezicima je prilikom definisanja niza potrebno navesti njegovu dužinu (tj. koliko će imati elemenata). U JavaScript-u ovo nije potrebno - svaki put kada pokušate da upišete neku vrednost u element niza sa nekim indeksom, niz će automatski biti proširen do indeksa koji vam je potreban.

var ocene = []
ocene[0] = 4
ocene[1] = 5
ocene[2] = 2
ocene[3] = 5

Prvo smo napravili prazan niz. Kada smo upisali prvu ocenu, niz je automatski uvećan za jedan, kako bi se obezbedilo mesto za novu promenljivu. Svaki naredni upis će na isti način automatski proširiti niz kako bi se obezbedilo da ima dovoljno mesta.

Primer - Sabiranje brojeva u nizu

Pronalaženje zbira, ili proizvoda brojeva u nizu je verovatno najčešći problem koji ćete rešavati. Prvo ćemo definisati promenljivu u kojoj će biti zbir elemenata. Početna vrednost ove promenljive će biti nula. Onda ćemo proći kroz niz, uzeti svaki element i njegovu vrednost dodati u zbir. U sledećem primeru je prikazana funkcija koja izračunava zbir elemenata niza na ovaj način:

function zbir ( niz ) {
  zbir = 0
  i = 0
  while ( i< niz.length ) {
	  zbir = zbir + niz[i]
	  i = i + 1
  }
  return zbir
}

Primer - provera da li su svi brojevi u nizu veći od nule

U ovom primeru ćemo napraviti funkciju koja proverava da li su svi brojevi u nizu pozitivni (tj. veći od nule). Ako jesu, funkcija vraća TAČNO. Prvo ćemo definisati logičku promenljivu, koja će govoriti da li su svi brojevi u nizu pozitivni. Pretpostavićemo da jesu. Potom ćemo proći kroz niz i za svaki element proveriti da li je manji od nule - ako jeste, upisaćemo vrednost false u promenljivu.

function sviSuPozitivni ( niz ) {
  pozitivni = true
  i = 0
  while ( i < niz.length ) {
    if( niz[i] < 0 ) { 
		  pozitivni = false
	  }
    i = i + 1
  }
  return pozitivni
}

Primer - rastući niz

U datom nizu brojeva proveriti da li su elementi poređani u rastućem redosledu.

function nizJeRastuci ( niz ) {
  rastuci = true
  i = 0
  while( i< niz.length - 2 ) {
    if(niz[i] > niz[i+1]) {
		  rastuci = false
	  }
	  i = i + 1
  }
  return rastuci
}

Primer - Najmanji element niza

Za dati niz brojeva potrebno je naći najmanji element. Minimum ćemo naći tako što prvo pretpostavimo da je najmanji element u nizu prvi element, a onda ćemo proći kroz sve elemente niza i za svaki od njih proveriti da li je manji od trenutnog minimuma. Ako jeste, onda ćemo u minimum upisati vrednost tog elementa niza.

function minimum ( niz ) {
  min = niz[0]
  i=1
  while ( i < niz.length ) {
    if(niz[i] < min) {
      min = niz[i]
    }
	  i = i + 1
  }
}

Obratite pažnju da indeksi niza u petlji idu od 1 do poslednjeg. Mogli bismo da koristimo indekse od nule ali bismo u tom slučaju u prvoj iteraciji poredili vrednost niz[0] sa minimumom koji je inicijalno već jednak vrednosti u niz[0]. Iako na ovaj način ne bismo napravili grešku, prva iteracija bi bila uzaludna.

Primer - razvrstavanje brojeva u nizu

Potrebno je napisati program koja od niza brojeva formira dva niza: jedan u kome su svi parni i drugi u kome su svi neparni brojevi.

Razvrstavanje brojeva na parne i neparne

Rešenje je prikazano u sledećem primeru. Program prolazi kroz elemente niza koje razvrstava u nizove parni i neparni.

// niz koji treba razvrstati na parne i neparne:
brojevi = [3,7,6,8,5,2,1,6,4,6,8,1,5,2]

// Nizovi u kojima će biti rezultati (na početku su prazni):
parni = []
neparni = []

//Glavni program:
i=0
while ( i < brojevi.length )
{
    if( brojevi[i] % 2 == 0) {
        parni.push(brojevi[i])  // Ako je broj paran dodaj ga u parne
    } else {
        neparni.push(brojevi[i]) // Ako je neparan dodaj ga u neparne
    }
    i = i + 1                   // i uvećaj za jedan da bi prešao na sledeći element niza
}

alert("Parni: " + parni)
alert("Neparni: " + neparni)

Prvo napravimo prazne nizove za parne i neparne brojeve. Potom prolazimo kroz sve elemente niza brojeva i ako je trenutni element paran stavljamo ga u niz parnih, a ako je neparan onda ide u niz neparnih.

Primer - koliko puta je unet broj

Uradimo još jedan primer da bismo se uhodali u radu sa nizovima. Recimo da se unose jednocifreni brojevi sve dok se ne unese -1. Ono što hoćemo da uradimo je da ispišemo koliko puta se svaki od brojeva pojavio. Pogledajmo kako bismo to uradili:

brojPojavljivanja = []

// Unosimo broj i proveravamo da li je različit od -1
// Ako jeste uvećamo broj pojavljivanja za 1  unesemo sledeći
broj = prompt("Unesite novi broj (ili -1 za kraj):")
while (broj != -1) {
  // Ako broj nije u nizu broj pojavljivanja mu je 0.
  if(!brojPojavljivanja[broj]) {
  	brojPojavljivanja[broj] = 0
  }
  brojPojavljivanja[broj] = brojPojavljivanja[broj] + 1
  broj = prompt("Unesite novi broj (ili -1 za kraj):")
}

// Na kraju, prođemo kroz sve elemente niza
// i prikažemo koliko puta se svaki broj pojavio.
for( indeks in brojPojavljivanja ) {
	alert( "Broj " + indeks + " je unet " + brojPojavljivanja[indeks] + " puta." )
}