国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

計數排序,桶排序與基數排序

GitChat / 3333人閱讀

摘要:涉及的算法有計數排序基數排序桶排序,它們被歸類為非比較排序。計數排序沒有對元素進行比較,只是利用了箱與元素的一一對應關系,根據箱已經排好序的先決條件,解決排序。基數排序,是按照從高位到低位的順序進行分組排序。內部排序也是用基數排序。

一般算法能做到O(logn),已經非常不錯,如果我們排序的對象是純數字,還可以做到驚人的O(n)。涉及的算法有計數排序、基數排序、桶排序,它們被歸類為非比較排序。

非比較排序只要確定每個元素之前的已有的元素個數即可,遍歷一次就能求解。算法時間復雜度O(n)。

非比較排序時間復雜度低,但由于非比較排序需要占用空間來確定唯一位置。所以對數據規模和數據分布有一定的要求。

計數排序

計數排序需要占用大量空間,它僅適用于數據比較集中的情況。比如 [0~100],[10000~19999] 這樣的數據。

我們看一下計數排序是怎么運作,假設我們有[1,2,3,1,0,4]這六個數,這里面最大的值為4,那么我們創建一個長度為4的數組,每個元素默認為0。這相當于選舉排序,一共有6個投票箱,1就投1號箱,0就投入0號箱。注意,這些箱本來就是已經排好序,并且箱的編號就是代表原數組的元素。當全部投完時,0號箱有1個,1號箱有2個,2號箱有1個,3號箱有1,4號箱有1個。然后我們從這些箱的所有數依次出來,放到新數組,就神奇地排好序了。

計數排序沒有對元素進行比較,只是利用了箱與元素的一一對應關系,根據箱已經排好序的先決條件,解決排序。

</>復制代碼

  1. //by 司徒正美
  2. function countSort(arr){
  3. var max = Math.max.apply(0, arr);
  4. var buckets = []
  5. for(var i = 0; i < n; i++){
  6. var el = arr[i]
  7. if(buckets[el]){//子桶里不實際存在
  8. buckets[el]++
  9. }else{
  10. buckets[el] = 1
  11. }
  12. }
  13. var index = 0
  14. for(var i = 0; i < n; i++){
  15. var m = buckets[i].length;
  16. while(m){
  17. arr[index] = i;
  18. index++
  19. m--
  20. }
  21. }
  22. return arr
  23. }

但數組有一個問題就是它的索引值是從0開始,但我們的元素也要大于或等于0。我們可以通過一個數學技巧讓它支持負數。

</>復制代碼

  1. //by 司徒正美
  2. function countSort(arr){
  3. var max = arr[0]
  4. var min = arr[0]
  5. for(var i = 0; i < n; i++){
  6. if(arr[i] > max){
  7. max = arr[i]
  8. }
  9. if(arr[i] < min){
  10. max = arr[i]
  11. }
  12. }
  13. var buckets = new Array(max-min+1).fill(0);
  14. for(var i = 0; i < n; i++){
  15. buckets[ arr[i]-min ]++ //減去最小值,確保索引大于負數
  16. }
  17. var index = 0, bucketCount = max-min+1
  18. for(var i = 0; i < bucketCount; i++){
  19. var m = buckets[i].length;
  20. while(m){
  21. //將桶的編號加上最小值,變回原來的元素
  22. arr[index] = i+min;
  23. index++
  24. m--
  25. }
  26. }
  27. return arr
  28. }
桶排序

桶排序與計數排序很相似,不過現在的桶不單計數,是實實在在地放入元素。舉個例子,學校要對所有老師按年齡進行排序,這么多老師很難操作,那么先讓他們按年齡段進行分組,20-30歲的一組,30-40歲一組,50-60歲一組,然后組內再排序。這樣效率就大大提高了。桶排序也是于這種思想。

操作步驟:

確認范圍,亦即求取原數組的最大值與最小值。

