## My LeetCode: https://leetcode-cn.com/u/ituring/

## My LeetCode source code [GitHub]: https://github.com/izhoujie/Algorithmcii

## LeetCode 912. Sort array

# subject

Give you an array of integers, nums, in ascending order.

Example 1:

Input: nums = [5,2,3,1] Output: [1,2,3,5]

Example 2:

Input: nums = [5,1,1,2,0,0] Output: [0,0,1,1,2,5]

Tips:

- 1 <= nums.length <= 50000
- -50000 <= nums[i] <= 50000

Source: LeetCode

Links: https://leetcode-cn.com/problems/sort-an-array

Copyright belongs to the network. For commercial reprint, please contact the official authorization. For non-commercial reprint, please indicate the source.

## Solving problems

There is nothing to say about this problem. The arrangement will be finished soon;

Extension: the sort (dual pivot quicksort) source code in Arrays is worth looking at. Sort is a multi factor sorting method that integrates quick sorting, merging, direct selection, insertion sorting, etc,

The designer of source code should calculate several data volume boundaries based on a large number of data, so as to decide to use the optimal sorting algorithm;

Some parts of the sort source code:

/** * This class implements the Dual-Pivot Quicksort algorithm by * Vladimir Yaroslavskiy, Jon Bentley, and Josh Bloch. The algorithm * offers O(n log(n)) performance on many data sets that cause other * quicksorts to degrade to quadratic performance, and is typically * faster than traditional (one-pivot) Quicksort implementations. * The sorting algorithm is a two axis fast sorting, which is implemented by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch, * In a large number of data sets, the worst sorting performance of other fast sorting algorithms is O(n ²), but the algorithm will always provide stable O(nlogn) sorting performance, and its efficiency is better than the traditional single axis fast sorting * * All exposed methods are package-private, designed to be invoked * from public methods (in class Arrays) after performing any * necessary array bounds checks and expanding parameters into the * required forms. * All methods are package private so that they can be called by Arrays after necessary boundary checking, parameter extension and formatting * * @author Vladimir Yaroslavskiy * @author Jon Bentley * @author Josh Bloch * * @version 2011.02.11 m765.827.12i:5\7pm * @since 1.7 */ final class DualPivotQuicksort { ... }

Several boundary quantities:

/** * The maximum number of runs in merge sort. * Maximum number of merge sub columns: the maximum number of sequences to be merged */ private static final int MAX_RUN_COUNT = 67; /** * The maximum length of run in merge sort. * Merge sub column maximum length: the maximum length of the sequence to be merged */ private static final int MAX_RUN_LENGTH = 33; /** * If the length of an array to be sorted is less than this * constant, Quicksort is used in preference to merge sort. * Quick sort threshold: if the length of the array to be sorted is less than this value, quick sort is preferred instead of merge sort */ private static final int QUICKSORT_THRESHOLD = 286; /** * If the length of an array to be sorted is less than this * constant, insertion sort is used in preference to Quicksort. * Insertion sort threshold: if the length of the array to be sorted is less than this value, insertion sort is preferred instead of quick sort */ private static final int INSERTION_SORT_THRESHOLD = 47; /** * If the length of a byte array to be sorted is greater than this * constant, counting sort is used in preference to insertion sort. * byte Array count sort threshold: if the byte array length to be sorted is greater than this value, count sort is preferred instead of insert sort */ private static final int COUNTING_SORT_THRESHOLD_FOR_BYTE = 29; /** * If the length of a short or char array to be sorted is greater * than this constant, counting sort is used in preference to Quicksort. * short&char Array count sort threshold: if the array to be sorted is of type short or char and the array length is greater than this value, count sort will be used first rather than insert sort */ private static final int COUNTING_SORT_THRESHOLD_FOR_SHORT_OR_CHAR = 3200;

### Train of thought 1 - fast platoon;

Steps:

- Find an intermediate value (generally the first number), and put the value less than the value on the left, and the value greater than the value on the right;
- The last ending position (excluding the position) is the operation of dividing line and dividing two blocks recursively for 1;
- The end condition is that left and right indexes meet;

## Algorithm source code example

package leetcode; /** * @author ZhouJie * @date 2020 12:02:03 am, March 31, 2015 * @Description: 912. Sort array * */ public class LeetCode_0912 { } class Solution_0912 { /** * @author: ZhouJie * @date: 2020 12:50:01 am, March 31, 2015 * @param: @param nums * @param: @return * @return: int[] * @Description: Quick sort * */ public int[] sortArray(int[] nums) { quickSort(nums, 0, nums.length - 1); return nums; } /** * @author: ZhouJie * @date: 2020 12:50:04 am, March 31, 2010 * @param: @param nums * @param: @param start * @param: @param end * @return: void * @Description: Fast row core * */ private void quickSort(int[] nums, int start, int end) { if (start >= end) { return; } int midVal = nums[start]; int left = start, right = end; while (left < right) { while (left < right && nums[right] >= midVal) { right--; } nums[left] = nums[right]; while (left < right && nums[left] <= midVal) { left++; } nums[right] = nums[left]; } nums[left] = midVal; quickSort(nums, start, left - 1); quickSort(nums, left + 1, end); } }