[JavaScript] Sortiranje šumnikov

primer sortirane tabele

/********************************************************************** 
		 ** sortiraj record_delo kot je bilo zahtevano s parametri 		     **
		 **														   		     **
		 ** poCemNajSortiram = 0: DATUM							   		     **
		 **					 = 1: PODROCJE						   		     **
		 **					 = 2: STORITEV						   		     **
		 **					 = 3: OPIS							   		     **
		 **					 = 4: URE							   		     **
		 **					 = 5: KONTAKT						   		     **
		 **					 = 6: NAROCNIK						   		     **
		 **					 = 7: TIP							   		     **
		 **														   		     **
		 ** kakoNajSortiram = "AZ" - od najmanjsega do najvecjega  		     **
		 ** 				= "ZA" - od najvecjega do najmanjsega  		     **
		 **																     **
		 **																     **
		 **	- Sortirni algoritem uporablja prej definirano abecedo.			 **
		 **   Pri dodajanju novih crk ali znakov se morajo dodajati v parih. **
		 **   Na prosto neparno stevilo se da lowercase znaka, na naslednjo  **
		 **   pa njegov uppercase, ce znak nima uppercase ga vseeno dodamo   **
		 **   v paru na neparno in naslednje parno stevilo				     **
		 ** - Ce se najde znak, ki ni definiran v abecedi dobi 				 **
		 **   prioriteto pred vsemi definiranimi							 **
		 ** - Uppercase prioriteta se bo upostevala samo pri prvi besedi	 **
		 **   oz. dokler ne naletimo na prvi presledek						 **
		 **********************************************************************/
		int primerjava = 0;
		String[][] tempek = new String[1][1];
		String[][] abeceda = {{"1",  "a"},
							  {"2",  "A"},
							  {"3",  "b"},
							  {"4",  "B"},
							  {"5",  "c"},
							  {"6",  "C"},
							  {"7",  "č"},
							  {"8",  "Č"},
							  {"9",  "ć"},
							  {"10", "Ć"},
							  {"11", "d"},
							  {"12", "D"},
							  {"13", "đ"},
							  {"14", "Đ"},
							  {"15", "e"},
							  {"16", "E"},
							  {"17", "f"},
							  {"18", "F"},
							  {"19", "g"},
							  {"20", "G"},
							  {"21", "h"},
							  {"22", "H"},
							  {"23", "i"},
							  {"24", "I"},
							  {"25", "j"},
							  {"26", "J"},
							  {"27", "k"},
							  {"28", "K"},
							  {"29", "l"},
							  {"30", "L"},
							  {"31", "m"},
							  {"32", "M"},
							  {"33", "n"},
							  {"34", "N"},
							  {"35", "o"},
							  {"36", "O"},
							  {"37", "p"},
							  {"38", "P"},
							  {"39", "q"},
							  {"40", "Q"},
							  {"41", "r"},
							  {"42", "R"},
							  {"43", "s"},
							  {"44", "S"},
							  {"45", "š"},
							  {"46", "Š"},
							  {"47", "t"},
							  {"48", "T"},
							  {"49", "u"},
							  {"50", "U"},
							  {"51", "v"},
							  {"52", "V"},
							  {"53", "w"},
							  {"54", "w"},
							  {"55", "x"},
							  {"56", "X"},
							  {"57", "y"},
							  {"58", "Y"},
							  {"59", "z"},
							  {"60", "Z"},
							  {"61", "ž"},
							  {"62", "Ž"},
							  {"63", " "},
							  {"64", " "}};
				
		
		int i = 0;
		int j = 0;
		int k = 0;
		int l = 0;
		int i_jek = 0;
		int j_jek = 0;
		int kateriJeManjsi = 0;
		int kjeIma_i_prviUpperCase = -1;
		int kjeIma_j_prviUpperCase = -1;
		int nehajGledatiUpperCase_i = 0;
		int nehajGledatiUpperCase_j = 0;
		for (i = 0 ; i < steviloDelIzBaze-1 ; i++) // bubble sort zunanja zanka
		{
			for (j = i+1 ; j < steviloDelIzBaze ; j++) // bubble sort notranja zanka
			{
				// kateri niz je manjsi? zanka ki gleda crke se bo obrnila samo do najmanjsega
				if (record_delo[i][3].length() > record_delo[j][3].length()) 
				{ kateriJeManjsi = record_delo[j][3].length(); }
				else
				{ kateriJeManjsi = record_delo[i][3].length(); }
				
				if (kateriJeManjsi > 0) // oba niza sta bila null?
				{
					k = 0;
					do // vzemi trenutna niza ki se bosta primerjala in ju preleti crko za crko
					{
						// ce bosta ostala na 0 pomeni, da smo naleteli na poseben znak, 
						// ki ga nismo definirali v nasi abecedi in ta bo dobil prioriteto
						i_jek = 0; 
						j_jek = 0;
						
						l = 0;
						do // trenutno crko prvega niza najdi v abecedi
						{
							if (record_delo[i][3].substring(k, k+1).equals(abeceda[l][1])) 
							{ i_jek = Integer.parseInt(abeceda[l][0]); break; }
							l++;
						}
						while(l < abeceda.length);
					
						l = 0;
						do // trenutno crko drugega niza najdi v abecedi
						{
							if (record_delo[j][3].substring(k, k+1).equals(abeceda[l][1])) 
							{ j_jek = Integer.parseInt(abeceda[l][0]); break; }
							l++;
						}
						while(l < abeceda.length);
						
						
						// poglej, ce je razlika v teh dveh crkah samo uppercase, torej samo -1 v arrayju abecede
						// ce bosta niza enaka bo zmagal tisti, ki je prej imel uppercase
						if ((i_jek - 1 == j_jek) && (nehajGledatiUpperCase_i == 0))
						{ 
							i_jek = j_jek; // i_jek in j_jek izenacimo da nebomo padli ven iz while zanke
							if (kjeIma_i_prviUpperCase == -1) // samo ce ga se nismo nasli
							{ kjeIma_i_prviUpperCase = k; }
						} 
						if ((j_jek - 1 == i_jek) && (nehajGledatiUpperCase_j == 0))
						{ 
							i_jek = j_jek; // i_jek in j_jek izenacimo da nebomo padli ven iz while zanke 
							if (kjeIma_j_prviUpperCase == -1) // samo ce ga se nismo nasli
							{ kjeIma_j_prviUpperCase = k; }
						}
						
						if ((i_jek == 63) || (i_jek == 64)) // nasli smo presledek v prvi besedi
						{ nehajGledatiUpperCase_i = 1; }
						
						if ((j_jek == 63) || (j_jek == 64)) // nasli smo presledek v drugi besedi
						{ nehajGledatiUpperCase_j = 1; }
						
						k++;
					}
					while(((i_jek == j_jek) && (k != kateriJeManjsi))); // dokler sta trentni crki enaki in nismo prisli do konca najmanjsega niza
				}//end if
				
								
				// odlocitev, ali je potrebna zamenjava
				// prisli smo do konca manjsega niza, niza sta enaka in prvi je samo daljsi
				if ((i_jek == j_jek) && (record_delo[i][3].length() > record_delo[j][3].length()))
				{ primerjava = 1; }
				else
				{
					// niza se razlikujeta samo po uppercase
					if (((i_jek == j_jek) || (j_jek - 1 == i_jek) || (i_jek - 1 == j_jek)) && (record_delo[i][3].length() == record_delo[j][3].length()))
					{
						if ((kjeIma_i_prviUpperCase > kjeIma_j_prviUpperCase)) // zmaga tisti, ki ima prej uppercase
						{ primerjava = 1; }
					}
					else
					{
						// drugi niz se je koncal na crko z vecjo prioriteto in ta ni samo lowercase prve
						if ((j_jek < i_jek) && (i_jek - 1 != j_jek))
						{ primerjava = 1; }
					}
				}
				
				if (primerjava == 1) // naredi zamenjavo
				{
					tempek[0]      = record_delo[i];
					record_delo[i] = record_delo[j];
					record_delo[j] = tempek[0];
				}
				
				// resetiraj primerjalne spremenljivke za naslednji par nizov
				primerjava = 0;
				kjeIma_i_prviUpperCase = -1;
				kjeIma_j_prviUpperCase = -1;
				nehajGledatiUpperCase_i = 0;
				nehajGledatiUpperCase_j = 0;
			}
		}