Riešenia (skupina A, 5. týždeň)

import java.util.Arrays;

public abstract class TriediaciAlgoritmus {

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

        /**
         * 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) {
                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;
        }

        /**
         * Vypise pole
         */
        protected void vypisPole() {
                System.out.println(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;
                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) {
                // TODO Auto-generated method stub
                quickSort(0, dlzkaPola-1);
        }

        public void quickSort(int odIdx, int poIdx) {
                if (odIdx >= poIdx)
                        return;
                int pivotIdx = rozdel(odIdx, poIdx);
                quickSort(odIdx, pivotIdx - 1);
                quickSort(pivotIdx + 1, poIdx);
        }

        public int rozdel(int odIdx, int poIdx) {
                int pivot = p[poIdx];

                int idx = odIdx;
                for (int i = odIdx; i <= poIdx - 1; i++)
                        if (p[i] < pivot) {
                                vymen(i, idx);
                                idx++;
                        }
                vymen(idx, poIdx);
                return idx;
        }
}

import java.util.Arrays;


public class Tester {

        public static void main(String[] args) {
                QuickSort qs = new QuickSort();
                int p[] = new int[]{9,8,5,4,3,2,11,1};
                qs.utried(p);
                qs.vypisPole();
        }
}

import java.util.Arrays;

public class Tester {

        /**
         * @param args
         */
        public static void main(String[] args) {
                int[] p = { 2, 4, 6 };
                int[] p1 = { 1, 3, 5, 7 };
                System.out.println(Arrays.toString(p));
                System.out.println(Arrays.toString(p1));
                System.out.println(Arrays.toString(zluc(p, p1)));
                // System.out.println(jeHaldou(p));
        }

        public static int[] zluc(int[] p1, int[] p2) {

                int index1 = 0;
                int index2 = 0;
                int[] pole = new int[p1.length + p2.length];
                int poc = 0;
                while ((index1 < p1.length) && (index2 < p2.length)) {
                        if (p1[index1] > p2[index2]) {
                                pole[poc] = p2[index2];
                                index2++;
                                poc++;
                        } else {
                                pole[poc] = p1[index1];
                                index1++;
                                poc++;
                        }

                }

                for (int i = index2; i < p2.length; i++) {
                        pole[poc] = p2[index2];
                        poc++;

                }
                for (int i = index1; i < p1.length; i++) {
                        pole[poc] = p1[index1];
                        poc++;

                }
                return pole;

        }

        public static int hodnotaVStrome(int[] pole, String cesta) {
                int pom = 0;
                for (int i = 0; i < cesta.length(); i++) {

                        if (cesta.charAt(i) == 'l') {
                                pom = pom * 2 + 1;
                        } else
                                pom = pom * 2 + 2;

                }

                return pole[pom];

        }

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