基數排序、希爾排序、計數排序、桶排序

1、基數排序

import random from timewrap import *

def list_to_buckets(li, iteration):#這個是用來比較每一個位置的大小的數字

    """ 由於分紅10個原本就是有序的因此排出來就是有序的。 :param li: 列表 :param iteration: 裝桶是第幾回迭代 :return: """ buckets = [[] for _ in range(10)] print('buckests',buckets) for num in li: digit = (num // (10 ** iteration)) % 10 buckets[digit].append(num) print(buckets) return buckets def buckets_to_list(buckets):#這個是用來出數的
    return [num for bucket in buckets for num in bucket] # li = []
    # for bucket in buckets:
    # for num in bucket:
    # li.append(num)
 @cal_time def radix_sort(li): maxval = max(li) # 10000
    it = 0 while 10 ** it <= maxval:#這個是循環用來，在之前一次排序的基礎上在排序。
        li = buckets_to_list(list_to_buckets(li, it)) it += 1
    return li # li = [random.randint(0,1000) for _ in range(100000)]
li = [random.randint(0,10) for _ in range(10)] li=[5555,5525,9939,9999,6,3,8,9] s=radix_sort(li) print(s)

 

2、希爾排序

思路：

• 希爾排序是一種分組插入排序算法。
• 首先取一個整數d1=n/2，將元素分爲d1個組，每組相鄰量元素之間距離爲d1，在各組內進行直接插入排序；
• 取第二個整數d2=d1/2，重複上述分組排序過程，直到di=1，即全部元素在同一組
• 希爾排序每趟並不使某些元素有序，而是使總體數據愈來愈接近有序；最後一趟排序使得全部數據有序。

代碼實現、

def insert_sort(li):#插入排序
    for i in range(1, len(li)): # i 表示無序區第一個數
        tmp = li[i] # 摸到的牌
        j = i - 1 # j 指向有序區最後位置
        while li[j] > tmp and j >= 0: #循環終止條件： 1. li[j] <= tmp; 2. j == -1
            li[j+1] = li[j] j -= 1 li[j+1] = tmp def shell_sort(li):#希爾排序 與插入排序區別就是把1變成d
    d = len(li) // 2
    while d > 0: for i in range(d, len(li)): tmp = li[i] j = i - d while li[j] > tmp and j >= 0: li[j+d] = li[j] j -= d li[j+d] = tmp d = d >> 1 li=[5,2,1,4,5,69,20,11] shell_sort(li) print(li)

 

希爾排序的複雜度特別複雜，取決於d，分組的長度2、位移運算符

3、計數排序

統計每一個數字出現了幾回

#計數排序 # 0 0 1 1 2 4 3 3 1 4 5 5
import random import copy from timewrap import * @cal_time def count_sort(li, max_num = 100): count = [0 for i in range(max_num+1)] for num in li: count[num]+=1 li.clear() for i, val in enumerate(count): for _ in range(val): li.append(i) @cal_time def sys_sort(li): li.sort() li = [random.randint(0,100) for i in range(100000)] li1 = copy.deepcopy(li) count_sort(li) sys_sort(li1)

 計數排序這麼快，爲何不用計數排序呢？由於他是有限制的，你要知道列表中的最大數

若是一下來了一個很大的數，好比10000，那麼佔的空間就的這麼大，

計數排序佔用的空間和列表的範圍有關係

解決這種問題的方法，能夠用桶排序，都放進去能夠在進行其餘的排序。好比插入排序。

4、桶排序

    在計數排序中，若是元素的範圍比較大(好比在1到1億之間)，如何改造算法？

     桶排序，首先將將元素分在不一樣的桶中，在對每一個桶中的元素排序。

多關鍵字排序

先對十位進行排序，再根據 十位進行排序

要用兩個函數，一個用來裝桶，一個用來出桶

默認10個桶，找到個位，十位，分別放在對應的桶裏的位置

 

     桶排序的表現取決於數據的分佈。也就是須要對不一樣數據排序時採起不一樣的分桶策略。

     平均狀況時間複雜度：O(n+k)

     最壞狀況時間複雜度：O(n+k)

     空間複雜度：O(nk)

    先分紅若干個桶，桶內用插入排序。

 

例子

1：給兩個字符串S和T，判斷T是否爲S的從新排列後組成的單詞：

  s="anagram",t="nagaram",return true

   s='cat',t='car',return false

代碼以下：

s = "anagram" t = "nagaram"

def ss(s,t): return  sorted(list(s))==sorted(list(t)) y=ss(s,t) print(y)

二、‘’

二維的座標變成一維的座標

X*b +y =i

(x,y) ->i

 

i//n----》x

i%n---->n

 

 1 def searchMatrix(matrix, target):  2     m = len(matrix)  3     # print('m', m)
 4     if m == 0:  5         return False  6     n = len(matrix[0])  7     if n == 0:  8         return False  9     low = 0 10     high = m * n - 1
11     # print('high',high)
12     while low <= high: 13         mid = (low + high) // 2
14         x, y = divmod(mid, n) 15         if matrix[x][y] > target: 16             high = mid - 1
17         elif matrix[x][y] < target: 18             low = mid + 1
19         else: 20             return True 21     else: 22         return False 23 
24 
25 s = [ 26     [1, 2, 3], 27     [4, 5, 6], 28     [7, 8, 9] 29 ] 30 # print(searchMatrix(s, 1))
31 # print(searchMatrix(s, 2))
32 # print(searchMatrix(s, 3))
33 # print(searchMatrix(s, 4))
34 # print(searchMatrix(s, 5))
35 # print(searchMatrix(s, 6))
36 print(searchMatrix(s, 7)) 37 # print(searchMatrix(s, 8))
38 # print(searchMatrix(s, 9))

View Code

 3.給定一個列表和一個整數，設計算法找兩個數的小標，使得兩個數之和爲給定的整數。保證確定僅有一個結果。

     例如：列表[1,2,5,4]與目標整數3，1+2=3，結果爲(0,1)

方式一：

方式二：

方式三

方式四和三同樣

def twoSum(num, target): dict = {} for i in range(len(num)): print(dict) x = num[i] if target - x in dict: return dict[target - x], i dict[x] = i l = [1, 2, 5, 4] print(twoSum(l, 7))