|
來源：https://www.cnblogs.com/onepixel
十種常見排序算法可以分為兩大類： 比較類排序：通過比較來決定元素間的相對次序，由于其時(shí)間復(fù)雜度不能突破O(nlogn)，因此也稱為非線性時(shí)間比較類排序。 非比較類排序：不通過比較來決定元素間的相對次序，它可以突破基于比較排序的時(shí)間下界，以線性時(shí)間運(yùn)行，因此也稱為線性時(shí)間非比較類排序。 
0.2 算法復(fù)雜度
0.3 相關(guān)概念穩(wěn)定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不穩(wěn)定：如果a原本在b的前面，而a=b，排序之后 a 可能會出現(xiàn)在 b 的后面。 時(shí)間復(fù)雜度：對排序數(shù)據(jù)的總的操作次數(shù)。反映當(dāng)n變化時(shí)，操作次數(shù)呈現(xiàn)什么規(guī)律。 空間復(fù)雜度：是指算法在計(jì)算機(jī) 內(nèi)執(zhí)行時(shí)所需存儲空間的度量，它也是數(shù)據(jù)規(guī)模n的函數(shù)。 冒泡排序（Bubble Sort）也是一種簡單直觀的排序算法。它重復(fù)地走訪過要排序的數(shù)列，一次比較兩個(gè)元素，如果他們的順序錯(cuò)誤就把他們交換過來。走訪數(shù)列的工作是重復(fù)地進(jìn)行直到?jīng)]有再需要交換，也就是說該數(shù)列已經(jīng)排序完成。這個(gè)算法的名字由來是因?yàn)樵叫〉脑貢?jīng)由交換慢慢“浮”到數(shù)列的頂端。
作為最簡單的排序算法之一，冒泡排序給我的感覺就像 Abandon 在單詞書里出現(xiàn)的感覺一樣，每次都在第一頁第一位，所以最熟悉。冒泡排序還有一種優(yōu)化算法，就是立一個(gè) flag，當(dāng)在一趟序列遍歷中元素沒有發(fā)生交換，則證明該序列已經(jīng)有序。但這種改進(jìn)對于提升性能來說并沒有什么太大作用。 1. 算法步驟 比較相鄰的元素。如果第一個(gè)比第二個(gè)大，就交換他們兩個(gè)。 對每一對相鄰元素作同樣的工作，從開始第一對到結(jié)尾的最后一對。這步做完后，最后的元素會是最大的數(shù)。 針對所有的元素重復(fù)以上的步驟，除了最后一個(gè)。 持續(xù)每次對越來越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。
2. 動(dòng)圖演示 
3. 什么時(shí)候最快 當(dāng)輸入的數(shù)據(jù)已經(jīng)是正序時(shí)（都已經(jīng)是正序了，我還要你冒泡排序有何用?。?。 4. 什么時(shí)候最慢 當(dāng)輸入的數(shù)據(jù)是反序時(shí)（寫一個(gè) for 循環(huán)反序輸出數(shù)據(jù)不就行了，干嘛要用你冒泡排序呢，我是閑的嗎）。 5. Java 代碼實(shí)現(xiàn) public class BubbleSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進(jìn)行拷貝，不改變參數(shù)內(nèi)容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
for (int i = 1; i < arr.length; i ) {
// 設(shè)定一個(gè)標(biāo)記，若為true，則表示此次循環(huán)沒有進(jìn)行交換，也就是待排序列已經(jīng)有序，排序已經(jīng)完成。
boolean flag = true;
for (int j = 0; j < arr.length - i; j ) {
if (arr[j] > arr[j 1]) {
int tmp = arr[j];
arr[j] = arr[j 1];
arr[j 1] = tmp;
flag = false;
}
}
if (flag) {
break;
}
}
return arr;
}
}選擇排序是一種簡單直觀的排序算法，無論什么數(shù)據(jù)進(jìn)去都是 O(n2) 的時(shí)間復(fù)雜度。所以用到它的時(shí)候，數(shù)據(jù)規(guī)模越小越好。唯一的好處可能就是不占用額外的內(nèi)存空間了吧。
1. 算法步驟 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置 再從剩余未排序元素中繼續(xù)尋找最?。ù螅┰?，然后放到已排序序列的末尾。 重復(fù)第二步，直到所有元素均排序完畢。
2. 動(dòng)圖演示 
3. Java 代碼實(shí)現(xiàn) public class SelectionSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
// 總共要經(jīng)過 N-1 輪比較
for (int i = 0; i < arr.length - 1; i ) {
int min = i;
// 每輪需要比較的次數(shù) N-i
for (int j = i 1; j < arr.length; j ) {
if (arr[j] < arr[min]) {
// 記錄目前能找到的最小值元素的下標(biāo)
min = j;
}
}
// 將找到的最小值和i位置所在的值進(jìn)行交換
if (i != min) {
int tmp = arr[i];
arr[i] = arr[min];
arr[min] = tmp;
}
}
return arr;
}
}插入排序的代碼實(shí)現(xiàn)雖然沒有冒泡排序和選擇排序那么簡單粗暴，但它的原理應(yīng)該是最容易理解的了，因?yàn)橹灰蜻^撲克牌的人都應(yīng)該能夠秒懂。插入排序是一種最簡單直觀的排序算法，它的工作原理是通過構(gòu)建有序序列，對于未排序數(shù)據(jù)，在已排序序列中從后向前掃描，找到相應(yīng)位置并插入。
插入排序和冒泡排序一樣，也有一種優(yōu)化算法，叫做拆半插入。 1. 算法步驟 將第一待排序序列第一個(gè)元素看做一個(gè)有序序列，把第二個(gè)元素到最后一個(gè)元素當(dāng)成是未排序序列。 從頭到尾依次掃描未排序序列，將掃描到的每個(gè)元素插入有序序列的適當(dāng)位置。（如果待插入的元素與有序序列中的某個(gè)元素相等，則將待插入元素插入到相等元素的后面。）
2. 動(dòng)圖演示 
3. Java 代碼實(shí)現(xiàn) public class InsertSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進(jìn)行拷貝，不改變參數(shù)內(nèi)容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
// 從下標(biāo)為1的元素開始選擇合適的位置插入，因?yàn)橄聵?biāo)為0的只有一個(gè)元素，默認(rèn)是有序的
for (int i = 1; i < arr.length; i ) {
// 記錄要插入的數(shù)據(jù)
int tmp = arr[i];
// 從已經(jīng)排序的序列最右邊的開始比較，找到比其小的數(shù)
int j = i;
while (j > 0 && tmp < arr[j - 1]) {
arr[j] = arr[j - 1];
j--;
}
// 存在比其小的數(shù)，插入
if (j != i) {
arr[j] = tmp;
}
}
return arr;
}
}
希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進(jìn)版本。但希爾排序是非穩(wěn)定排序算法。
希爾排序是基于插入排序的以下兩點(diǎn)性質(zhì)而提出改進(jìn)方法的： 希爾排序的基本思想是：先將整個(gè)待排序的記錄序列分割成為若干子序列分別進(jìn)行直接插入排序，待整個(gè)序列中的記錄“基本有序”時(shí)，再對全體記錄進(jìn)行依次直接插入排序。 1. 算法步驟 選擇一個(gè)增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1； 按增量序列個(gè)數(shù) k，對序列進(jìn)行 k 趟排序； 每趟排序，根據(jù)對應(yīng)的增量 ti，將待排序列分割成若干長度為 m 的子序列，分別對各子表進(jìn)行直接插入排序。僅增量因子為 1 時(shí)，整個(gè)序列作為一個(gè)表來處理，表長度即為整個(gè)序列的長度。
2. Java 代碼實(shí)現(xiàn) public class ShellSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進(jìn)行拷貝，不改變參數(shù)內(nèi)容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int gap = 1;
while (gap < arr.length) {
gap = gap * 3 1;
}
while (gap > 0) {
for (int i = gap; i < arr.length; i ) {
int tmp = arr[i];
int j = i - gap;
while (j >= 0 && arr[j] > tmp) {
arr[j gap] = arr[j];
j -= gap;
}
arr[j gap] = tmp;
}
gap = (int) Math.floor(gap / 3);
}
return arr;
}
}
歸并排序（Merge sort）是建立在歸并操作上的一種有效的排序算法。該算法是采用分治法（Divide and Conquer）的一個(gè)非常典型的應(yīng)用。
作為一種典型的分而治之思想的算法應(yīng)用，歸并排序的實(shí)現(xiàn)由兩種方法： 在《數(shù)據(jù)結(jié)構(gòu)與算法 JavaScript 描述》中，作者給出了自下而上的迭代方法。但是對于遞歸法，作者卻認(rèn)為： However, it is not possible to do so in JavaScript, as the recursion goes too deep for the language to handle. 然而，在 JavaScript 中這種方式不太可行，因?yàn)檫@個(gè)算法的遞歸深度對它來講太深了。 說實(shí)話，我不太理解這句話。意思是 JavaScript 編譯器內(nèi)存太小，遞歸太深容易造成內(nèi)存溢出嗎？還望有大神能夠指教。 和選擇排序一樣，歸并排序的性能不受輸入數(shù)據(jù)的影響，但表現(xiàn)比選擇排序好的多，因?yàn)槭冀K都是 O(nlogn) 的時(shí)間復(fù)雜度。代價(jià)是需要額外的內(nèi)存空間。 1. 算法步驟 申請空間，使其大小為兩個(gè)已經(jīng)排序序列之和，該空間用來存放合并后的序列； 設(shè)定兩個(gè)指針，最初位置分別為兩個(gè)已經(jīng)排序序列的起始位置； 比較兩個(gè)指針?biāo)赶虻脑?，選擇相對小的元素放入到合并空間，并移動(dòng)指針到下一位置； 重復(fù)步驟 3 直到某一指針達(dá)到序列尾； 將另一序列剩下的所有元素直接復(fù)制到合并序列尾。
2. 動(dòng)圖演示 
3. Java 代碼實(shí)現(xiàn) public class MergeSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進(jìn)行拷貝，不改變參數(shù)內(nèi)容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
if (arr.length < 2) {
return arr;
}
int middle = (int) Math.floor(arr.length / 2);
int[] left = Arrays.copyOfRange(arr, 0, middle);
int[] right = Arrays.copyOfRange(arr, middle, arr.length);
return merge(sort(left), sort(right));
}
protected int[] merge(int[] left, int[] right) {
int[] result = new int[left.length right.length];
int i = 0;
while (left.length > 0 && right.length > 0) {
if (left[0] <= right[0]) {
result[i ] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
} else {
result[i ] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
}
while (left.length > 0) {
result[i ] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
}
while (right.length > 0) {
result[i ] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
return result;
}
}
快速排序是由東尼·霍爾所發(fā)展的一種排序算法。在平均狀況下，排序 n 個(gè)項(xiàng)目要 Ο(nlogn) 次比較。在最壞狀況下則需要 Ο(n2) 次比較，但這種狀況并不常見。事實(shí)上，快速排序通常明顯比其他 Ο(nlogn) 算法更快，因?yàn)樗膬?nèi)部循環(huán)（inner loop）可以在大部分的架構(gòu)上很有效率地被實(shí)現(xiàn)出來。
快速排序使用分治法（Divide and conquer）策略來把一個(gè)串行（list）分為兩個(gè)子串行（sub-lists）。 快速排序又是一種分而治之思想在排序算法上的典型應(yīng)用。本質(zhì)上來看，快速排序應(yīng)該算是在冒泡排序基礎(chǔ)上的遞歸分治法。 快速排序的名字起的是簡單粗暴，因?yàn)橐宦牭竭@個(gè)名字你就知道它存在的意義，就是快，而且效率高！它是處理大數(shù)據(jù)最快的排序算法之一了。雖然 Worst Case 的時(shí)間復(fù)雜度達(dá)到了 O(n2)，但是人家就是優(yōu)秀，在大多數(shù)情況下都比平均時(shí)間復(fù)雜度為 O(n logn) 的排序算法表現(xiàn)要更好，可是這是為什么呢，我也不知道。好在我的強(qiáng)迫癥又犯了，查了 N 多資料終于在《算法藝術(shù)與信息學(xué)競賽》上找到了滿意的答案： 快速排序的最壞運(yùn)行情況是 O(n2)，比如說順序數(shù)列的快排。但它的平攤期望時(shí)間是 O(nlogn)，且 O(nlogn) 記號中隱含的常數(shù)因子很小，比復(fù)雜度穩(wěn)定等于 O(nlogn) 的歸并排序要小很多。所以，對絕大多數(shù)順序性較弱的隨機(jī)數(shù)列而言，快速排序總是優(yōu)于歸并排序。 1. 算法步驟 從數(shù)列中挑出一個(gè)元素，稱為 “基準(zhǔn)”（pivot）; 重新排序數(shù)列，所有元素比基準(zhǔn)值小的擺放在基準(zhǔn)前面，所有元素比基準(zhǔn)值大的擺在基準(zhǔn)的后面（相同的數(shù)可以到任一邊）。在這個(gè)分區(qū)退出之后，該基準(zhǔn)就處于數(shù)列的中間位置。這個(gè)稱為分區(qū)（partition）操作； 遞歸地（recursive）把小于基準(zhǔn)值元素的子數(shù)列和大于基準(zhǔn)值元素的子數(shù)列排序；
遞歸的最底部情形，是數(shù)列的大小是零或一，也就是永遠(yuǎn)都已經(jīng)被排序好了。雖然一直遞歸下去，但是這個(gè)算法總會退出，因?yàn)樵诿看蔚牡╥teration）中，它至少會把一個(gè)元素?cái)[到它最后的位置去。 2. 動(dòng)圖演示 
3. Java 代碼實(shí)現(xiàn) public class QuickSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進(jìn)行拷貝，不改變參數(shù)內(nèi)容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
return quickSort(arr, 0, arr.length - 1);
}
private int[] quickSort(int[] arr, int left, int right) {
if (left < right) {
int partitionIndex = partition(arr, left, right);
quickSort(arr, left, partitionIndex - 1);
quickSort(arr, partitionIndex 1, right);
}
return arr;
}
private int partition(int[] arr, int left, int right) {
// 設(shè)定基準(zhǔn)值（pivot）
int pivot = left;
int index = pivot 1;
for (int i = index; i <= right; i ) {
if (arr[i] < arr[pivot]) {
swap(arr, i, index);
index ;
}
}
swap(arr, pivot, index - 1);
return index - 1;
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
堆排序（Heapsort）是指利用堆這種數(shù)據(jù)結(jié)構(gòu)所設(shè)計(jì)的一種排序算法。堆積是一個(gè)近似完全二叉樹的結(jié)構(gòu)，并同時(shí)滿足堆積的性質(zhì)：即子結(jié)點(diǎn)的鍵值或索引總是小于（或者大于）它的父節(jié)點(diǎn)。堆排序可以說是一種利用堆的概念來排序的選擇排序。分為兩種方法：
大頂堆：每個(gè)節(jié)點(diǎn)的值都大于或等于其子節(jié)點(diǎn)的值，在堆排序算法中用于升序排列； 小頂堆：每個(gè)節(jié)點(diǎn)的值都小于或等于其子節(jié)點(diǎn)的值，在堆排序算法中用于降序排列；
堆排序的平均時(shí)間復(fù)雜度為 Ο(nlogn)。 1. 算法步驟 創(chuàng)建一個(gè)堆 H[0……n-1]； 把堆首（最大值）和堆尾互換； 把堆的尺寸縮小 1，并調(diào)用 shift_down(0)，目的是把新的數(shù)組頂端數(shù)據(jù)調(diào)整到相應(yīng)位置； 重復(fù)步驟 2，直到堆的尺寸為 1。
2. 動(dòng)圖演示 
3. Java 代碼實(shí)現(xiàn) public class HeapSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進(jìn)行拷貝，不改變參數(shù)內(nèi)容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int len = arr.length;
buildMaxHeap(arr, len);
for (int i = len - 1; i > 0; i--) {
swap(arr, 0, i);
len--;
heapify(arr, 0, len);
}
return arr;
}
private void buildMaxHeap(int[] arr, int len) {
for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
heapify(arr, i, len);
}
}
private void heapify(int[] arr, int i, int len) {
int left = 2 * i 1;
int right = 2 * i 2;
int largest = i;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) {
swap(arr, i, largest);
heapify(arr, largest, len);
}
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
計(jì)數(shù)排序的核心在于將輸入的數(shù)據(jù)值轉(zhuǎn)化為鍵存儲在額外開辟的數(shù)組空間中。作為一種線性時(shí)間復(fù)雜度的排序，計(jì)數(shù)排序要求輸入的數(shù)據(jù)必須是有確定范圍的整數(shù)。
1. 動(dòng)圖演示 
2. Java 代碼實(shí)現(xiàn) public class CountingSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進(jìn)行拷貝，不改變參數(shù)內(nèi)容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int maxValue = getMaxValue(arr);
return countingSort(arr, maxValue);
}
private int[] countingSort(int[] arr, int maxValue) {
int bucketLen = maxValue 1;
int[] bucket = new int[bucketLen];
for (int value : arr) {
bucket[value] ;
}
int sortedIndex = 0;
for (int j = 0; j < bucketLen; j ) {
while (bucket[j] > 0) {
arr[sortedIndex ] = j;
bucket[j]--;
}
}
return arr;
}
private int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
}
桶排序是計(jì)數(shù)排序的升級版。它利用了函數(shù)的映射關(guān)系，高效與否的關(guān)鍵就在于這個(gè)映射函數(shù)的確定。為了使桶排序更加高效，我們需要做到這兩點(diǎn)：
在額外空間充足的情況下，盡量增大桶的數(shù)量 使用的映射函數(shù)能夠?qū)⑤斎氲?N 個(gè)數(shù)據(jù)均勻的分配到 K 個(gè)桶中
同時(shí)，對于桶中元素的排序，選擇何種比較排序算法對于性能的影響至關(guān)重要。 1. 什么時(shí)候最快 當(dāng)輸入的數(shù)據(jù)可以均勻的分配到每一個(gè)桶中。 2. 什么時(shí)候最慢 當(dāng)輸入的數(shù)據(jù)被分配到了同一個(gè)桶中。 3. Java 代碼實(shí)現(xiàn) public class BucketSort implements IArraySort {
private static final InsertSort insertSort = new InsertSort();
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進(jìn)行拷貝，不改變參數(shù)內(nèi)容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
return bucketSort(arr, 5);
}
private int[] bucketSort(int[] arr, int bucketSize) throws Exception {
if (arr.length == 0) {
return arr;
}
int minValue = arr[0];
int maxValue = arr[0];
for (int value : arr) {
if (value < minValue) {
minValue = value;
} else if (value > maxValue) {
maxValue = value;
}
}
int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) 1;
int[][] buckets = new int[bucketCount][0];
// 利用映射函數(shù)將數(shù)據(jù)分配到各個(gè)桶中
for (int i = 0; i < arr.length; i ) {
int index = (int) Math.floor((arr[i] - minValue) / bucketSize);
buckets[index] = arrAppend(buckets[index], arr[i]);
}
int arrIndex = 0;
for (int[] bucket : buckets) {
if (bucket.length <= 0) {
continue;
}
// 對每個(gè)桶進(jìn)行排序，這里使用了插入排序
bucket = insertSort.sort(bucket);
for (int value : bucket) {
arr[arrIndex ] = value;
}
}
return arr;
}
/**
* 自動(dòng)擴(kuò)容，并保存數(shù)據(jù)
*
* @param arr
* @param value
*/
private int[] arrAppend(int[] arr, int value) {
arr = Arrays.copyOf(arr, arr.length 1);
arr[arr.length - 1] = value;
return arr;
}
}
基數(shù)排序是一種非比較型整數(shù)排序算法，其原理是將整數(shù)按位數(shù)切割成不同的數(shù)字，然后按每個(gè)位數(shù)分別比較。由于整數(shù)也可以表達(dá)字符串（比如名字或日期）和特定格式的浮點(diǎn)數(shù)，所以基數(shù)排序也不是只能使用于整數(shù)。
1. 基數(shù)排序 vs 計(jì)數(shù)排序 vs 桶排序 基數(shù)排序有兩種方法： 這三種排序算法都利用了桶的概念，但對桶的使用方法上有明顯差異： 基數(shù)排序：根據(jù)鍵值的每位數(shù)字來分配桶； 計(jì)數(shù)排序：每個(gè)桶只存儲單一鍵值； 桶排序：每個(gè)桶存儲一定范圍的數(shù)值；
2. LSD 基數(shù)排序動(dòng)圖演示 
3. Java 代碼實(shí)現(xiàn) /**
* 基數(shù)排序
* 考慮負(fù)數(shù)的情況還可以參考： https://code./zh-CN/q/e98fa9
*/
public class RadixSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進(jìn)行拷貝，不改變參數(shù)內(nèi)容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int maxDigit = getMaxDigit(arr);
return radixSort(arr, maxDigit);
}
/**
* 獲取最高位數(shù)
*/
private int getMaxDigit(int[] arr) {
int maxValue = getMaxValue(arr);
return getNumLenght(maxValue);
}
private int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
protected int getNumLenght(long num) {
if (num == 0) {
return 1;
}
int lenght = 0;
for (long temp = num; temp != 0; temp /= 10) {
lenght ;
}
return lenght;
}
private int[] radixSort(int[] arr, int maxDigit) {
int mod = 10;
int dev = 1;
for (int i = 0; i < maxDigit; i , dev *= 10, mod *= 10) {
// 考慮負(fù)數(shù)的情況，這里擴(kuò)展一倍隊(duì)列數(shù)，其中 [0-9]對應(yīng)負(fù)數(shù)，[10-19]對應(yīng)正數(shù) (bucket 10)
int[][] counter = new int[mod * 2][0];
for (int j = 0; j < arr.length; j ) {
int bucket = ((arr[j] % mod) / dev) mod;
counter[bucket] = arrayAppend(counter[bucket], arr[j]);
}
int pos = 0;
for (int[] bucket : counter) {
for (int value : bucket) {
arr[pos ] = value;
}
}
}
return arr;
}
/**
* 自動(dòng)擴(kuò)容，并保存數(shù)據(jù)
*
* @param arr
* @param value
*/
private int[] arrayAppend(int[] arr, int value) {
arr = Arrays.copyOf(arr, arr.length 1);
arr[arr.length - 1] = value;
return arr;
}
}
|