確認需要多少個桶(這個通常作為參數傳入,不能大于原數組長度),然后最大值減最小值,除以桶的數量,但得每個桶最多能放多個元素,我們稱這個數為桶的最大容量。

遍歷原數組的所有元素,除以這個最大容量,就能得到它要放入的桶的編號了。在放入時可以使用插入排序,也可以在合并時才使用快速排序。

對所有桶進行遍歷,如果桶內的元素已經排好序,直接一個個取出來,放到結果數組就行了。

</>復制代碼

  1. //by 司徒正美
  2. var arr = [2,5,3,0,2,8,0,3,4,3]
  3. function bucketSort(array, num){
  4. if(array.length <= 1){
  5. return array
  6. }
  7. var n = array.length;
  8. var min = Math.min.apply(0, array)
  9. var max = Math.max.apply(0, array)
  10. if(max === min){
  11. return array
  12. }
  13. var capacity = (max - min + 1) /num;
  14. var buckets = new Array(max - min + 1)
  15. for(var i = 0; i < n; i++){
  16. var el = array[i];//el可能是負數
  17. var index = Math.floor((el - min) / capacity)
  18. var bucket = buckets[index]
  19. if(bucket){
  20. var jn = bucket.length;
  21. if(el >= bucket[jn-1]){
  22. bucket[jn] = el
  23. }else{
  24. insertSort:
  25. for(var j = 0; j < jn; j++){
  26. if(bucket[j] > el){
  27. while(jn > j){ //全部向后挪一位
  28. bucket[jn] = bucket[jn-1]
  29. jn--
  30. }
  31. bucket[j] = el //讓el占據bucket[j]的位置
  32. break insertSort;
  33. }
  34. }
  35. }
  36. }else{
  37. buckets[index] = [el]
  38. }
  39. }
  40. var index = 0
  41. for(var i = 0; i < num; i++){
  42. var bucket = buckets[i]
  43. for(var k = 0, kn = bucket.length; k < kn; k++){
  44. array[index++] = bucket[k]
  45. }
  46. }
  47. return array;
  48. }
  49. console.log( bucketSort(arr,4) )
  50. //[ 0, 0, 2, 2, 3, 3, 3, 4, 5, 8 ]
基數排序

基數排序是一種非比較型的整數排序算法。其基本原理是,按照整數的每個位數分組。在分組過程中,對于不足位的數據用0補位。

基數排序按照對位數分組的順序的不同,可以分為LSD(Least significant digit)基數排序和MSD(Most significant digit)基數排序。

LSD基數排序,是按照從低位到高位的順序進行分組排序。MSD基數排序,是按照從高位到低位的順序進行分組排序。上述兩種方式不僅僅是對位數分組順序不同,其實現原理也是不同的。

LSD基數排序

對于序列中的每個整數的每一位都可以看成是一個桶,而該位上的數字就可以認為是這個桶的鍵值。比如下面數組

[170, 45, 75, 90, 802, 2, 24, 66]

首先我們要確認最大值,一個for循環得最大數,因為最大數的位數最長。

然后,建立10個桶,亦即10個數組。

然后再遍歷所有元素,取其個位數,個位數是什么就放進對應編號的數組,1放進1號桶。

</>復制代碼

  1. 0號桶: 170,90
  2. 1號桶: 無
  3. 2號桶: 802,2
  4. 3號桶: 無
  5. 4號桶: 24
  6. 5號桶: 45, 75
  7. 6號桶: 66
  8. 7-9號桶: 無

然后再依次將元素從桶里最出來,覆蓋原數組,或放到一個新數組,我們把這個經過第一次排序的數組叫sorted。

sorted = [170,90,802,2,24,45,75,66]

然后我們再一次遍歷sorted數組的元素,這次取十位的值。這時要注意,2不存在十位,那么默認為0

</>復制代碼

  1. 0號桶: 2,802
  2. 1號桶: 無
  3. 2號桶: 24
  4. 3號桶: 無
  5. 4號桶: 45
  6. 5號桶: 無
  7. 6號桶: 66
  8. 7號桶: 170, 75
  9. 8號桶: 無
  10. 9號桶: 90

