【算法基础】【排序】快速排序 - Quick Sort

算法描述：

       快速排序对待排序的记录采用一种“分治”法。在排序的每一步，都把记录分成两个分区。这种分区是基于称为基准（ pivot）的记录进行的。将小于基准的所有记录划分到一个分区中，而将大于基准的所有记录划分到另一个分区中。等于基准的记录则可以划分到任何一个分区中。

       时间复杂度： O(nlogn)

挖空填数 + 分治法 ( 双端扫描)：

       算法步骤：

       1. 数组array，设起始索引值为start，终止索引值为end；若start>=end，则停止排序；若start < end，开始一次排序；

       2. 在索引start和end的数组元素之间，选择一个基准值pivot，通常选择start元素为基准值：pivot=array[start]；将start,end之间的元素，小于pivot的元素放在pivot之前，大于pivot的元素放在pivot的后面；

           2.1. 设置两个cursor变量 i j, 初始化为 i = start; j = end；

           2.2. 由 j 开始向前搜索( j-- )，找到第一个值小于pivot的值array[ j ]，将array[ j ]与当前值为pivot的元素相交换；

           2.3. 由 i 开始向后搜索( i++ )，找到第一个值大于pivot的值array[ i ]，将array[ i ]与当前值为pivot的元素相交换；

           2.4. 重复2.2，2.3，直到 i == j；结束一次搜索；

       3. 将start, end之间的元素分成两组 [start,  i(j) - 1], [i(j) + 1, end]，分别重复以上步骤(此处的 i / j 为2.4结束时的值)；

示例：

选取区间第一个数为基准数： i=0; j=9; piovt=a[i]=72;

由于已经将a[0]保存到pivot中，可以理解为在数组a[0]上挖了个坑，可以将其他数据填充到这里。

从j开始向前找一个比pivot小或等于pivot的数。当 j=8，符合条件，将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8];i++；这样一个坑a[0]就被搞定了，但是又形成了一个新坑a[8]。再找数字来填a[8]这个坑。这次从i开始向后找一个大于pivot的数，当i=3符合条件，将a[3]挖出再填到上一个坑中a[8]=a[3];j--;

数组变为：

i=3;j=7;pivot=72;

再重复上面的步骤，先从后先前找，再从前向后找。

从j开始向前找，当j=5,符合条件，将a[5]挖出填到上一个坑中，a[3]=a[5];i++;

从j开始向后找，当i=5时，由于i==j退出。

此时，i=j=5，而a[5]刚好又是上次挖的坑，因此将pivot填入a[5]。

数组变为：

a[5]前面的数字都小于它，a[5]后面的数字都大于它。因此再对a[0...4]和a][6...9]这两个子区间重复上述步骤就可以了。

C++:

#include <iostream>
#include <string>

using namespace std;

void quicksort(int arr[], int l, int r)
{
    int i = l;
    int j = r;
    
    int pivot = arr[l];                       // 将最左边的值作为基准数
    
    if (l < r)
    {
        while (i < j)                         // 如果 i != j 就不断的进行循环
        {
            while (i < j && arr[j] >= pivot) // 从后向前扫描，找到第一个比基准数小的数
            {
                --j;
            }
            if (i < j)
            {
                arr[i++] = arr[j];            // 将后面第一个比基准数小的数放到前面
            }
            
            while (i < j && arr[i] <= pivot)  // 从前向后扫描，找到第一个比基准数大的数
            {
                ++i;
            }
            if (i < j)
            {
                arr[j--] = arr[i];           // 将前面第一个比基准数大的数放到后面
            }
        }
        
        arr[i] = pivot;                      // 将基准数放到 i = j的位置上
        quicksort(arr, l, i - 1);            // 递归
        quicksort(arr, i + 1, r);            // 递归
    }
}

int main(int argc, const char * argv[])
{
    int arr[6] = {2,5,8,3,9,4};
    quicksort(arr, 0, sizeof(arr) / sizeof(int));
    
    for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
    {
        cout<< arr[i]<<" ";
    }
    
    return 0;
}

Java:

package co.gof.algo;

public class QuickSort<T> {

	public static <T> void sort(Comparable<T>[] array) {
		if (array == null || array.length == 0) {
			return;
		}
		
		sort(array, 0, array.length - 1);
	}
	
	private static <T> void sort(Comparable<T>[] array, int start, int end) {
		if (start >= end) {
			return;
		}
		
		// define pivot, current <blank position> is i = start
		Comparable<T> comparator = array[start];
        int i = start;
        int j = end;
        
		while (i < j) {
			// scan from right to left
			while( (i < j) && compare(comparator, array[j]) <= 0) {
				j--;
			}
			
			if (i < j) {
				// the right element j is less than the pivot, move element j to the <blank position> i
				// current the <blank position> changed from i to j
				swap(array, i, j);
				i++;
			}
			
			// scan from left to right
            while ((i < j) && compare(comparator, array[i]) >=0) {
            	i++;
            }
            
            if (i < j) {
            	// the left element j is larger than the pivot, move element j to the <blank position> j
            	// current the <blank position> changed from j to i
            	swap(array, i, j);
            	j--;
            }
		}
		
		// currently, <blank position> i==j
		assert(i == j);
		array[i] = comparator;
		
		sort(array, start, i-1);
		sort(array, i+1, end);
	}
	
	private static int compare(Comparable left, Comparable right) {
		return left.compareTo(right);
	}
	
	private static <T> void swap(Comparable<T>[] array, int left, int right) {
		Comparable<T> temp = array[left];
		array[left] = array[right];
		array[right] = temp;
	}
	
	private static <T> boolean isSorted(Comparable<T>[] array) {
		for (int i = 1; i < array.length; i++) {
			if (compare(array[i-1], array[i]) > 0) {
				return false;
			}
		}
		return true;
	}
	
	private static <T> void print(Comparable<T>[] array) {
	   for (Comparable<T> c : array) {
		   System.out.print(c.toString() + " ");
	   }
	   
	   System.out.println();
	}
	
	
	public static <T> void test(Comparable<T>[] array) {
		sort(array);
		isSorted(array);
		print(array);
	}
	
	public static void main(String[] args) {
		QuickSort.test(new Integer[]{1,2,3,4,5});
		QuickSort.test(new Integer[]{5,4,3,2,1});
		QuickSort.test(new Integer[]{1,2,5,4,3});
		
	}
}