面試pos機(jī)銷售技巧,手撕十大排序算法

 新聞資訊  |   2023-05-17 09:49  |  投稿人:pos機(jī)之家

網(wǎng)上有很多關(guān)于面試pos機(jī)銷售技巧,手撕十大排序算法的知識(shí),也有很多人為大家解答關(guān)于面試pos機(jī)銷售技巧的問(wèn)題,今天pos機(jī)之家(www.dsth100338.com)為大家整理了關(guān)于這方面的知識(shí),讓我們一起來(lái)看下吧!

本文目錄一覽:

1、面試pos機(jī)銷售技巧

面試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)氖S辔磁判蛟刂欣^續(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í),希望能夠幫助到大家!

轉(zhuǎn)發(fā)請(qǐng)帶上網(wǎng)址:http://www.dsth100338.com/news/43788.html

你可能會(huì)喜歡:

版權(quán)聲明:本文內(nèi)容由互聯(lián)網(wǎng)用戶自發(fā)貢獻(xiàn),該文觀點(diǎn)僅代表作者本人。本站僅提供信息存儲(chǔ)空間服務(wù),不擁有所有權(quán),不承擔(dān)相關(guān)法律責(zé)任。如發(fā)現(xiàn)本站有涉嫌抄襲侵權(quán)/違法違規(guī)的內(nèi)容, 請(qǐng)發(fā)送郵件至 babsan@163.com 舉報(bào),一經(jīng)查實(shí),本站將立刻刪除。