Python 排序算法集合

企业开发 2023-04-06 17:39:30 阅读次数: 0

Python 排序算法集合

插入排序

from turtle import right
import numpy as np


length = 10
nums = np.random.randint(100, size=length)
nums = list(nums)
print(nums)

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

def insert_sort(arr, n):
    for i in range(n):
        j = i - 1
        while j >= 0 and arr[j] > arr[j+1]:
            swap(arr, j, j+1)
            j = j - 1

def bin_insert_sort(arr, num):
    left = 0
    right = len(arr) - 1
    middle = left + ((right - left) >> 1)
    while  left < middle:
        if arr[middle] < num:
            left = middle
        elif arr[middle] > num:
            right = middle
        else:
            left = middle
            right = middle
        middle = left + ((right - left) >> 1)
    arr.insert(right, num)


insert_sort(nums, len(nums))
print(nums)
bin_insert_sort(nums, 10)
print(nums)

选择排序

import numpy as np

length = 10
nums = np.random.randint(100, size=length)
nums = list(nums)
print(nums)

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

def select_sort(arr, n):
    for i in range(n):
        mini_index = i
        for j in range(i+1, n):
            if arr[j] < arr[mini_index]:
                mini_index = j
        swap(arr, mini_index, i)

select_sort(nums, len(nums))
print(nums)

冒泡排序

import numpy as np

length = 10
nums = np.random.randint(100, size=length)
nums = list(nums)
print(nums)

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

def bubbleSort(arr, n):
    for i in range(n):
        flag = 0
        for j in range(n-i-1):
            if arr[j] > arr[j+1]:
                swap(arr, j, j+1)
                flag += 1
        if flag == 0:
            break
bubbleSort(nums, len(nums))
print(nums)

谢尔排序

import numpy as np


length = 10
nums = np.random.randint(100, size=length)
nums = list(nums)
print(nums)

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

def shell_sort(arr, n):
    gap = n
    while gap > 1:
        gap = gap >> 1
        flag = 0
        for i in range(n - gap):
            if arr[i] > arr[gap+i]:
                swap(arr, i ,gap+i)
                flag += 1
        if flag == 0:
            break

shell_sort(nums, len(nums))
print(nums)

快速排序

import numpy as np

length = 10
nums = np.random.random(length)
nums = list(nums)
print(nums)

def quickSort(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)
        quickSort(arr, left, partitionIndex - 1)
        quickSort(arr, partitionIndex+1, right)
    return arr

def partition(arr, left, right):
    # pivot = left
    # index = pivot + 1
    # for i in range(index, right+1):
    #     if arr[i] < arr[pivot]:
    #         swap(arr, i, index)
    #         index += 1
    # swap(arr, pivot, index - 1)
    # return index - 1
    num = arr[np.random.randint(left, right+1)] # 随机快速排序 O(n*log(n))
    # num = arr[left] # 最坏情况下慢一些
    i = left
    while i <= right:
        if arr[i] > num:
            swap(arr, i, right)
            right -= 1
        elif arr[i] < num: 
            swap(arr, i, left)
            left += 1
            i += 1
        else:
            i += 1
    
    return i-1


def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

print(quickSort(nums))

快速排序2

import numpy as np


length = 10
nums = np.random.randint(100, size=length)
nums = list(nums)
print(nums)

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]


def quick(arr, oral_left, oral_right):
    if oral_left >= oral_right:
        return
    num = arr[oral_left]
    left = oral_left
    right = oral_right
    i = left
    while i <= right:
        if arr[i] > num:
            swap(arr, i, right)
            right -= 1
        elif arr[i] < num:
            swap(arr, i, left)
            left += 1
            i += 1
        else:
            i += 1
    print(arr, i)
    quick(arr, oral_left, i-2)
    quick(arr, i, oral_right)

    

def quick_sort(arr, n):
    quick(arr, 0, n-1)

quick_sort(nums, len(nums))
print(nums)

堆积排序

from math import log2
import numpy as np


length = 10
nums = np.random.randint(100, size=length)
nums = list(nums)
print(nums)

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]


def heapDown(arr, index):
    left_index = 2*index + 1
    while left_index <= len(arr):
        large_index = left_index + 1 if (left_index+1) < len(arr) and arr[left_index] < arr[left_index+1] else left_index
        if arr[large_index] > arr[index]:
            swap(arr, large_index, index)
            index = large_index
            left_index = 2*index + 1
        else:
            break


def heap_sort_insert(arr, num):
    arr.append(num)
    index = len(arr) - 1

    while arr[int((index - 1) / 2)] < arr[index]:
        swap(arr, index, int((index - 1) / 2))
        index = int((index - 1) / 2)

# first
res = []
for num in nums:
    heap_sort_insert(res, num)
