算法查找与排序

一.查找

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

二.排序

lowB三人组

1.冒泡排序

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现他们的排序与排序要求相反时，就将他们互换。

##最好情况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的有序表。即先将序列的第一个记录看成是一个有序的子序列，然后从第二个记录逐个进行插入，直至整个序列有序为止。

##最好情况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)