十五、自己动手实现排序算法（3）------------“ Quick Sort 快速排序 ”

参考文章：

https://www.cnblogs.com/guoyaohua/p/8600214.html                  十大经典排序算法最强总结（含JAVA代码实现）

https://blog.csdn.net/tizzzzzz/article/details/79610375                   快速排序简单理解（实现原理以及不稳定性）（强推）

---

快速排序分析：

平均时间复杂度	最好情况	最坏情况	空间复杂度	排序方式	稳定性
O（n*logn）	O（n*logn）	O（n^2）	O（logn）	In-place	不稳定

---

快速排序原理：

       快速排序的基本思想： 通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

 

原理示意图（引用自参考文章）：

 

Java 代码实现：

代码一：

（温馨提示：如果下面这段代码不是很懂，可以先看看我在一开始强推的文章，把那个搞懂了， 下面的用一个数组按照流程走一遍就理解个大概了。）

package com.sorting.algorithm;

public class QuickSort2 {
	
	public static int[] quickSort(int[] array,int start,int end){
		if(array.length<1 || start <0 || start > end || end >array.length)
			return null;
		int smallIndex = partition(array,start,end);
		if(smallIndex > start)
			quickSort(array, start, smallIndex-1);
		if(smallIndex < end)
			quickSort(array, smallIndex+1, end);
		
		return array;
	}

	private static int partition(int[] array, int start, int end) {
		int pivot = (int)(start + Math.random()*(end-start+1));
		int smallIndex = start -1;
		swap(array,pivot,end);
		for (int i = start; i <= end; i++) {
			if(array[i] <= array[end]){
				smallIndex++;
				swap(array,i,smallIndex);
			}
		}
		return smallIndex;
	}

	private static void swap(int[] array, int i, int j) {
		int temp = array[i];
		array[i]=array[j];
		array[j]=temp;
	}	
	
	private static void printArr(int[] array){
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		
		int[] array= { 56,28,45,93,10,32,44,95,60,58 };
		
		System.out.println("未排序前的数组：");
		printArr(array);
		
		quickSort(array, 0, array.length-1);
		
		System.out.println("排序之后的数组：");
		printArr(array);
	}
	
}

 

 

代码二：

（这一版代码实现的是跟上面一模一样的效果，重要的话说三遍，

1，先把原理搞懂，再拿出纸和笔用一个无序数组，按照程序流程走一遍。

2，先把原理搞懂，再拿出纸和笔用一个无序数组，按照程序流程走一遍。

3，先把原理搞懂，再拿出纸和笔用一个无序数组，按照程序流程走一遍。

）

package com.sorting.algorithm;

public class QuickSort3 {
	
	public static void quickSort(Comparable[] array){
		int length = array.length;
		quickSort(array,0,length-1);
	}

	private static void quickSort(Comparable[] array, int left, int right) {
		if(left >= right)
			return;
		int pivot = partition(array,left,right);
		quickSort(array, left, pivot-1);
		quickSort(array, pivot+1, right);
	}

	private static int partition(Comparable[] array, int left, int right) {
		Comparable v = array[left];
		
		int j = left;
		for (int i = left; i <= right; i++) {
			if(array[i].compareTo(v)<0){
				j++;
				swap(array,j,i);
			}
		}
		swap(array, left, j);
		
		return j;
	}

	private static void swap(Object[] array, int j, int i) {
		Object object = array[i];
		array[i] = array[j];
		array[j] = object;
	}

	private static void printArr(Comparable[] array){
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		
		Comparable[] array= { 77,21,3,1,56,28,45,93,2,5,10,32,44,95,60,58,90,23,66,87,62 };
		
		System.out.println("未排序前的数组：");
		printArr(array);
		
		quickSort(array, 0, array.length-1);
		
		System.out.println("排序之后的数组：");
		printArr(array);
		
		
	}
	
}

 

 

快速排序测试：

（测试集，我就直接将最后的排序结果输出来了，中间的排序没有输出┭┮﹏┭┮）

代码一测试数组如下：

 

代码二测试数组如下：