B5

import java.util.Arrays;

public abstract class TriediaciAlgoritmus {

        /**
         * Aktualne usporiadavane pole
         */
        private int[] p;

        private int pocetVymen = 0;
        private int pocetPorovnani = 0;

        public int getPocetPorovnani() {
                return pocetPorovnani;
        }

        public int getPocetVymen() {
                return pocetVymen;
        }

        /**
         * 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) {
                pocetVymen++;
                int pom = p[idx1];
                p[idx1] = p[idx2];
                p[idx2] = pom;
        }

        /**
         * 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;
                pocetVymen = 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 QuickSort extends TriediaciAlgoritmus {

        @Override
        protected void utried(int dlzkaPola) {
                quickSort(0, dlzkaPola - 1);
        }

        public int rozdel(int odIdx, int poIdx) {
                // nahodny pivot
                int idxPivota = odIdx + (int) (Math.random() * (poIdx - odIdx + 1));
                vymen(idxPivota, poIdx);

                int idx = odIdx;
                for (int i = odIdx; i <= poIdx - 1; i++)
                        if (porovnaj(i, poIdx) < 0) {
                                vymen(i, idx);
                                idx++;
                        }

                vymen(idx, poIdx);
                return idx;
        }

        private void quickSort(int odIdx, int poIdx) {
                System.out.println("Q(" + odIdx + ", " + poIdx + ")");
                if (odIdx >= poIdx)
                        return;

                int pivotIdx = rozdel(odIdx, poIdx);
                quickSort(odIdx, pivotIdx - 1);
                quickSort(pivotIdx + 1, poIdx);
        }

}

import java.util.Arrays;

public class Spustac {

        public static int hodnotaVStrome(int[] pole, String cesta) {
                int idxVStrome = 0;
                for (int i = 0; i < cesta.length(); i++) {
                        if (cesta.charAt(i) == 'L') {
                                idxVStrome = idxVStrome * 2 + 1;
                        } else {
                                idxVStrome = idxVStrome * 2 + 2;
                        }
                }

                return pole[idxVStrome];
        }

        public static boolean jeHaldou(int[] pole) {
                for (int i = 1; i < pole.length; i++) {
                        int idxRodica = (i - 1) / 2;
                        if (pole[idxRodica] < pole[i])
                                return false;
                }

                return true;
        }

        /**
         * @param args
         */
        public static void main(String[] args) {
                // int[] pole = new int[10];
                // for (int i=0; i<pole.length; i++)
                // pole[i] = (int)(Math.random() * 100);

                int[] pole = { 1, 4, 2, 3, 7, 6, 10, 9, 8, 5 };
                System.out.println(Arrays.toString(pole));

                TriediaciAlgoritmus algoritmus = new QuickSort();
                algoritmus.utried(pole);
                System.out.println("Porovnania:" + algoritmus.getPocetPorovnani());
                System.out.println("Vymeny:" + algoritmus.getPocetVymen());
                System.out.println(Arrays.toString(pole));
                int[] strom = { 8, 3, 2, 10, 5, 1, 6, 12, 1, 3 };
        }

}

import java.util.Arrays;

public class Spustac {

        public static int[] zluc(int[] p1, int[] p2) {
                int[] p = new int[p1.length + p2.length];
                int p1Idx = 0;
                int p2Idx = 0;
                int pIdx = 0;
                while (p1Idx < p1.length && p2Idx < p2.length) {
                        if (p1[p1Idx] < p2[p2Idx]) {
                                p[pIdx] = p1[p1Idx];
                                p1Idx++;
                        } else {
                                p[pIdx] = p2[p2Idx];
                                p2Idx++;
                        }
                        pIdx++;
                }
                while (p1Idx < p1.length) {
                        p[pIdx] = p1[p1Idx];
                        p1Idx++;
                        pIdx++;
                }
                while (p2Idx < p2.length) {
                        p[pIdx] = p2[p2Idx];
                        p2Idx++;
                        pIdx++;
                }
                return p;
        }

        public static void main(String[] args) {
                int[] p1 = {};
                int[] p2 = { 1, 4, 6, 10};
                int[] p = zluc(p1, p2);
                System.out.println(Arrays.toString(p));
        }
}