print(res)
# second
for i in range(len(nums)//2):
    heapDown(nums, len(nums)//2-i-1)
print(nums)

堆积排序2

from math import log2

import numpy as np
import math

length = 10
nums = np.random.randint(100, size=length)
nums = list(nums)
print(nums)


"""
父节点 int((index-1)/2) 子节点 2*index+1 和 2*index+2
"""
def heapInsert(arr, num):
    arr.append(num)
    temp_index = len(arr)-1
    while arr[temp_index] > arr[int((temp_index-1)/2)]: # temp_index > 0 可以省略
        swap(arr, temp_index, int((temp_index-1)/2))
        temp_index = int((temp_index-1)/2)

def heapDown(arr, index):
    left_index = 2*index + 1
    while left_index <= len(arr):
        large_index = left_index + 1 if (left_index+1) <= len(arr) and arr[left_index] < arr[left_index+1] else left_index
        if arr[large_index] > arr[index]:
            swap(arr, large_index, index)
            index = large_index
            left_index = 2*index + 1
        else:
            break





def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]


def print_nums(nums):
    depth = math.log2(len(nums) + 1)
    i = 1
    while i < depth:
        print(nums[pow(2,i-1)-1: pow(2, i)-1])
        i += 1
    print(nums[pow(2,i-1)-1:])

# heapInsert(nums, 100)
arr = []
for num in nums:
    heapInsert(arr, num)
print_nums(arr)
print_nums(nums)
heapDown(nums, 0)
print_nums(nums)

归并排序

import numpy as np

nums = np.random.random(5)
nums = list(nums)

def mergeSort(nums_part):
    if len(nums_part) == 1:
        return nums_part
    middle = len(nums_part) >> 1
    return Sort(mergeSort(nums_part[:middle]), mergeSort(nums_part[middle:]))

def Sort(nums_part1, nums_part2):
    res = []
    while len(nums_part1) > 0 and len(nums_part2) > 0:
        if nums_part1[0] > nums_part2[0]:
            res.append(nums_part1.pop(0))
        else:
            res.append(nums_part2.pop(0))
    res += nums_part1
    res += nums_part2

    return res

print(mergeSort(nums))

归并排序2

import numpy as np


length = 10
nums = np.random.randint(100, size=length)
nums = list(nums)
print(nums)

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

def merge_arr(arr1, arr2):
    i = 0
    j = 0
    res=  []
    while i < len(arr1) and j < len(arr2):
        if arr1[i] < arr2[j]:
            res.append(arr1[i])
            i += 1
        elif arr1[i] > arr2[j]:
            res.append(arr2[j])
            j += 1
        else:
            res.append(arr1[i])
            res.append(arr2[j])
            i += 1
            j += 1
    res = res + arr1[i:] + arr2[j:]
    return res

def merge_sort(nums):
    if len(nums) == 1:
        return nums
    middle = len(nums) >> 1
    return merge_arr(merge_sort(nums[:middle]), merge_sort(nums[middle:]))

print(merge_sort(nums))

计数排序

import numpy as np


length = 10
nums = np.random.randint(5, size=length)
nums = list(nums)
print(nums)

def count_sort(arr, max_num):
    count_list = np.zeros(max_num)
    res = []
    for num in arr:
        count_list[num] += 1
    for i in range(len(count_list)):
        res +=  [i] * int(count_list[i])
    return res

print(count_sort(nums, 5))

桶排序

import numpy as np


length = 10
nums = np.random.randint(200, size=length)
nums = list(nums)
print(nums)

def num_max_length(arr):
    max_num = arr[0]
    for num in arr:
        if max_num < num:
            max_num = num
    res = 0
    while max_num > 0:
        max_num = max_num // 10
        res += 1

    return res

def bucketsort(arr, max_length):
    for i in range(max_length):
        help = [[] for _ in range(10)]
        for num in arr:
            help[int((num/pow(10, i))%10)].append(num)
        arr = []
        for i in range(len(help)):
            arr += help[i]
    return arr

print(bucketsort(nums, num_max_length(nums)))

猜你喜欢

转载自blog.csdn.net/qq_40608730/article/details/123100147
今日推荐
手把手教你用 LangChain 实现大模型 Agent
外星人入侵（python）
超全的免费chatGPT列表【建议收藏】
52.2k star! 自己部署gpt4free, 免费使用各种GPT
2024年 （第十届）全国大学生统计建模大赛优秀论文解析——中国经济发展与碳排放库兹涅茨曲线的验证研究
【自动驾驶技术】自动驾驶汽车AI芯片汇总——NVIDIA篇
7个免费的ChatGPT网站，给大家送上
Angular v18 正式发布！
【VMware】 vCenter Converter standalone 6.6.0正式版下载
开源日报 | Angular v18；大模型价格战下的推理优化；Mistral AI以开源模型瞄准美国市场；硅谷有自己的鲁迅
数学建模Matlab之数据预处理方法
充电桩---ISO15118协议详细介绍
周排行
keepalived实现LB配置
数据库相关中间件收录集
Spring Boot 入门之 Web 篇（二） Spring Boot 入门之 Web 篇（二）
gitee 搭建个人网站
Java校招基础知识总结（横扫BAT,就业经验交流会演讲稿）
工程管理器
Delphi定位TDataSet数据集最后一条记录
cocos2dx笔记1:概述
Java实现 LeetCode 110 平衡二叉树
MacBook IDEA激活码
每日归档
更多
2024-05-30(4)
2024-05-29(65)
2024-05-28(2)
2024-05-27(56)
2024-05-26(6)
2024-05-25(68)
2024-05-24(65)
2024-05-23(9)
2024-05-22(41)
2024-05-21(8)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022