再全部取出來

sorted = [2,802,24,45,66,170,75,90]

開始百位上的入桶操作,沒有百位就默認為0:

</>復制代碼

  1. 0號桶: 2,24,45,66,75,90
  2. 1號桶: 170
  3. 2-7號桶:無
  4. 8號桶: 802
  5. 9號桶: 無

再全部取出來

sorted = [2,24,45,66,75,90,170,802]

沒有千位數,那么循環結束,返回結果桶sorted

從程序描述如下:

</>復制代碼

  1. //by 司徒正美
  2. function radixSort(array) {
  3. var max = Math.max.apply(0, array);
  4. var times = getLoopTimes(max),
  5. len = array.length;
  6. var buckets = [];
  7. for (let i = 0; i < 10; i++) {
  8. buckets[i] = []; //初始化10個桶
  9. }
  10. for (var radix = 1; radix <= times; radix++) {
  11. //個位,十位,百位,千位這樣循環
  12. lsdRadixSort(array, buckets, len, radix);
  13. }
  14. return array;
  15. }
  16. // 根據數字某個位數上的值得到桶的編號
  17. function getBucketNumer(num, d) {
  18. return (num + "").reverse()[d];
  19. }
  20. //或者這個
  21. function getBucketNumer(num, i) {
  22. return Math.floor((num / Math.pow(10, i)) % 10);
  23. }
  24. //獲取數字的位數
  25. function getLoopTimes(num) {
  26. var digits = 0;
  27. do {
  28. if (num > 1) {
  29. digits++;
  30. } else {
  31. break;
  32. }
  33. } while ((num = num / 10));
  34. return digits;
  35. }
  36. function lsdRadixSort(array, buckets, len, radix) {
  37. //入桶
  38. for (let i = 0; i < len; i++) {
  39. let el = array[i];
  40. let index = getBucketNumer(el, radix);
  41. buckets[index].push(el);
  42. }
  43. var k = 0;
  44. //重寫原桶
  45. for (let i = 0; i < 10; i++) {
  46. let bucket = buckets[i];
  47. for (let j = 0; j < bucket.length; j++) {
  48. array[k++] = bucket[j];
  49. }
  50. bucket.length = 0;
  51. }
  52. }
  53. // test
  54. var arr = [278, 109, 63, 930, 589, 184, 505, 269, 8, 83];
  55. console.log(radixSort(arr));
MSD基數排序

接下來講MSD基數排序.

最開始時也是遍歷所有元素,取最大值,得到最大位數,建立10個桶。這時從百位取起。不足三位,對應位置為0.

</>復制代碼

  1. 0號桶: 45, 75, 90, 2, 24, 66
  2. 1號桶: 107
  3. 2-7號桶: 無
  4. 8號桶: 802
  5. 9號桶: 無

接下來就與LSD不一樣。我們對每個長度大于1的桶進行內部排序。內部排序也是用基數排序。我們需要建立另10個桶,對0號桶的元素進行入桶操作,這時比原來少一位,亦即十位。

</>復制代碼

  1. 0號桶: 2
  2. 1號桶: 無
  3. 2號桶: 24
  4. 3號桶: 無
  5. 4號桶: 45
  6. 5號桶: 無
  7. 6號桶: 66
  8. 7號桶: 75
  9. 8號桶: 無
  10. 9號桶: 90

然后繼續遞歸上一步,因此每個桶的長度,都沒有超過1,于是開始0號桶的收集工作:

</>復制代碼

  1. 0號桶: 2,24,45,66,75,90
  2. 1號桶: 107
  3. 2-7號桶: 無
  4. 8號桶: 802
  5. 9號桶: 無

將這步驟應用其他桶,最后就排序完畢。

