Python排序算法与快速排序

排序算法

import random
import time

冒泡排序

arr = [5, 2, 1, 3, 8, 6]*1000

def bubble_sort():
    for i in range(len(arr) - 1):
        for j in range(1, len(arr) - i):
            # j-1和j进行比较
            if arr[j - 1] > arr[j]:
                # 交换
                arr[j - 1], arr[j] = arr[j], arr[j - 1]

bubble_sort()
print(arr)

选择排序

arr = list(range(1, 1000))
random.shuffle(arr)

def select_sort():
        # 选择次数 n-1
        for i in range(len(arr) - 1):
            # 找i及以后的位置中最小的位置
            min_index = i
            # 扫描i以后的序列中是否存在更小的位置
            for j in range(i + 1, len(arr)):
                if arr[j] < arr[min_index]:
                    min_index = j
            # 判断最小位置和当前位置是否恰好重合
            if i != min_index:
                arr[i], arr[min_index] = arr[min_index], arr[i]

插入排序

def insert_sort():
        for i in range(1, len(arr)):
            # 为arr[i]找到一个插入位置
            # 监视哨
            temp = arr[i]

            # 待插入的位置
            insert_index = i
    
            # 向前判断
            while insert_index > 0 and temp < arr[insert_index - 1]:
                arr[insert_index] = arr[insert_index - 1]
                insert_index -= 1
    
            # 插入数据
            arr[insert_index] = temp

非原地快排

 def quick_sort1(sort_arr: list):
        """
        进行列表的划分 将列表划分为左 中 右
        :param sort_arr:待划分的列表
        :return: 最终的连接左中右的列表
        """
        if len(sort_arr) <= 1:
            return sort_arr
        # 准备三个列表 左 中 右
        less, pivot, right = [], [sort_arr[0]], []

        # 循环1-末尾
        for i in range(1, len(sort_arr)):
            if sort_arr[i] < pivot[0]:
                less.append(sort_arr[i])
            elif sort_arr[i] == pivot[0]:
                pivot.append(sort_arr[i])
            else:
                right.append(sort_arr[i])
    
        # 返回划分结果
        return quick_sort1(less) + pivot + quick_sort1(right)

原地排序

  def quick_sort2(start: int, end: int):
        """
        将序列的一部分划分为左小右大
        :param start: 序列的起始位置
        :param end: 序列的结束位置
        :return: None
        """
        if start < end:
            s = start
            e = end
            # 临界值在的一端的标识
            # True:临界值在s端  False:临界值在e端
            flag = True

            while s != e:
                if arr[s] > arr[e]:
                    arr[s], arr[e] = arr[e], arr[s]
                    # 临界值:从s端变为e端  e端变为s端
                    flag = not flag
                # 移动s或e
                if flag:
                    e -= 1
                else:
                    s += 1
    
            # 继续将左边的部分再划分
            quick_sort2(start, e - 1)
            # 继续将右边的部分再划分
            quick_sort2(s + 1, end)

   # print(arr)
        s = time.time()
        # select_sort()
        # insert_sort()
        # quick_sort1(arr)
        # arr.sort()
        quick_sort2(0, len(arr) - 1)
        print(time.time() - s)
        print(arr)

折半查找

import random
    
    arr = [random.randint(1, 100) for i in range(50)]
    
    
    def binary_search(s_list, key):
        # 定义起始和结束
        start = 0
        end = len(s_list) - 1
    
        while start <= end:
            # 中间位置:
            mid = (start + end) // 2
            if s_list[mid] == key:
                return mid
            elif key > s_list[mid]:
                # 修改start的值
                start = mid + 1
            else:
                end = mid - 1
        # 未找到
        return -1
    
    
    arr.sort()
    print(arr)
    print(binary_search(arr, 19))