Implementation process

1 Select a point element from the sequence (Pivot)
✓ Suppose each element is selected 0 positions as a point element
2 Separate the sequence into 2 subsequences using Pivot
✓ Place less than pivot in front of Pivot (left side)
✓ Place the elements greater than pivot in the back of the pivot (right side)
✓ Other elements of Pivot can be used
3 pair subsequences 1 2 operation
✓ until it is no longer divided (only 1 element in the child sequence)

Rapid Sorting - Point Construction Process

Quick Sorting - Elements equal to the axis point

The judgment of the CMP location is changed to <=,> = what effect will

The nature of the rapid sorting algorithm: converts each element into a point element.

Code

package com.mj.sort.cmp;

import com.mj.sort.Sort;

public class QuickSort<T extends Comparable<T>> extends Sort<T> {

	@Override
	protected void sort() {
		sort(0, array.length);
	}

	/**
	 * Rapid sorting elements in [Begin, End) range
	 * @param begin
	 * @param end
	 */
	private void sort(int begin, int end) { 
		if (end - begin < 2) return;
		
		/ / Determine the position of the point O (N)
		int mid = pivotIndex(begin, end);
		// Quick sequence of subsequences
		sort(begin, mid); 
		sort(mid + 1, end); 
	} 
	
	/**
	  * Configure the axis point elements in [Begin, End) range
	  * @Return point elements final position
	 */
	private int pivotIndex(int begin, int end) {
		/ / Randomly select an element with the begin position to exchange the clocked point of the point, the begin position is the point element
		swap(begin, begin + (int)(Math.random() * (end - begin)));
		
		// Back up the element of the Begin location
		T pivot = array[begin];
		// end points to the last element
		end--;
		
		while (begin < end) {
			while (begin < end) {
				if (cmp(pivot, array[end]) < 0) { // Right Element> Point Elements
					end--;
				} else { // Right Element <= point element
					array[begin++] = array[end];	// Cover the element of the Begin position with the right elements, then Begin ++
					break;							// After overriding, change the comparison direction
				}
			}
			while (begin < end) {
				if (cmp(pivot, array[begin]) > 0) { // Left element <axis point element
					begin++;
				} else { // Left Element> = Point Element
					array[end--] = array[begin];   // covers the element pointing to the right side of the array with the left element, which is greater than his right. Then end--
					break;						   // After overriding, change the comparison direction
				}
			}
		}
		// When Begin == End, the Begin location is the final position of the point element element.
		// put the point element into the final position
		array[begin] = pivot;
		// Return to the position of the point element
		return begin;
	}
}