快速排序

快速排序是基于冒泡排序的算法改进,算法的基本思想是分治的思想.关于分治思想有空写.
基本的排序原理:
   每次排序只发生在指定的边界内.然后把指定边界内的数组看作一个完整的子数组,将字数组的首位元素作为比较的基准(标准的算法是随机选择,而且有选择的算法,有空写)

进行一次排序,此次单一排序的目的是将字数组中比基准小的元素放置在基准的左侧,比基准大的元素放置在基准的右侧.

(实现算法:定义2个指针,其实状态分别指向子数组的首位和末位,简称左右指针.

1:开始的时候将右指针指向的元素和基准进行比较,如果比基准大那么指针左移,使用下一个元素继续比较,如果右指针指向的元素比基准小,那么基准和该元素交换位置.

   如果发生交换那么转向步骤2,直到右指针不大于左指针,返回当前基准元素所在的角标.

2:使用左指针指向的元素和基准进行比较,如果比基准小,那么指针右移,使用下一个元素继续进行比较,如果左指针指向的元素比基准大,那么基准和该元素交换位置,

   如果发生交换那么转向步骤3,直到右指针不大于左指针,返回当前基准元素所在的角标.)

单次排序完成后,那么基准所在的角标将是有序数组中该基准应该在的角标.那么基准左侧的数组元素全部小于等于该基准元素,基准右侧的数组全部大于等于该基准元素.
但是左侧和右侧的字数组还是无序的!如何让两侧分别有序呢!只要将左侧子数组看作一个完整的数组继续重复上述完整的步骤即可,同理右侧字数组.当子数组只剩一个元素的时候
那么排序就完成了!

举例说明
a = {4,5,9,8,3,1,4}

第一次排序
a = {4,5,9,8,3,1,4}
基准元素: t = a[start]=4
start = 0,end = 6,pivot = start(记录基准元素角标)
右侧指针开始:
4和t比较,不交换,继续,
1和t比较,交换
发生交换:
start = 1(自增),end = 5,pivot =end =5;
a={1,5,9,8,3,t(4),4}
满足start<end
故继续

左侧指针开始:
a[start] = 5 和t(4)比较,交换
发生交换:
start = 1,end = 4(自减),pivot = start =1;
a={1,t(4),9,8,3,5,4}
满足start<end
故继续

右侧指针开始:
a[end] = a[4] = 3 和t(4)比较,交换
发生交换:
start =2(自增),end =4,pivot = end =4;
a={1,3,9,8,t(4),5,4}
满足start<end
故继续

左侧指针
a[start]=a[2]=9和t(4)比,交换
发生交换:
start=2,end=3(自减),pivot=start=2;
a={1,3,t(4),8,9,5,4}
满足start<end
故继续

右侧指针
a[end]=a[3]=8 和t(4)比较,不需要交换
end=2,end-start=0
不满足start<end

故此次排序完成!
a={1,3,4,8,9,5,4},pivot=2
可见在角标为2的左侧子数组 全部小于等于角标为2的元素,右侧全部是大于等于角标为2的元素

为了使左侧数组和右侧数组分别有序
直接重复以上步骤
传入参数:
    数组为a,start=0,end=pivot-1=1
    数组为a,start=pivot+1=3,end=6

继续执行以上步骤,一直到传入的参数start和end相等的时候,那么该次排序直接完成,
当所有的子排序全部完成的时候,那么整个数组排序完成!!整个算法执行完毕!

public class QuickSortReview {

    public static void main(String[] args) {
        Integer[] arr = { 1, 2, 4, 56, 7, 4, 23, 3, 2, 2, 4, 5, 22, 1 };
        for (Integer integer : arr) {
            System.out.print(integer + ",");
        }
        System.out.println();
        quickSort(arr, 0, arr.length - 1);
        for (Integer integer : arr) {
            System.out.print(integer + ",");
        }
    }

    public static <T extends Comparable<? super T>> void quickSort(T[] arr, int start, int end) {

        // break条件
        if (end - start < 1) {
            return;
        }
        // 本次处理
        int pivot = subSort(arr, start, end);
        // 左部递归排序
        quickSort(arr, start, pivot - 1);
        // 右部递归排序
        quickSort(arr, pivot + 1, end);

    }

    public static <T extends Comparable<? super T>> int subSort(T[] arr, int start, int end) {

        int pivot = start;
        // 选本次比较的对象
        T tmp = arr[pivot];

        while (start < end) {
            while (arr[end].compareTo(tmp) >= 0 && start < end) {
                end--;
            }
            if (tmp.compareTo(arr[end]) > 0 && start < end) {
                T t = arr[end];
                arr[end] = arr[pivot];
                arr[pivot] = t;
                pivot = end;
                start++;
            }
            while (arr[start].compareTo(tmp) <= 0 && start < end) {
                start++;
            }
            if (tmp.compareTo(arr[start]) < 0 && start < end) {
                T t = arr[pivot];
                arr[pivot] = arr[start];
                arr[start] = t;
                pivot = start;
                end--;
            }
        }

        return pivot;
    }

}