05 快速排序 QuickSort

第5节.pptx

1 快速排序

01 引入

Partition过程：给定一个数组arr，和一个整数num。请把小于等于num的数放在数组的左边，大于num的数放在数组的右边。
要求额外空间复杂度O(1)，时间复杂度O(N)

//给定一个数组arr，和一个整数num。请把小于等于num的数放在数组的左边，大于num的数放在数组的右边。
    //要求额外空间复杂度O(1)，时间复杂度O(N)
    public static void partition(int[] arr, int num) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int lessR = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] <= num) {
                swap(arr, ++lessR, i);
            }
        }
    }
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

02 荷兰国旗问题

荷兰国旗问题
给定一个数组arr，和一个整数num。请把小于num的数放在数组的左边，等于num的数放在中间，大于num的数放在数组的右边。
要求额外空间复杂度O(1)，时间复杂度O(N)

//给定一个数组arr，和一个整数num。请把小于num的数放在数组的左边，等于num的数放在中间，大于num的数放在数组的右边。
    //要求额外空间复杂度O(1)，时间复杂度O(N)
    public static void netherlandFlag(int[] arr, int num) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int lessR = -1;
        int moreL = arr.length - 1;
        int i = 0;
        while (i <= moreL) {
            if (arr[i] < num) {
                swap(arr, i++, ++lessR);
            }else if (arr[i] == num) {
                i++;
            }else {
                swap(arr, i, moreL--);
            }
        }
    }
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

03 快速排序1.0

在arr[L..R]范围上，进行快速排序的过程：
1）用arr[R]对该范围做partition，<= arr[R]的数在左部分并且保证arr[R]最后来到左部分的最后一个位置，记为M； <= arr[R]的数在右部分（arr[M+1..R]）
2）对arr[L..M-1]进行快速排序(递归)
3）对arr[M+1..R]进行快速排序(递归)
因为每一次partition都会搞定一个数的位置且不会再变动，所以排序能完成

public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }
    public static void process(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int partition = partition(arr, left, right);
        process(arr, left, partition - 1);
        process(arr, partition + 1, right);
    }
    public static int partition(int[] arr,int left,int right){
        int lessR = left - 1;
        int moreL = right;
        int i = left;
        while (i < moreL) {
            if (arr[i] <= arr[right]) {
                swap(arr, i++, ++lessR);
            } else {
                swap(arr, i, --moreL);
            }
        }
        swap(arr, right, moreL);
        return  moreL;
    }
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

04 快速排序2.0

在arr[L..R]范围上，进行快速排序的过程：
1）用arr[R]对该范围做partition，< arr[R]的数在左部分，== arr[R]的数中间，>arr[R]的数在右部分。假设== arr[R]的数所在范围是[a,b]
2）对arr[L..a-1]进行快速排序(递归)
3）对arr[b+1..R]进行快速排序(递归)
因为每一次partition都会搞定一批数的位置且不会再变动，所以排序能完成

public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }
    public static void process(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int[] partition = partition(arr, left, right);
        process(arr, left, partition[0] - 1);
        process(arr, partition[1] + 1, right);
    }
    public static int[] partition(int[] arr, int left, int right) {
        int lessR = left - 1;
        int moreL = right;
        int i = left;
        while (i < moreL) {
            if (arr[i] < arr[right]) {
                swap(arr, i++, ++lessR);
            } else if (arr[i] > arr[right]) {
                swap(arr, i, --moreL);
            } else {
                i++;
            }
        }
        swap(arr, right, moreL);
        return new int[]{lessR + 1, moreL};
    }
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

05 快速排序3.0

在arr[L..R]范围上，进行快速排序的过程：
1）在这个范围上，随机选一个数记为num，
1）用num对该范围做partition，< num的数在左部分，== num的数中间，>num的数在右部分。假设== num的数所在范围是[a,b]
2）对arr[L..a-1]进行快速排序(递归)
3）对arr[b+1..R]进行快速排序(递归)
因为每一次partition都会搞定一批数的位置且不会再变动，所以排序能完成

public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }
    public static void process(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int[] partition = partition(arr, left, right);
        process(arr, left, partition[0] - 1);
        process(arr, partition[1] + 1, right);
    }
    public static int[] partition(int[] arr, int left, int right) {
        int lessR = left - 1;
        swap(arr,right,(int) (Math.random()*(right-left+1))+left);
        int moreL = right;
        int i = left;
        while (i < moreL) {
            if (arr[i] < arr[right]) {
                swap(arr, i++, ++lessR);
            } else if (arr[i] > arr[right]) {
                swap(arr, i, --moreL);
            } else {
                i++;
            }
        }
        swap(arr, right, moreL);
        return new int[]{lessR + 1, moreL};
    }

06 快速排序 非递归版本

static class Task {
        int left;
        int right;

        public Task(int left, int right) {
            this.left = left;
            this.right = right;
        }
    }


    public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        Stack<Task> stack = new Stack<>();
        int[] partition = partition(arr, 0, arr.length - 1);
        stack.push(new Task(0, partition[0] - 1));
        stack.push(new Task(partition[1] + 1, arr.length - 1));
        while (!stack.empty()) {
            Task task = stack.pop();
            if (task.left < task.right) {
                int[] partition1 = partition(arr, task.left, task.right);
                stack.push(new Task(task.left, partition1[0] - 1));
                stack.push(new Task(partition1[1] + 1, task.right));
            }
        }

    }

    public static int[] partition(int[] arr, int left, int right) {
        if (left >= right) {
            return new int[]{-1, -1};
        }
        swap(arr, right, (int) (Math.random() * (right - left + 1)) + left);
        int moreL = right;
        int lessR = left - 1;
        int i = left;
        while (i < moreL) {
            if (arr[i] < arr[right]) {
                swap(arr, i++, ++lessR);
            } else if (arr[i] > arr[right]) {
                swap(arr, i, --moreL);
            } else {
                i++;
            }
        }
        swap(arr, right, moreL);
        return new int[]{lessR + 1, moreL};
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }