算法03-分治算法

算法03-分治算法

1.分治算法-快速排序

public class QuickSort {

    public void printArrays(int[] arrays) {
        for (int array : arrays)
            System.out.println(array);
    }

    public void quickSortForRecursion(int[] arrays) {
        quickSortForRecursion(arrays, 0, arrays.length - 1);
    }

    public void quickSortForRecursion(int[] arrays, int left, int right) {
        if (left < right) {
            int comparableData = arrays[left];
            int start = left;
            int end = right;
            while (start < end) {
                // form end start
                while (start < end && arrays[end] >= comparableData)
                    end--;

                // need interactive location
                if (start < end)
                    arrays[start++] = arrays[end];

                while (start < end && arrays[start] < comparableData)
                    start++;

                if (start < end)
                    arrays[end--] = arrays[start];
            }

            // comparable data inert into middle
            arrays[start] = comparableData;

            // divide and rule
            // handle left that comparable data
            quickSortForRecursion(arrays, left, start - 1);
            // handle right that comparable data
            quickSortForRecursion(arrays, end + 1, right);
        }
    }

    public void quickSortForIterator(int[] arrays) {
        // use queue replace recursion
        Queue<Integer> queue = new LinkedList<>();
        int start = 0, left;
        int end = arrays.length - 1, right;

        queue.add(start);
        queue.add(end);
        while (!queue.isEmpty()) {
            left = start = queue.poll();
            right = end = queue.poll();

            System.out.println("left " + left + " right:" + right);
            int comparableData = arrays[start];
            // like recursion
            while (start < end) {

                while (start < end && arrays[end] >= comparableData)
                    end--;

                if (start < end)
                    arrays[start++] = arrays[end];

                while (start < end && arrays[start] < comparableData)
                    start++;

                if (start < end)
                    arrays[end--] = arrays[start];
            }

            if (start <= end)
                arrays[start] = comparableData;

            if (left < start) {
                queue.add(left);
                queue.add(start - 1);
            }

            if (end < right) {
                queue.add(end + 1);
                queue.add(right);
            }
        }
    }

    public static void main(String[] args) {
        QuickSort sort = new QuickSort();
        int[] arrays = {3, 2, 4, 7, 5, 8, 6, 9, 2, 4, 7, 0};

        //sort.quickSortForRecursion(arrays);
        sort.quickSortForIterator(arrays);
        sort.printArrays(arrays);
    }
}