常见排序和查找算法的Python实现

def bubble_sort(arr):
    """冒泡排序"""
    n = len(arr)
    for j in range(n - 1):
        count = 0
        for i in range(n - 1 - j):
            if arr[i + 1] < arr[i]:
                arr[i], arr[i + 1] = arr[i + 1], arr[i]
                count += 1
        if count == 0:
            break

def select_sort(arr):
    """选择排序"""
    n = len(arr)
    for i in range(n - 1):
        min_index = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]

def insert_sort(arr):
    """插入排序，在需要处理的数据量小时效率高"""
    n = len(arr)
    for i in range(1, n):
        for j in range(i, 0, -1):
            if arr[j] < arr[j - 1]:
                arr[j], arr[j - 1] = arr[j - 1], arr[j]
            else:
                break

def shell_sort(arr):
    """希尔排序"""
    n = len(arr)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            j = i
            while j > 0:
                if arr[j] < arr[j - gap]:
                    arr[j], arr[j - gap] = arr[j - gap], arr[j]
                    j -= gap
                else:
                    break
        gap = gap // 2

def quick_sort(arr, left, right):
    """快速排序"""
    if left >= right:
        return None
    pivot = arr[left]
    low = left
    high = right
    while low < high:
        while low < high and arr[high] >= pivot:
            high -= 1
        arr[low] = arr[high]
        while low < high and arr[low] < pivot:
            low += 1
        arr[high] = arr[low]
    arr[low] = pivot
    quick_sort(arr, left, low - 1)
    quick_sort(arr, low + 1, right)

def quick_sort(arr, left=None, right=None):
	"""快速排序的另一种实现方式"""
    left = 0 if not isinstance(left, (int, float)) else left
    right = len(arr) - 1 if not isinstance(right, (int, float)) else right
    if left < right:
        partitionIndex = partition(arr, left, right)
        quick_sort(arr, left, partitionIndex - 1)
        quick_sort(arr, partitionIndex + 1, right)
    return arr

def partition(arr, left, right):
    pivot = left
    index = pivot + 1
    i = index
    while i <= right:
        if arr[i] < arr[pivot]:
            arr[i], arr[index] = arr[index], arr[i]
            index += 1
        i += 1
    arr[pivot], arr[index - 1] = arr[index - 1], arr[pivot]
    return index - 1

def merge_sort(arr):
    """归并排序"""
    n = len(arr)
    if n <= 1:
        return arr
    mid = n // 2
    # left和right为归并排序之后形成的新的有序序列
    left_arr = merge_sort(arr[:mid])
    right_arr = merge_sort(arr[mid:])
    left, right = 0, 0
    result = list()
    while left < len(left_arr) and right < len(right_arr):
        if left_arr[left] <= right_arr[right]:
            result.append(left_arr[left])
            left += 1
        else:
            result.append(right_arr[right])
            right += 1
    result.extend(left_arr[left:])
    result.extend(right_arr[right:])
    return result

from math import floor
def merge_sort(arr):
	"""另一种归并排序"""
    n = len(arr)
    if n == 1:
        return arr
    middle = floor(n / 2)
    left, right = arr[:middle], arr[middle:]
    return merge(merge_sort(left), merge_sort(right))

def merge(left, right):
    ret = []
    while left and right:
        if left[0] <= right[0]:
            ret.append(left.pop(0))
        else:
            ret.append(right.pop(0))
    if left:
        ret.extend(left)
    if right:
        ret.extend(right)
    return ret

def binary_search(arr, item):
    """二分查找，递归版"""
    n = len(arr)
    if n > 0:
        mid = n // 2
        if arr[mid] == item:
            return True
        elif arr[mid] < item:
            return binary_search(arr[mid + 1:], item)
        elif arr[mid] > item:
            return binary_search(arr[:mid], item)
    else:
        return False


def binary_search_1(arr, item):
    """二分查找，非递归版"""
    left = 0
    right = len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == item:
            return True
        elif arr[mid] < item:
            left = mid + 1
        elif arr[mid] > item:
            right = mid - 1
    return False