給定一個整數數組 nums，將該數組升序排列。
示例 1：
輸入：[5,2,3,1]
輸出：[1,2,3,5]
示例 2：
輸入：[5,1,1,2,0,0]
輸出：[0,0,1,1,2,5]
各排序算法解法如下： (如想要了解算法排序原理，見> 十大算法)
public class _912排序數組 {
public int[] sortArray(int[] nums) {
if(nums.length <=1)return nums;
//qSort(nums,0,nums.length-1);
//selectSort(nums);
// insertSort(nums);
// shellSort(nums);
// bucketSort(nums);
// countSort(nums);
// mergeSort(nums,0,nums.length-1);
heapSort(nums);
return nums;
}
/**
快速排序
**/
void qSort(int[] arr,int s,int e){
int l = s, r = e;
if(l < r){
int temp = arr[l];
while(l < r){
while(l < r && arr[r] >= temp) r--;
if(l < r) arr[l] = arr[r];
while(l < r && arr[l] < temp) l++;
if(l < r) arr[r] = arr[l];
}
arr[l] = temp;
qSort(arr,s,l);
qSort(arr,l + 1, e);
}
}
/**
選擇排序
**/
void selectSort(int[] arr){
int min;
for(int i = 0;i<arr.length;i++){
min = i;
for(int j = i;j<arr.length;j++){
if(arr[j] < arr[min]){
min = j;
}
}
if(min != i) {
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
}
/**
*
* 插入排序：數列前面部分看爲有序，依次將後面的無序數列元素插入到前面的有序數列中，初始狀態有序數列僅有一個元素，即首元素。在將無序數列元素插入有序數列的過程中，採用了逆序遍歷有序數列，相較於順序遍歷會稍顯繁瑣，但當數列本身已近排序狀態效率會更高。
*
* 時間複雜度：O(N2) 穩定性：穩定
* @param arr
*/
public void insertSort(int arr[]){
for(int i = 1; i < arr.length; i++){
int rt = arr[i];
for(int j = i - 1; j >= 0; j--){
if(rt < arr[j]){
arr[j + 1] = arr[j];
arr[j] = rt;
}else{
break;
}
}
}
}
/**
* 希爾排序 - 插入排序的改進版。爲了減少數據的移動次數，在初始序列較大時取較大的步長，通常取序列長度的一半，此時只有兩個元素比較，交換一次；之後步長依次減半直至步長爲1，即爲插入排序，由於此時序列已接近有序，故插入元素時數據移動的次數會相對較少，效率得到了提高。
*
* 時間複雜度：通常認爲是O(N3/2) ，未驗證 穩定性：不穩定
* @param arr
*/
void shellSort(int arr[]){
int d = arr.length >> 1;
while(d >= 1){
for(int i = d; i < arr.length; i++){
int rt = arr[i];
for(int j = i - d; j >= 0; j -= d){
if(rt < arr[j]){
arr[j + d] = arr[j];
arr[j] = rt;
}else break;
}
}
d >>= 1;
}
}
/**
* 桶排序 - 實現線性排序，但當元素間值得大小有較大差距時會帶來內存空間的較大浪費。首先，找出待排序列中得最大元素max，申請內存大小爲max + 1的桶（數組）並初始化爲0；然後，遍歷排序數列，並依次將每個元素作爲下標的桶元素值自增1；
* 最後，遍歷桶元素，並依次將值非0的元素下標值載入排序數列（桶元素>1表明有值大小相等的元素，此時依次將他們載入排序數列），遍歷完成，排序數列便爲有序數列。
*
* 時間複雜度：O(x*N) 穩定性：穩定
* @param arr
*/
void bucketSort(int[] arr){
int[] bk = new int[50000 * 2 + 1];
for(int i = 0; i < arr.length; i++){
bk[arr[i] + 50000] += 1;
}
int ar = 0;
for(int i = 0; i < bk.length; i++){
for(int j = bk[i]; j > 0; j--){
arr[ar++] = i - 50000;
}
}
}
/**
* 基數排序 - 桶排序的改進版，桶的大小固定爲10，減少了內存空間的開銷。首先，找出待排序列中得最大元素max，並依次按max的低位到高位對所有元素排序；
* 桶元素10個元素的大小即爲待排序數列元素對應數值爲相等元素的個數，即每次遍歷待排序數列，桶將其按對應數值位大小分爲了10個層級，桶內元素值得和爲待排序數列元素個數。
* @param arr
*/
void countSort(int[] arr){
int[] bk = new int[19];
Integer max = Integer.MIN_VALUE;
for(int i = 0; i < arr.length; i++){
if(max < Math.abs(arr[i])) max = arr[i];
}
if(max < 0) max = -max;
max = max.toString().length();
int [][] bd = new int[19][arr.length];
for(int k = 0; k < max; k++) {
for (int i = 0; i < arr.length; i++) {
int value = (int)(arr[i] / (Math.pow(10,k)) % 10);
bd[value+9][bk[value+9]++] = arr[i];
}
int fl = 0;
for(int l = 0; l < 19; l++){
if(bk[l] != 0){
for(int s = 0; s < bk[l]; s++){
arr[fl++] = bd[l][s];
}
}
}
bk = new int[19];
fl = 0;
}
}
/**
* 歸併排序 - 採用了分治和遞歸的思想，遞歸&分治-排序整個數列如同排序兩個有序數列，依次執行這個過程直至排序末端的兩個元素，再依次向上層輸送排序好的兩個子列進行排序直至整個數列有序（類比二叉樹的思想，from down to up）。
*
* 時間複雜度：O(NlogN) 穩定性：穩定
* @param arr
*/
void mergeSortInOrder(int[] arr,int bgn,int mid, int end){
int l = bgn, m = mid +1, e = end;
int[] arrs = new int[end - bgn + 1];
int k = 0;
while(l <= mid && m <= e){
if(arr[l] < arr[m]){
arrs[k++] = arr[l++];
}else{
arrs[k++] = arr[m++];
}
}
while(l <= mid){
arrs[k++] = arr[l++];
}
while(m <= e){
arrs[k++] = arr[m++];
}
for(int i = 0; i < arrs.length; i++){
arr[i + bgn] = arrs[i];
}
}
void mergeSort(int[] arr, int bgn, int end)
{
if(bgn >= end){
return;
}
int mid = (bgn + end) >> 1;
mergeSort(arr,bgn,mid);
mergeSort(arr,mid + 1, end);
mergeSortInOrder(arr,bgn,mid,end);
}
/**
* 堆排序 - 堆排序的思想借助於二叉堆中的最大堆得以實現。首先，將待排序數列抽象爲二叉樹，並構造出最大堆；然後，依次將最大元素（即根節點元素）與待排序數列的最後一個元素交換（即二叉樹最深層最右邊的葉子結點元素）；
* 每次遍歷，刷新最後一個元素的位置（自減1），直至其與首元素相交，即完成排序。
*
* 時間複雜度：O(NlogN) 穩定性：不穩定
*
* @param arr
*/
void heapSort(int[] nums) {
int size = nums.length;
for (int i = size/2-1; i >=0; i--) {
adjust(nums, size, i);
}
for (int i = size - 1; i >= 1; i--) {
int temp = nums[0];
nums[0] = nums[i];
nums[i] = temp;
adjust(nums, i, 0);
}
}
void adjust(int []nums, int len, int index) {
int l = 2 * index + 1;
int r = 2 * index + 2;
int maxIndex = index;
if (l<len&&nums[l]>nums[maxIndex])maxIndex = l;
if (r<len&&nums[r]>nums[maxIndex])maxIndex = r;
if (maxIndex != index) {
int temp = nums[maxIndex];
nums[maxIndex] = nums[index];
nums[index] = temp;
adjust(nums, len, maxIndex);
}
}
}
以上！