</>復制代碼

  1. //by 司徒正美
  2. function radixSort(array) {
  3. var max = Math.max.apply(0, array),
  4. times = getLoopTimes(max),
  5. len = array.length;
  6. msdRadixSort(array, len, times);
  7. return array;
  8. }
  9. //或者這個
  10. function getBucketNumer(num, i) {
  11. return Math.floor((num / Math.pow(10, i)) % 10);
  12. }
  13. //獲取數字的位數
  14. function getLoopTimes(num) {
  15. var digits = 0;
  16. do {
  17. if (num > 1) {
  18. digits++;
  19. } else {
  20. break;
  21. }
  22. } while ((num = num / 10));
  23. return digits;
  24. }
  25. function msdRadixSort(array, len, radix) {
  26. var buckets = [[], [], [], [], [], [], [], [], [], []];
  27. //入桶
  28. for (let i = 0; i < len; i++) {
  29. let el = array[i];
  30. let index = getBucketNumer(el, radix);
  31. buckets[index].push(el);
  32. }
  33. //遞歸子桶
  34. for (let i = 0; i < 10; i++) {
  35. let el = buckets[i];
  36. if (el.length > 1 && radix - 1) {
  37. msdRadixSort(el, el.length, radix - 1);
  38. }
  39. }
  40. var k = 0;
  41. //重寫原桶
  42. for (let i = 0; i < 10; i++) {
  43. let bucket = buckets[i];
  44. for (let j = 0; j < bucket.length; j++) {
  45. array[k++] = bucket[j];
  46. }
  47. bucket.length = 0;
  48. }
  49. }
  50. var arr = radixSort([170, 45, 75, 90, 802, 2, 24, 66]);
  51. console.log(arr);
字符串使用基數排序實現字典排序

此外,基數排序不局限于數字,可以稍作變換,就能應用于字符串的字典排序中。我們先來一個簡單的例子,只對都是小寫字母的字符串數組進行排序。

小寫字母一共26個,考慮到長度不一樣的情況,我們需要對夠短的字符串進行補充,這時補上什么好呢?我們不能直接上0,而是補空白。然后根據字母與數字的對應關系,弄27個桶,空字符串對應0,a對應1,b對應2.... 字典排序是從左邊開始比較, 因此我們需要用到MST基數排序。

</>復制代碼

  1. //by 司徒正美
  2. var character = {};
  3. "abcdefghijklmnopqrstuvwxyz".split("").forEach(function(el, i) {
  4. character[el] = i + 1;
  5. });
  6. function toNum(c, length) {
  7. var arr = [];
  8. arr.c = c;
  9. for (var i = 0; i < length; i++) {
  10. arr[i] = character[c[i]] || 0;
  11. }
  12. return arr;
  13. }
  14. function getBucketNumer(arr, i) {
  15. return arr[i];
  16. }
  17. function radixSort(array) {
  18. var len = array.length;
  19. var loopTimes = 0;
  20. //求出最長的字符串,并得它的長度,那也是最高位
  21. for (let i = 0; i < len; i++) {
  22. let el = array[i];
  23. var charLen = el.length;
  24. if (charLen > loopTimes) {
  25. loopTimes = charLen;
  26. }
  27. }
  28. //將字符串轉換為數字數組
  29. var nums = [];
  30. for (let i = 0; i < len; i++) {
  31. nums.push(toNum(array[i], loopTimes));
  32. }
  33. //開始多關鍵字排序
  34. msdRadixSort(nums, len, 0, loopTimes);
  35. //變回字符串
  36. for (let i = 0; i < len; i++) {
  37. array[i] = nums[i].c;
  38. }
  39. return array;
  40. }
  41. function msdRadixSort(array, len, radix, radixs) {
  42. var buckets = [];
  43. for (var i = 0; i <= 26; i++) {
  44. buckets[i] = [];
  45. }
  46. //入桶
  47. for (let i = 0; i < len; i++) {
  48. let el = array[i];
  49. let index = getBucketNumer(el, radix);
  50. buckets[index].push(el);
  51. }
  52. //遞歸子桶
  53. for (let i = 0; i <= 26; i++) {
  54. let el = buckets[i];
  55. //el.c是用來識別是桶還是我們臨時創建的數字字符串
  56. if (el.length > 1 && !el.c && radix < radixs) {
  57. msdRadixSort(el, el.length, radix + 1, radixs);
  58. }
  59. }
  60. var k = 0;
  61. //重寫原桶
  62. for (let i = 0; i <= 26; i++) {
  63. let bucket = buckets[i];
  64. for (let j = 0; j < bucket.length; j++) {
  65. array[k++] = bucket[j];
  66. }
  67. bucket.length = 0;
  68. }
  69. }
  70. var array = ["ac", "ee", "ef", "b", "z", "f", "ep", "gaaa", "azh", "az", "r"];
  71. var a = radixSort(array);
  72. console.log(a);
