简单基本算法

1. 冒泡排序

import random

"""
冒泡排序: 循环遍历对每一个(n-1)元素进行和其下一位的元素进行比较, 如果元素大于下一位的元素则交换, 不大于继续循环
"""
"""
时间复杂度: O(n**n)
"""
def pu(li):
    for i in range(len(li)):
        for j in range(i+1, len(li)):
            if li[i] > li[j]:
                li[i], li[j] = li[j], li[i]

    print("排序后的列表:", li)


li = list(range(0, 10))
random.shuffle(li)
print("排序前原始列表:", li)
pu(li)

2. 选择排序

import random

"""
选择排序: 循环遍历列表, 找出无序区最小的数和无序区第一个位置元素进行互换(交换后无序区第一个位置开始成为有序区), 无序区循环一次减少一
"""
"""
时间复杂度: O(n**n)
"""

def select_soct(li):
    for i in range(len(li) - 1):    # 循环一次无序区减少1, 有序区增加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]
        print("排序过程中的列表:", li)

li = list(range(10))
random.shuffle(li)
print("排序前原始列表:", li)
select_soct(li)
print("排序后的列表", li)

3. 插入排序

import random

"""
插入排序: 类似于扑克牌摸牌时中整理牌的过程, 手里摸到的元素要找到左面元素比其小, 右面元素比其大的位置插入
插入排序的主要思想是每次取一个列表元素与列表中已经排序好的列表段进行比较，然后插入从而得到新的排序好的列表段，最终获得排序好的列表
"""

def insert_soct(li):
    """将当前循环的元素的值比较成为摸到的扑克牌"""
    for i in range(1, len(li)):
        j = i-1  # 用来和当前循环元素进行对比的索引
        key = li[i]     # 将此时循环的值作为临时变量, 用来做j索引的元素作比较
        while j >= 0 and key < li[j]:   # 当前循环的元素小于当前循环元素的前一个元素的情况下
            li[j + 1] = li[j]   # 将当前循环位置的元素替换成当前循环元素的前一个元素的值
            j -= 1  # 将用来作为对比的元素索引向前移动一位， 继续进行比较， 知道比较至索引为0的元素

        li[j+1] = key   # 如果当前循环的元素不比它前一位元素小,就将其放置在其前一位元素的后一位


li = list(range(10))
random.shuffle(li)
print(li)
insert_soct(li)
print(li)

 4. 快速排序

import random

"""
快排思想: 取一个值(索引为0的元素), 将此值做归位处理, 此值左侧为小于此值的元素, 右侧为大于此值的元素; 将此操作递归处理
时间复杂度: n*log(n)
"""

def quick_sort(li, left, right):
    if left < right:
        mid = partition(li, left, right)    # 此方法为将元素归位处理的方法,返回索引下标
        quick_sort(li, left, mid - 1)   # 将分为两部分的序列做递归处理
        quick_sort(li, left + 1, mid)


def partition(li, left, right):
    """假设left为序列最左侧的元素, right为序列的最后一位"""
    """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(10))
random.shuffle(li)
print("排序前序列:", li)
quick_sort(li, 0, len(li)-1)
print("排序后的序列", li)

5. 二分法

"""
二分法思想: 取有序序列的中间元素, 用来做比较使用; 当需要查找的元素的比中间元素大,将序列的左边界设置为中间元素的下一个元素, 当需要查找的元素比重要简元素小,将序列的右边界设置为中间元素的前一位元素
            重复此操作, 直到左边界不小于右边界为止
"""

def second_minute(lis):
    c = int(input("输入需要查找的数字(1-9):"))
    left = 0
    right = len(lis) - 1
    while left < right:
        mid = (left + right) // 2
        if c > lis[mid]:
            left = mid + 1
        elif c < lis[mid]:
            right = mid - 1
        elif c == lis[mid]:
            return mid
    return mid


lis = [1, 2, 3, 4, 5, 6, 7, 8, 9]
w = second_minute(lis)
print("要查的数在序列的第%s个位置上" % str(w + 1))