網(wǎng)上有很多關(guān)于面試pos機(jī)銷售技巧,手撕十大排序算法的知識(shí)，也有很多人為大家解答關(guān)于面試pos機(jī)銷售技巧的問(wèn)題，今天pos機(jī)之家(www.dsth100338.com)為大家整理了關(guān)于這方面的知識(shí)，讓我們一起來(lái)看下吧!
本文目錄一覽：
面試pos機(jī)銷售技巧
推薦閱讀：去面試大廠被 Kafka 虐了，后悔沒(méi)有早點(diǎn)看到這份Kafka手寫(xiě)筆記 面試阿里，京東，百度，快手歸來(lái)，三年Java開(kāi)發(fā)總結(jié)了這些經(jīng)驗(yàn) 阿里，字節(jié)，騰訊，面試題都涵蓋了，這一份Java面試文檔也太強(qiáng)了今天我們就來(lái)討論面試官最喜歡問(wèn)到的排序算法吧，從冒泡排序、選擇排序、插入排序等十大排序算法的排序步驟、代碼實(shí)現(xiàn)兩個(gè)方面入手，徹底搞清實(shí)現(xiàn)原理，保證面試道路一路暢通。
01 排序算法的概述所謂排序算法，就是通過(guò)特定的算法因式將一組或多組數(shù)據(jù)按照一定模式進(jìn)行重新排序。
這種新序列遵循著一定的規(guī)則，體現(xiàn)出一定的規(guī)律，因此，經(jīng)處理后的數(shù)據(jù)便于篩選和計(jì)算，大大提高了計(jì)算效率。
02 排序算法的分類03評(píng)價(jià)標(biāo)準(zhǔn)（1）時(shí)間復(fù)雜度：即從序列的初始狀態(tài)到經(jīng)過(guò)排序算法的變換移位等操作變到最終排序好的結(jié)果狀態(tài)的過(guò)程所花費(fèi)的時(shí)間度量。
（2）空間復(fù)雜度：就是從序列的初始狀態(tài)經(jīng)過(guò)排序移位變換的過(guò)程一直到最終的狀態(tài)所花費(fèi)的空間開(kāi)銷。
（3）穩(wěn)定性：穩(wěn)定性是不管考慮時(shí)間和空間必須要考慮的問(wèn)題，往往也是非常重要的影響選擇的因素。
04 實(shí)現(xiàn)步驟與代碼冒泡排序（Bubble Sort）冒泡排序是一種簡(jiǎn)單直觀的排序算法。它重復(fù)地走訪過(guò)要排序的數(shù)列，一次比較兩個(gè)元素，如果他們的順序錯(cuò)誤就把他們交換過(guò)來(lái)。走訪數(shù)列的工作是重復(fù)地進(jìn)行直到?jīng)]有再需要交換的數(shù)據(jù)，也就是說(shuō)該數(shù)列已經(jīng)排序完成。這個(gè)算法的名字由來(lái)是因?yàn)樵叫〉脑貢?huì)經(jīng)由交換慢慢"浮"到數(shù)列的頂端。
（1）算法步驟
步驟1：比較相鄰的元素。如果第一個(gè)比第二個(gè)大，就交換他們兩個(gè)；步驟2：對(duì)每一對(duì)相鄰元素作同樣的工作，從開(kāi)始第一對(duì)到結(jié)尾的最后一對(duì)。這步做完后，最后的元素會(huì)是最大的數(shù)；步驟3：針對(duì)所有的元素重復(fù)以上的步驟，除了最后一個(gè)；步驟4：重復(fù)步驟1~3，直到排序完成；
（2）過(guò)程演示
（3）代碼實(shí)現(xiàn)
public class BubbleSort implements IArraySort { @Override public int[] sort(int[] sourceArray) throws Exception { // 對(duì) 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)沒(méi)有進(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; }}選擇排序（Selection Sort）
選擇排序是一種簡(jiǎn)單直觀的排序算法，無(wú)論什么數(shù)據(jù)進(jìn)去都是 O(n2) 的時(shí)間復(fù)雜度。所以用到它的時(shí)候，數(shù)據(jù)規(guī)模越小越好。
（1）算法步驟
步驟1：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；步驟2：再?gòu)氖Ｓ辔磁判蛟刂欣^續(xù)尋找最?。ù螅┰?，然后放到已排序序列的末尾；步驟3：重復(fù)步驟2，直到所有元素均排序完畢；
（2）過(guò)程演示
（3）代碼實(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)過(guò) 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; }}插入排序（Insertion Sort）
插入排序的算法描述是一種簡(jiǎn)單直觀的排序算法。它的工作原理是通過(guò)構(gòu)建有序序列，對(duì)于未排序數(shù)據(jù)，在已排序序列中從后向前掃描，找到相應(yīng)位置并插入。插入排序在實(shí)現(xiàn)上，通常采用in-place排序（即只需用到O(1)的額外空間的排序），因而在從后向前掃描過(guò)程中，需要反復(fù)把已排序元素逐步向后挪位，為最新元素提供插入空間。
（1）算法步驟
步驟1：從第一個(gè)元素開(kāi)始，該元素可以認(rèn)為已經(jīng)被排序；步驟2：取出下一個(gè)元素，在已經(jīng)排序的元素序列中從后向前掃描；步驟3：如果該元素（已排序）大于新元素，將該元素移到下一位置；步驟4：重復(fù)步驟3，直到找到已排序的元素小于或者等于新元素的位置；步驟5：將新元素插入到該位置后；步驟6：重復(fù)步驟2~5；
（2）過(guò)程演示
（3）代碼實(shí)現(xiàn)
public class InsertSort implements IArraySort { @Override public int[] sort(int[] sourceArray) throws Exception { // 對(duì) arr 進(jìn)行拷貝，不改變參數(shù)內(nèi)容 int[] arr = Arrays.copyOf(sourceArray, sourceArray.length); // 從下標(biāo)為1的元素開(kāi)始選擇合適的位置插入，因?yàn)橄聵?biāo)為0的只有一個(gè)元素，默認(rèn)是有序的 for (int i = 1; i < arr.length; i++) { // 記錄要插入的數(shù)據(jù) int tmp = arr[i]; // 從已經(jīng)排序的序列最右邊的開(kāi)始比較，找到比其小的數(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; }}希爾排序（Shell Sort）
希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進(jìn)版本。但希爾排序是非穩(wěn)定排序算法。
希爾排序是基于插入排序的以下兩點(diǎn)性質(zhì)而提出改進(jìn)方法的：
插入排序在對(duì)幾乎已經(jīng)排好序的數(shù)據(jù)操作時(shí)，效率高，即可以達(dá)到線性排序的效率；但插入排序一般來(lái)說(shuō)是低效的，因?yàn)椴迦肱判蛎看沃荒軐?shù)據(jù)移動(dòng)一位；希爾排序的基本思想是：先將整個(gè)待排序的記錄序列分割成為若干子序列分別進(jìn)行直接插入排序，待整個(gè)序列中的記錄"基本有序"時(shí)，再對(duì)全體記錄進(jìn)行依次直接插入排序。
（1）算法步驟
步驟1：選擇一個(gè)增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；步驟2：按增量序列個(gè)數(shù) k，對(duì)序列進(jìn)行 k趟排序；步驟3：每趟排序，根據(jù)對(duì)應(yīng)的增量 ti，將待排序列分割成若干長(zhǎng)度為 m 的子序列，分別對(duì)各子表進(jìn)行直接插入排序。僅增量因子為 1時(shí)，整個(gè)序列作為一個(gè)表來(lái)處理，表長(zhǎng)度即為整個(gè)序列的長(zhǎng)度；
（2）過(guò)程演示
（3）代碼實(shí)現(xiàn)
public class ShellSort implements IArraySort { @Override public int[] sort(int[] sourceArray) throws Exception { // 對(duì) 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)用。歸并排序是一種穩(wěn)定的排序方法。將已有序的子序列合并，得到完全有序的序列；即先使每個(gè)子序列有序，再使子序列段間有序。若將兩個(gè)有序表合并成一個(gè)有序表，稱為2-路歸并。
和選擇排序一樣，歸并排序的性能不受輸入數(shù)據(jù)的影響，但表現(xiàn)比選擇排序好的多，因?yàn)槭冀K都是O(n log n）的時(shí)間復(fù)雜度。代價(jià)是需要額外的內(nèi)存空間。
（1）算法步驟
步驟1：把長(zhǎng)度為n的輸入序列分成兩個(gè)長(zhǎng)度為n/2的子序列；步驟2：對(duì)這兩個(gè)子序列分別采用歸并排序；步驟3：將兩個(gè)排序好的子序列合并成一個(gè)最終的排序序列；
（2）過(guò)程演示
（3）代碼實(shí)現(xiàn)
public class MergeSort implements IArraySort { @Override public int[] sort(int[] sourceArray) throws Exception { // 對(duì) 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; }}快速排序（Quick Sort）
快速排序是由東尼·霍爾所發(fā)展的一種排序算法。在平均狀況下，排序n個(gè)項(xiàng)目要 Ο(n log n) 次比較。在最壞狀況下則需要 Ο(n^2) 次比較，但這種狀況并不常見(jiàn)。事實(shí)上，快速排序通常明顯比其他 Ο(nlogn) 算法更快，因?yàn)樗膬?nèi)部循環(huán)（inner loop）可以在大部分的架構(gòu)上很有效率地被實(shí)現(xiàn)出來(lái)。
快速排序使用分治法（Divide and conquer）策略來(lái)把一個(gè)串行（list）分為兩個(gè)子串行（sub-lists）。
（1）算法步驟
步驟1：從數(shù)列中挑出一個(gè)元素，稱為 "基準(zhǔn)"（pivot）；步驟2：重新排序數(shù)列，所有元素比基準(zhǔn)值小的擺放在基準(zhǔn)前面，所有元素比基準(zhǔn)值大的擺在基準(zhǔn)的后面（相同的數(shù)可以到任一邊）。在這個(gè)分區(qū)退出之后，該基準(zhǔn)就處于數(shù)列的中間位置。這個(gè)稱為分區(qū)（partition）操作；步驟3：遞歸地（recursive）把小于基準(zhǔn)值元素的子數(shù)列和大于基準(zhǔn)值元素的子數(shù)列排序；
（2）過(guò)程演示
（3）代碼實(shí)現(xiàn)
public class QuickSort implements IArraySort { @Override public int[] sort(int[] sourceArray) throws Exception { // 對(duì) 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; }}堆排序（Heap Sort）
堆排序是指利用堆這種數(shù)據(jù)結(jié)構(gòu)所設(shè)計(jì)的一種排序算法。堆積是一個(gè)近似完全二叉樹(shù)的結(jié)構(gòu)，并同時(shí)滿足堆積的性質(zhì)：即子結(jié)點(diǎn)的鍵值或索引總是小于（或者大于）它的父節(jié)點(diǎn)。堆排序可以說(shuō)是一種利用堆的概念來(lái)排序的選擇排序。分為兩種方法：
大頂堆：每個(gè)節(jié)點(diǎn)的值都大于或等于其子節(jié)點(diǎn)的值，在堆排序算法中用于升序排列；小頂堆：每個(gè)節(jié)點(diǎn)的值都小于或等于其子節(jié)點(diǎn)的值，在堆排序算法中用于降序排列；堆排序的平均時(shí)間復(fù)雜度為 O(n log n)。
（1）算法步驟
步驟1：將初始待排序關(guān)鍵字序列(R1,R2….Rn)構(gòu)建成大頂堆，此堆為初始的無(wú)序區(qū)；步驟2：將堆頂元素R[1]與最后一個(gè)元素R[n]交換，此時(shí)得到新的無(wú)序區(qū)(R1,R2,……Rn-1)和新的有序區(qū)(Rn),且滿足R[1,2…n-1]<=R[n]；步驟3：由于交換后新的堆頂R[1]可能違反堆的性質(zhì)，因此需要對(duì)當(dāng)前無(wú)序區(qū)(R1,R2,……Rn-1)調(diào)整為新堆，然后再次將R[1]與無(wú)序區(qū)最后一個(gè)元素交換，得到新的無(wú)序區(qū)(R1,R2….Rn-2)和新的有序區(qū)(Rn-1,Rn)。不斷重復(fù)此過(guò)程直到有序區(qū)的元素個(gè)數(shù)為n-1，則整個(gè)排序過(guò)程完成；
（2）過(guò)程演示
（3）代碼實(shí)現(xiàn)
public class HeapSort implements IArraySort { @Override public int[] sort(int[] sourceArray) throws Exception { // 對(duì) 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ù)排序（Counting Sort）
計(jì)數(shù)排序 的核心在于將輸入的數(shù)據(jù)值轉(zhuǎn)化為鍵存儲(chǔ)在額外開(kāi)辟的數(shù)組空間中。作為一種線性時(shí)間復(fù)雜度的排序，計(jì)數(shù)排序要求輸入的數(shù)據(jù)必須是有確定范圍的整數(shù)。
計(jì)數(shù)排序是一種穩(wěn)定的排序算法。計(jì)數(shù)排序使用一個(gè)額外的數(shù)組C，其中第i個(gè)元素是待排序數(shù)組A中值等于i的元素的個(gè)數(shù)。然后根據(jù)數(shù)組C來(lái)將A中的元素排到正確的位置。它只能對(duì)整數(shù)進(jìn)行排序。
（1）算法步驟
步驟1：找出待排序的數(shù)組中最大和最小的元素；步驟2：統(tǒng)計(jì)數(shù)組中每個(gè)值為i的元素出現(xiàn)的次數(shù)，存入數(shù)組C的第i項(xiàng)；步驟3：對(duì)所有的計(jì)數(shù)累加（從C中的第一個(gè)元素開(kāi)始，每一項(xiàng)和前一項(xiàng)相加）；步驟4：反向填充目標(biāo)數(shù)組：將每個(gè)元素i放在新數(shù)組的第C(i)項(xiàng)，每放一個(gè)元素就將C(i)減去1；
（2）過(guò)程演示
（3）代碼實(shí)現(xiàn)
public class CountingSort implements IArraySort { @Override public int[] sort(int[] sourceArray) throws Exception { // 對(duì) 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; }}桶排序（Bucket Sort）
桶排序是計(jì)數(shù)排序的升級(jí)版。它利用了函數(shù)的映射關(guān)系，高效與否的關(guān)鍵就在于這個(gè)映射函數(shù)的確定。為了使桶排序更加高效，我們需要做到這兩點(diǎn)：
在額外空間充足的情況下，盡量增大桶的數(shù)量使用的映射函數(shù)能夠?qū)⑤斎氲腘個(gè)數(shù)據(jù)均勻的分配到K個(gè)桶中同時(shí)，對(duì)于桶中元素的排序，選擇何種比較排序算法對(duì)于性能的影響至關(guān)重要。
（1）算法步驟
步驟1：人為設(shè)置一個(gè)BucketSize，作為每個(gè)桶所能放置多少個(gè)不同數(shù)值（例如當(dāng)BucketSize==5時(shí)，該桶可以存放｛1,2,3,4,5｝這幾種數(shù)字，但是容量不限，即可以存放100個(gè)3）；步驟2：遍歷輸入數(shù)據(jù)，并且把數(shù)據(jù)一個(gè)一個(gè)放到對(duì)應(yīng)的桶里去；步驟3：對(duì)每個(gè)不是空的桶進(jìn)行排序，可以使用其它排序方法，也可以遞歸使用桶排序；步驟4：從不是空的桶里把排好序的數(shù)據(jù)拼接起來(lái)；
注意，如果遞歸使用桶排序?yàn)楦鱾€(gè)桶排序，則當(dāng)桶數(shù)量為1時(shí)要手動(dòng)減小BucketSize增加下一循環(huán)桶的數(shù)量，否則會(huì)陷入死循環(huán)，導(dǎo)致內(nèi)存溢出；
（2）過(guò)程演示
（3）代碼實(shí)現(xiàn)
/** * 桶排序 * * @param array * @param bucketSize * @return */ public static ArrayList<Integer> BucketSort(ArrayList<Integer> array, int bucketSize) { if (array == null || array.size() < 2) return array; int max = array.get(0), min = array.get(0); // 找到最大值最小值 for (int i = 0; i < array.size(); i++) { if (array.get(i) > max) max = array.get(i); if (array.get(i) < min) min = array.get(i); } int bucketCount = (max - min) / bucketSize + 1; ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount); ArrayList<Integer> resultArr = new ArrayList<>(); for (int i = 0; i < bucketCount; i++) { bucketArr.add(new ArrayList<Integer>()); } for (int i = 0; i < array.size(); i++) { bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i)); } for (int i = 0; i < bucketCount; i++) { if (bucketSize == 1) { // 如果待排序數(shù)組中有重復(fù)數(shù)字時(shí) for (int j = 0; j < bucketArr.get(i).size(); j++) resultArr.add(bucketArr.get(i).get(j)); } else { if (bucketCount == 1) bucketSize--; ArrayList<Integer> temp = BucketSort(bucketArr.get(i), bucketSize); for (int j = 0; j < temp.size(); j++) resultArr.add(temp.get(j)); } } return resultArr; }基數(shù)排序（Radix Sort）
基數(shù)排序也是非比較的排序算法，對(duì)每一位進(jìn)行排序，從最低位開(kāi)始排序，復(fù)雜度為O(kn),為數(shù)組長(zhǎng)度，k為數(shù)組中的數(shù)的最大的位數(shù)；
基數(shù)排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次類推，直到最高位。有時(shí)候有些屬性是有優(yōu)先級(jí)順序的，先按低優(yōu)先級(jí)排序，再按高優(yōu)先級(jí)排序。最后的次序就是高優(yōu)先級(jí)高的在前，高優(yōu)先級(jí)相同的低優(yōu)先級(jí)高的在前?；鶖?shù)排序基于分別排序，分別收集，所以是穩(wěn)定的。
（1）算法步驟
步驟1：取得數(shù)組中的最大數(shù)，并取得位數(shù)；步驟2：arr為原始數(shù)組，從最低位開(kāi)始取每個(gè)位組成radix數(shù)組；步驟3：對(duì)radix進(jìn)行計(jì)數(shù)排序（利用計(jì)數(shù)排序適用于小范圍數(shù)的特點(diǎn)）；
（2）過(guò)程演示
（3）代碼實(shí)現(xiàn)
/** * 基數(shù)排序 */public class RadixSort implements IArraySort { @Override public int[] sort(int[] sourceArray) throws Exception { // 對(duì) 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]對(duì)應(yīng)負(fù)數(shù)，[10-19]對(duì)應(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; }}05 總結(jié)
以上就是關(guān)于面試pos機(jī)銷售技巧,手撕十大排序算法的知識(shí)，后面我們會(huì)繼續(xù)為大家整理關(guān)于面試pos機(jī)銷售技巧的知識(shí)，希望能夠幫助到大家！