參考鏈接

https://wenku.baidu.com/view/... (PPT)

https://www.cnblogs.com/kkun/...

http://blog.csdn.net/ltyqljhw...

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://m.specialneedsforspecialkids.com/yun/92652.html

相關文章

  • JavaScript 數據結構算法之美 - 排序計數排序基數排序

    摘要:之所以把計數排序桶排序基數排序放在一起比較,是因為它們的平均時間復雜度都為。動畫計數排序思想找出待排序的數組中最大和最小的元素。桶排序計數排序能派上用場嗎手機號碼有位,范圍太大,顯然不適合用這兩種排序算法。 showImg(https://segmentfault.com/img/bVbuF9e?w=900&h=500); 1. 前言 算法為王。 想學好前端,先練好內功,只有內功深厚者...

    Awbeci 評論0 收藏0
  • 用JS寫計數排序基數排序

    摘要:計數排序計數排序就是簡單的桶排序,一個桶代表數組中一個數出現的個數,所以需要一個和數組數字范圍一樣大的輔助數組,一般用在范圍小于的排序,時間復雜度為,空間復雜度為數組的數字范圍。 計數排序 計數排序就是簡單的桶排序,一個桶代表數組中一個數出現的個數,所以需要一個和數組數字范圍一樣大的輔助數組,一般用在范圍小于100的排序,時間復雜度為O(n),空間復雜度為數組的數字范圍。 /** *...

    tulayang 評論0 收藏0
  • JavaScript 數據結構算法之美 - 十大經典排序算法匯總

    摘要:筆者寫的數據結構與算法之美系列用的語言是,旨在入門數據結構與算法和方便以后復習。這應該是目前較為簡單的十大經典排序算法的文章講解了吧。比如原本在的前面,而,排序之后,在的后面十大經典排序算法冒泡排序思想冒泡排序只會操作相鄰的兩個數據。 showImg(https://segmentfault.com/img/bVbvHet); 1. 前言 算法為王。想學好前端,先練好內功,內功不行,就...

    zsy888 評論0 收藏0
  • 排序算法 JavaScript

    摘要:一冒泡排序算法介紹比較相鄰的兩個元素如果前一個比后一個大,則交換位置。它與冒泡排序的不同之處在于,它會優先比較距離較遠的元素。希爾排序的核心在于間隔序列的設定。作為一種線性時間復雜度的排序,計數排序要求輸入的數據必須是有確定范圍的整數。 一、冒泡排序 算法介紹: 比較相鄰的兩個元素,如果前一個比后一個大,則交換位置。 第一輪把最大的元素放到了最后面。 由于每次排序最后一個都是最大的,...

    Charlie_Jade 評論0 收藏0
  • 數據結構以及相關排序

    摘要:桶排序與計數排序的區別桶排序中一個桶可以放一個范圍內的多個數據,在各個桶中又可以用其他方法排序,其快速之處在于只用對比同一個桶內的數字而無需與其他桶的數字作對比。與計數排序相比,桶排序需要作二次對比,但可省略桶的個數。 哈希表(Hash Table) 所有符合鍵值對即key-value的結構就是哈希。數組其實也是一種哈希。 計數排序(復雜度(n+max))無法統計負數和小數,需要一個...

    Brenner 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<