検索とソートアルゴリズム

A.の検索

1.シーケンシャルサーチ（線形検索）O（N）

##li=[4,5,6,9,3,7],查找9
def search(li, val):
    for i in range(len(li)):
        if li[i]==val:
            return i
    return -1
>>> 3

2.バイナリ検索O（LOGN）

##li = [1,3,6,9,44,67,88](列表要有序),查找9
def bin_search(li, val):
    low = 0
    high = len(li) - 1
    while low <= high:
        mid = (low + high) // 2
        if li[mid] == val:
            print(mid)
            return mid
        elif li[mid] < val:
            low = mid + 1
        else:
            high = mid - 1
    else:
        print("没有这个值")
>>>3

II。ソート

lowBトリオ

1.バブルソート

グループの数は、比較する隣接する2つの数の、トップダウン順にソートされていない現在の範囲内の合計数になるように沈没より多くの、より小さなソートします取り上げるします。すなわち：いつでも自分のシーケンシングおよび要件の反対を隣接する二つの比較的少ない見つけ、彼らは交換します。

##最好情况O(n) # 列表有序
##平均情况O(n^2)
##最坏情况O(n^2)
##稳定性:稳定
import random
def bubble_sort(li):
    for i in range(len(li)-1):
        exchange = False
        for j in range(len(li)-i-1):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
                exchange = True
        if not exchange:
            break
    return li
li = list(range(15))
random.shuffle(li)
print(li)
res = bubble_sort(li)
print(res)

2. [ソート

バブルソートのために、場所を最適化することができるがあり、すなわち、旅行の間、交換二十から二必要はなく、トランスデューサの前部への旅行を終えた直後に、最小値を最小値を書き留めることができます。

##最好情况O(n^2)
##平均情况O(n^2)
##最坏情况O(n^2)
##稳定性:不稳定
import random
def select_sort(li):
    for i in range(len(li)-1):
        min_pos = i
        for j in range(i+1, len(li)):
            if li[j] < li[min_pos]:
                min_pos = j
        li[i], li[min_pos] = li[min_pos], li[i]
    return li

li = list(range(15))
random.shuffle(li)
print(li)
res = select_sort(li)
print(res)

3.挿入ソート

ソートされたリストにレコードを表1に番号順新しいレコードで、その結果、ソートされます。すなわち、第一の配列として最初のレコードは、これまで順序付けの配列全体まで、順序付けられたシーケンスであり、第2の記録から1枚ずつ挿入しました。

##最好情况O(n)
##平均情况O(n^2)
##最坏情况O(n^2)
##稳定性:稳定
import random
def insert_sort(li):
    for i in range(1, len(li)):
        tmp = li[i]
        j = i - 1
        while j >= 0 and li[j] > tmp:
            li[j+1] = li[j]
            j -= 1
        li[j+1] = tmp
    return li

li = list(range(15))
random.shuffle(li)
print(li)
res = insert_sort(li)
print(res)

NBトリオ

1.クイックソート

基準素子よりも大きい要素の後ろに配置されている基準要素、前面の基準要素よりも小さい要素を選択し、基準値は、サブエレメントの数と基準要素は、ソートされた列の元のメソッドよりも大きい列の数よりも少ないです注文の全配列まで。

##最好情况O(nlogn)
##平均情况O(nlogn)
##最坏情况O(n^2) # 列表有序并倒序(从小到大排序)
##稳定性:不稳定

##方法一
import random
def quicksort(li, left, right):
    if left < right:
        mid = random_partition(li, left, right)
        quicksort(li, left, mid-1)
        quicksort(li, mid+1, right)
    return li
    
#优化快排最坏情况   
def random_partition(li, left, right):
    i = random.randint(left, right)
    li[i], li[left] = li[left], li[i]
    return partition(li, left, right)

def partition(li, left, right):
    tmp = li[left]
    while left < right:
        while left < right and li[right] >= tmp:
            right -= 1
        li[left] = li[right]
        while left < right and li[left] <= tmp:
            left += 1
        li[right] = li[left]
    li[left] = tmp
    return left
li = list(range(15))
random.shuffle(li)
print(li)
res = quicksort(li)
print(res)

##方法二
import random
def quick_sort(li):
    if len(li) < 2:
        return li
    temp = li[0]
    left = [v for v in li[1:] if v <= temp]
    right = [v for v in li[1:] if v > temp]
    left = quick_sort(left)
    right = quick_sort(right)
    return left + [temp] + right
li = list(range(15))
random.shuffle(li)
print(li)
res = quick_sort(li)
print(res)

2.ヒープソート

バイナリヒープは、完全なバイナリツリーまたはほぼ完全なバイナリツリーです。バイナリヒープ満たす二つの特性：
鍵（1）親ノードが常に（より小さいか等しい）よりも大きいか又は等しい任意の子ノードにキー;
（2）各ノードのサブツリー及び右サブツリーを左バイナリヒープは、
大きなルート親ノードのキーは、スタックがより常に大きいか、または任意のキーの子ノードに等しい場合。親ノードは、常に未満または任意のキーのキーと等しいとき、小さな子ルートノードヒープです。

##最好情况O(nlogn)
##平均情况O(nlogn)
##最坏情况O(nlogn)
##稳定性:不稳定

#大根堆
## O(nlogn)
def sift(li, low, high):
    tmp = li[low]
    i = low
    j = 2 * i + 1
    while j <= high:
        if j + 1 <= high and li[j] < li[j+1]:
            j += 1
        if li[j] > tmp:
            li[i] = li[j]
            i = j
            j = 2 * i + 1
        else:
            break
    li[i] = tmp

def heap_sort(li):
    n = len(li)
    for low in range((n-1)//2, -1, -1):
        sift(li, low, n-1)
    print(li)
    for high in range(n-1, -1, -1):
        li[0], li[high] = li[high], li[0]
        sift(li, 0, high-1)

import random
li = list(range(15))
random.shuffle(li)
print(li)
heap_sort(li)
print(li)