其餘排序

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))