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