算法排序-------快速排序

排序算法

查找算法：折半查找

冒泡排序

时间复杂度O（n**2） 空间复杂度O（1）稳定

快速排序

快速排序使用分治法策略来把一个串行(list)分为两个子串行(sub-list)。从本质来看，快速排序应该算是在冒泡排序的基础上的递归分治法

时间复杂度O(ologn)如果不考虑递归问题的化空间复杂度为O(1)稳定的算法

基本操作步骤

1.从数列中挑出一个元素，称为“基准”(pivot)

2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

3.递归地把小于基准值的元素的子数列和大于基准值元素的子数列排序

具体实现

【4,7,1,8,10,6,5,3,7,9】

1.pivot=4 start=0 end =9

low=0 high=9 pivot=4=arr[low]

首先从高端部分开始进行比较，保证高端部分比pivot大。如果值比4大，则–

high=7 此时high指针执行的值比pivot小，arr[low]=arr[high]

[3,7,1,8,10,6,5,3,7,9] low =0 high=7 pivot=4

开始比较低端，从low执行的数据开始比较，直到有数据比pivot大为止

如果low指向的数据比pivot小，则low++

low=1时对应得数据为7，比pivot大，则arr[high] = arr[low]

[3,7,1,8,10,6,5,7,7,9] low =1 high =7 pivot=4

一轮对比完的结束条件应该是low>=high，当前low=1<high =7

继续比较高端，比较方式同第一次比较 high–，具体值为2，arr[high]<pivot ，所以需要赋值

[3,1,1,8,10,6,5,7,7,9]low=1 high=2 pivot=4

继续比较低端low low++

此时low==high，本次循环结束，回存基准值

[3,1,4,8,10,6,5,7,7,9]可以发现在4左端的所有数据都比4小，而4右端的数据都比4大

---

将原始数组分为2部分继续排序

arr0—2 arr3----9

以左端为例[3,1,4]

low=0 high=2 pivot=3=arr[low]

1.4>3所以high-- low=0 high=1

2.arr[high]<pivot 所以进行修改操作arr[low]=arr[high],所以[1,1,4] low =0 high = 1 pivot=3

3.比较低端，如果值小则low++ low=1 high=1 pivot=3

4.此时low high重合，则进行循环结束并赋值[1,3,4]

---

将原始数据分为两部分继续排序

arr 0-----1 arr2—2 不需要排序

public class QuickSort {

	public static void main(String[] args) {
		int[] arr = new int[] { 3, 45, 13, 76, 27, 53, 8, 3, 8, 2, 5, 6 };
		quickSort(arr, 0, arr.length - 1);
		for (int temp : arr) {
			System.out.print(temp + "  ");
		}
	}

	public static void quickSort(int[] arr, int start, int end) {

		if (start < end) {
			int pivot = arr[start];
			int low = start;
			int high = end;
			while (low < high) {
				while (low < high && arr[high] >= pivot) {
					high--;
				}
				arr[low] = arr[high];
				while (low < high && arr[low] <= pivot) {
					low++;
				}
				arr[high] = arr[low];
			}
			arr[low] = pivot;
			quickSort(arr, start, low);
			quickSort(arr, low + 1, end);
		}
	}
}