C2

public class Cvicenie {

        public static boolean jeUsporiadane(int[] p) {
                if (p == null || p.length == 0)
                        return true;

                for (int i = 0; i < p.length - 1; i++) {
                        if (p[i] > p[i+1])
                                return false;
                }
                return true;
    }

        public static int binarneHladajIndex(int[] p, int hodnota) {
                if (p == null || p.length == 0)
                        return -1;

                int odIdx = 0;
                int poIdx = p.length - 1;
                while (odIdx <= poIdx) {
                        int stredIdx = (odIdx + poIdx) / 2;
                        if (p[stredIdx] == hodnota)
                                return stredIdx;
                        if (hodnota < p[stredIdx]) {
                                poIdx = stredIdx - 1;
                        } else {
                                odIdx = stredIdx + 1;
                        }
                }
                return -1;
        }

        public static void main(String[] args) {
                int[] p = new int[] {1, 2, 4, 7, 9, 11, 20, 35};
                System.out.println(binarneHladajIndex(p, 27));
                System.out.println(binarneHladajIndex(p, 35));

//              int[] p = new int[] {1, 2, 3, 4, 5, 6};
//              System.out.println(jeUsporiadane(p));
//              int[] p2 = new int[] {1, 2, 3, 7, 5, 6};
//              System.out.println(jeUsporiadane(p2));
        }
}

import java.util.Arrays;

public abstract class TriediaciAlgoritmus {

        /**
         * Aktualne usporiadavane pole
         */
        private int[] p;
        private int pocetVymien;
        public int getPocetVymien() {
                        return pocetVymien;
                }

        private int pocetPorovnani;
        public int getPocetPorovnani() {
                        return pocetPorovnani;
                }

                /**
         * Porovna prvky v poli na zadanych indexoch
         *
         * @return vrati zaporne cislo, ak p[idx1] < p[idx2],
         *                 0, ak p[idx1]==p[idx2], a
         *         kladne cislo, ak p[idx1] > p[idx2]
         */
        protected int porovnaj(int idx1, int idx2) {
                        pocetPorovnani++;
                return p[idx1] - p[idx2];

                /*
                 * Alternativa:
                 * if (p[idx1] < p[idx2]) return -1;
                 * if (p[idx1] > p[idx2]) return 1;
                 * return 0;
                 */
        }

        /**
         * Vymeni prvky v usporiadavanom poli na zadanych indexoch
         */
        protected void vymen(int idx1, int idx2) {

                int pom = p[idx1];
                p[idx1] = p[idx2];
                p[idx2] = pom;
                pocetVymien++;
        }

        /**
         * Vypise pole
         */
        protected void vypisPole() {
                Arrays.toString(p);
        }

        /**
         * Usporiada prvky v poli od najmensieho po najvacsie
         *
         * @param p
         *            pole, ktoreho prvky maju byt usporiadane
         */
        public void utried(int[] p) {
                this.p = p;
                pocetVymien = 0;
                pocetPorovnani = 0;
                utried(p.length);
                this.p = null;
        }

        /**
         * Metoda, ktora implementuje triedenie podla urciteho algoritmu
         * @param dlzkaPola dlzka (pocet prvkov) usporiadavaneho pola
         */
        protected abstract void utried(int dlzkaPola);
}
 

public class BubbleSort extends TriediaciAlgoritmus {

        @Override
        protected void utried(int dlzkaPola) {
                for (int i = 0; i < dlzkaPola; i++) {
                        boolean bolaVymena = false;
                        for (int j = 0; j < dlzkaPola - 1 - i; j++) {
                                if (porovnaj(j, j+1) > 0) {
                                        vymen(j, j+1);
                                        bolaVymena = true;
                                }
                        }
                        if (!bolaVymena)
                                return;
                }
        }

}

public class SelectionSort extends TriediaciAlgoritmus {

        @Override
        protected void utried(int dlzkaPola) {
                for (int i = 0; i < dlzkaPola; i++) {
                        int najIdx = indexNajmensieho(i, dlzkaPola);
                        vymen(i, najIdx);
                }

        }

        public int indexNajmensieho(int odIdx, int poIdx) {
                int najIdx = odIdx;
                for (int i = odIdx + 1; i <= poIdx; i++)
                        if (porovnaj(i, najIdx) < 0)
                                najIdx = i;
                return najIdx;
        }

}

import java.util.Arrays;


public class Spustac {

        public static void main(String[] args) {
                int p[]= new int[]{5,2,11,25,9,8,-2,0,-6,12};
                int pole[]= new int[]{5,2,11,25,9,8,-2,0,-6,12};



                BubbleSort bs = new BubbleSort();
                SelectionSort ss = new SelectionSort();

                bs.utried(p);
                /*System.out.println(Arrays.toString(p));
                System.out.println(bs.getPocetVymien());
                System.out.println("Pocet porovnani: "+bs.getPocetPorovnani());

                ss.utried(pole);
                System.out.println(Arrays.toString(pole));
                System.out.println(ss.getPocetVymien());
                System.out.println("Pocet porovnani: "+ss.getPocetPorovnani());*/

                bs.utried(p);
                System.out.println(Arrays.toString(p));
                System.out.println(bs.getPocetVymien());
                System.out.println("Pocet porovnani: "+bs.getPocetPorovnani());

                ss.utried(p);
                System.out.println(Arrays.toString(p));
                System.out.println(ss.getPocetVymien());
                System.out.println("Pocet porovnani: "+ss.getPocetPorovnani());
        }
}
 

public class Zlozitost {

        // Celkovy pocet zrealizovanych operacii
        public static int pocet = 0;

        // Elementarna operacia
        public static void operacia() {
                pocet++;
        }

        // Linearny pocet operacii v zavislosti od n
        public static void linearna(long n) { //2500000000L
                for (int i = 0; i < n; i++)
                        operacia();
        }

        // n.log(n) pocet operacii v zavislosti od n
        public static void nlogn(int n) { //100000000
                for (int i = 0; i < n; i++)
                        for (int j = 1; j < n; j = j * 2)
                                operacia();
        }

        // Kvadraticky pocet operacii v zavislosti od n
        public static void kvadraticka(int n) { //50000
                for (int i = 0; i < n; i++)
                        for (int j = 0; j < n; j++)
                                operacia();
        }

        // Exponencialny pocet operacii v zavislosti od n
        public static void exponencialna(int n) { //31
                if (n <= 1) {
                        operacia();
                        return;
                }

                // 2^n = 2*2^(n-1)
                exponencialna(n - 1);
                exponencialna(n - 1);
        }

        public static void main(String[] args) {
                System.out.println("Zaciatok...");
                long zaciatok = System.nanoTime();

                linearna(2200000000L);

                long koniec = System.nanoTime();
                System.out.println("Cas behu: " + ((koniec - zaciatok) / 1000000)
                                + " milisekund");
        }
}