【算法】排序算法

"""
列表元素交换
"""

list = [1,4,6,9]
list[0],list[1] = list[1],list[0]
print(list)

"""
选择排序法：递增/递减
"""

# 找出最小值
# ---------------------------------------
def find_min(list):
    a = 0
    for i in range(1,len(list)):
        if list[i] < list[a]:      
        # 如果要求从大到小的顺序排列则将<改为>
            a = i
    return list[a]
# ---------------------------------------
list = [56,18,49,84,72]

# 交换两个元素
tmp = find_min(list)
list[0] = tmp

# print(list)
# new_list = []
# new_list.append(find_min(list))
# print(new_list)

'''选择排序法'''

def choose(num):
    for i in range(0,len(num)-1):
        a = i

        # 找出最小值
        for j in range(i+1, len(num)):
            if num[j] < num[a]:
                a = j

        # 交换两个值
        temp = num[a]
        num[a] = num[i]
        num[i] = temp
        print(num)
    return num

num = [8,23,6,18,19,17,7]
print(choose(num))

"""
直接插入排序法
"""
def istrtsort(nums):
    for i in range(1,len(nums)):
        key = nums[i]            # 插入值
        j = i-1                  # 记录插入位置  j+1 代表插入的位置
        while (j>=0 and key < nums[j]):
            nums[j+1] = nums[j]
            j = j - 1
        nums[j+1] = key
    return nums

nums = [50, 36, 66, 76, 95, 12, 25]
print(istrtsort(nums))

# def istrtsort(nums):
#     for i in range(len(nums)):
#         while nums[i - 1] > nums[i] and i - 1 >= 0:
#             nums[i], nums[i - 1] = nums[i - 1], nums[i]
#             i = i - 1
#     return nums
#
# if __name__ == '__main__':
#     array = [50, 36, 66, 76, 95, 12, 25]
#     print(istrtsort(array))

def istrtsort(data):

    for i in range(1, len(data)):
        value = data[i]  # 插入值
        j = i - 1  # 记录插入位置  j+1 代表插入的位置
        while j >= 0:  # 不用 for 循环是因为 j 为 -1 的情况
            if data[j] > value:
                data[j + 1] = data[j]
            else:
                break
            j -= 1

        data[j + 1] = value
    return data

"""
冒泡排序法
"""
def bubble_sort(array):
    for i in range(1, len(array)):
        for j in range(0, len(array) - i):
            # print('i', array[i])
            # print('j', array[j])
            if array[j] > array[j + 1]:
                array[j], array[j + 1] = array[j + 1], array[j]
    return array

if __name__ == '__main__':
    array = [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]
    print(bubble_sort(array))



# 检测过程变换
def maopao(list):
    for i in range(1,len(list)+1):
        for j in range (0, len(list)):
            if list[j]>list[i]:
                list[j], list[i] = list[i], list[j]
            else:
                print(list)

list = [56, 20, 84, 66 ,13]
maopao(list)

"""
折半插入排序法
"""

# def main(arr):
#     list = []
#     for node in arr:
#         end = len(list)
#         start = 0
#         medium = (end - start) // 2
#         if 0 != end:
#             while True:
#                 if node > list[medium]:
#                     start = medium + 1
#                 else:
#                     end = medium
#
#                 medium = start + (end - start) // 2
#                 if start >= end:
#                     break
#         list.insert(start, node)
#         # for a in list:
#         #     print(a)
#         # print('------------')
#     print(list)
#
#
# if __name__ == '__main__':
#     arr = (5, 2, 1, 83, 491, 3, 45, 21, 56, 235, 61, 36, 13, 4, 643, 123, 64)
#     main(arr)


def BinaryInsertSort(mylist):
    for i in range(1, len(mylist)):
        
        tmp = mylist[i]                 # 将当前元素暂存起来
        low = 0                         # 在当前位置之前的范围查找插入
        high = i - 1 
        while low <= high:
            m = int((low + high) / 2)   # tmp比范围中点大，范围后半段作为新的查找范围
            if tmp > mylist[m]:
                low = m + 1
            else:   
                high = m - 1             # tmp比范围中点小，范围前半段作为新的查找范围   
        j = i - 1                        # 此时mylist[high]的元素比tmp小 
        while j >= high + 1:             # mylist[high]之后的元素往后挪一位
            mylist[j + 1] = mylist[j]
            j -= 1
        mylist[high + 1] = tmp           # 将tmp放在mylist[high]之后

if __name__ == "__main__":
    mylist = [49, 38, 65, 87, 76, 13, 27, 49]
    BinaryInsertSort(mylist)
    print(mylist)

"""
合并排序法
核心：将数列不断对半分割
"""

# def all_num(num):
#     print(len(num))
#     while (len(num)//2) != 1:
#         num = num[:len(num)//2]
#         # b = num[len(num)//2:]
#         print(num)
#         # print(b)
#
# nums=[33,10,49,78,57,96,66,21]
# all_num(nums)


def merge_sort(lis):
    # 递归结果条件
    if len(lis) <= 1:
        return lis
    # 分治进行递归
    mid = len(lis)//2
    left = merge_sort(lis[:mid])
    right = merge_sort(lis[mid:])

    # 将两个有序组进行合并
    result=[]
    i=j=0
    while i<len(left) and j<len(right):
        #将较小值放入到result中
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    #将未扫描到的直接追加到result后面
    if i==len(left):
        result.extend(right[j:])
    else:
        result.extend(left[i:])
    return result

a=[2,6,7,5,3,8,1]
print(merge_sort(a))

"""
希尔排序法
"""
def hill(data):
    n = len(data)
    step = n // 2                # 让步长从大变小，最后一步必须是1,获取gap的偏移值
    print('step的值：', step)
    while step >= 1:             # 只要gap在我们的合理范围内，就一直分组下去j
        for j in range(step, n): # 按照步长把数据分两半，从步长的位置遍历后面所有的数据,指定j下标的取值范围
            print('j的值：',j)
            while j - step >= 0: # 拿当前位置的数据，跟当前位置-gap 位置的数据进行比较
                if data[j] < data[j - step]: # 组内大小元素进行替换操作
                    data[j], data[j - step] = data[j - step], data[j]
                    j -= step    # 更新迁移元素的下标值为最新值
                    print('j的值2：', j)
                else:            # 否则的话，不进行替换
                    break
                print('排序后列表：',data)
            print('------------------------')
        step //= 2               # 每执行完毕一次分组内的插入排序，对gap进行/2细分
        print('step的值：',step)

• 快速排序法
• 堆排序法
• 计数排序法
• 基数排序法