用python实现一些基本算法

最新推荐文章于 2024-08-29 20:23:32 发布
最新推荐文章于 2024-08-29 20:23:32 发布
阅读量311 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32446743/article/details/79498518
版权 
感悟：重点不在于代码[通过各种方法最终都能搓出来],而在于思想[多看多了解]。

一、冒泡算法

[bubble_sort]
def bubble_sort(L):
    len_for_L = len(L)
    for i in range(len_for_L-1):
        flag = 0
        for j in range(len_for_L-1-i):
            if L[j] > L[j+1]:
                L[j+1],L[j] = L[j],L[j+1]
            flag = 1
        if flag == 0:
            break
    print(L)
L = [1,7,8,4,3,6,5,9,0]
bubble_soft(L)

二、二分查找

# 前提：L必须是提前排好序的
[binary_sort]
def binary_soft(L,x):
    lower,higher = 0,len(L)-1
    while lower<higher:
        mid = (lower + higher) // 2
        if x == L[mid]:
            return mid
        elif x > L[mid]:
            lower += 1
        elif x < L[mid]:
            higher -= 1

L = [1,2,3,4,5,6,7,8,9]
print(binary_soft(L,6))

三、插入排序（很慢）

# 基本思想: 将一个数插入到已经排好序的数据列中，使得新的数据列也是排好序的。


[insert_soft]
def insert_soft(L):
    # 依次插入数据
    for i in range(1,len(L)):
        # 在内部处理排好i之前的所有数据的排序
        while i > 0:
            if L[i] >= L[i-1]:
                break   # 核心1[如果已经比前面最后一个值大，就直接结束循环，避免浪费时间]
            else:
                L[i],L[i-1] = L[i-1],L[i]
                i = i-1 # 核心2[不停更换i的值]
    return L

四、直接选择排序

[direct_sort]
def direct_sort(L):
    for i in range(len(L)-1):
        # 找到i之后最小的那一个
        min = i
        for j in range(i+1,len(L)):
            min = j if L[min] > L[j] else min
        L[i],L[min] = L[min],L[i]
    return L

L = [1,2,3,4,5,7,10,1.2]
print(direct_sort(L))

五、快速排序

# 原创版本[根据快速排序基本思想]
def quick_sort(L,left,right):
  if left >= right:
        return L
    lower = left
    higher = right
    key = left
    # 每一次大while就将L按照[key左边的值都比L[key]小,key右边的值都比L[key]大]
    while left < right:
        # 进行一次右边比较
            while left < right: # 确保右边所有的都比L[key]值大
                if L[key] > L[right]:
                    L[key],L[right] = L[right],L[key]
                    key = right
                    break
                right -= 1
            while left < right: # 确保左边所有的都比L[key]值小
                if L[key] < L[left]:
                    L[key], L[left] = L[left], L[key]
                    key = left
                    break
                left += 1

    # 以上以完成[key左边的值都比L[key]小,key右边的值都比L[key]值大]

    quick_sort(L, lower, key-1)  # 递归[再次排序key左边所有值]
    quick_sort(L, key+1, higher)  # 递归[再次排序key右边所有值]
    return L


[进一步优化版本]
# quick_sort
def quick_sort(L,left,right):
    if left >= right:
        return L
    lower = left
    higher = right
    key = left
    # 每一次大while就将L按照[key左边的值都比L[key]小,key右边的值都比L[key]大]
    while left < right:
        # 进行一次右边比较
            while left < right and L[right] > L[key]:
                right -= 1
            # key = right [此句可以省略]
            L[key],L[right] = L[right],L[key]
            while left < right and L[left] < L[key]:
                left += 1
            L[key],L[left] = L[left],L[key]
            key = left
    quick_sort(L, lower, key-1)
    quick_sort(L, key+1, higher)
    return L

L = [6,2,7,3,8,9,5,10,-1]
print(quick_sort(L,0,len(L)-1))


[以下排序将于2018/8/28更新]

 

六、希尔排序

[xier_sort原创版本]
[代码中包含插入排序思想，但还是有所不同]

def xier_sort(L):
    len_for_L = len(L)
    group = len_for_L//2
    while group > 0:
        # 每循环一次,group值就地板除2
        for i in range(0,group+1): # 这里需要加1,确保L[group]和L[group+group..]能正确访问                            
            j = i+group
            # 因为这里会存在j-=group和j+=group,
            while j < len_for_L:
                # 如果是符合后面数大于前面数，就往后走
                if L[j] >= L[j-group]:
                    j+=group
                # 如果后面数比前面数字还小，就需要回溯，放置L[j]的值
                else:
                    L[j],L[j-group] = L[j-group],L[j]
                    j-=group
                # 如果出现一个数，比grup还小，那么后续while的j-group就会出问题
                if j < group:
                    j += group
        group = group // 2
    return L

L = [1,5,4,7,2,9,10,15,-2.5,0,6]
print(xier_sort(L))
[优化版本: 使用temp记录回溯前的j值,减少重复判断]
def xier_sort(L):
    len_for_L = len(L)
    group = len_for_L//2
    while group > 0:
        # 每循环一次,group就除以一半
        for i in range(0,group+1):
            j = i+group
            # 因为这里会存在j-=group和j+=group,
            while j < len_for_L:
                # 如果是符合后面数大于前面数，就往后走
                if L[j] >= L[j-group]:
                    j+=group
                    temp = j
                # 如果后面数比前面数字还小，就需要回溯，放置L[j]的值
                else:
                    L[j],L[j-group] = L[j-group],L[j]
                    j-=group
                # 如果出现一个数，比grup还小,说明已完成对L[j]的排序，直接跳到回溯前的j值
                if j < group:
                    j = temp
        group = group // 2
    return L

L = [1,5,4,7,2,9,10,15,-2.5,0,6]
print(xier_sort(L))



[c语言版本]

#include <stdio.h>

int data[] = {1,5,4,7,2,9,10,15,-2,0,6};
const int len_for_data = sizeof(data)/sizeof(int); 

void go_on(int *a);

void main(){
	go_on(data);
	for(int i=0; i<len_for_data; i++){
		printf("%d\n", data[i]);
	}
}

void go_on(int *a){
	int temp1, temp2; 
	int group = len_for_data/2; //地板除
	while(group > 0){ //当group = 1的时候
		//下面是插入排序逻辑
		for(int i=0; i<group+1; i++){
			int j = i+group; //模仿插入排序,表示这个一个后面来的数据[要插入]
			while(j<len_for_data){
				if(a[j] >= a[j-group]){
					j+=group;
					//记录最后一个排队的人
					temp1 = j;
				}
				else{
					temp2 = a[j];
					a[j] = a[j-group];
					a[j-group] = temp2;
					/*printf("%d, %d", a[j], a[j-group]);*/
					j -= group; //如果出现后面比前面还小,说明插入排序有问题,就
				}
				//按照插入排序,j必须大于group才行
				//如果小于group,说明前面全排好了,直接跳到最后就行了
				if(j<group){ 
					j = temp1;
				}
			}
		}
		group = group/2;//修改group,直到group为1做完最后一次排序
	}
}

 

 

七、归并排序

[基本思想: 先分(拆分成left,right) 后治(合并left,right)]
def dispatch(L):
    if len(L)<=1:
        return L
    mid = len(L)//2
    left = dispatch(L[:mid])
    right = dispatch(L[mid:])
    return merge(left,right)

def merge(left, right):
    l,r = 0,0
    result = []
    # left和right在同等条件下逐个值相互比较
    while l < len(left) and r < len(right):
        if left[l] <= right[r]:
            result.append(left[l])
            l+=1  # 如果result得到了左边的数,那么左边计数+1,对左边后一位数进行判断,相反,右边计数不变(等待下一次判断)[这样所有的数都能参与判断]
        else:
            result.append(right[r])
            r += 1  # 同理l+=1
    result.extend(left[l:])
    result.extend(right[r:])
    return result

L = [1,2,9,6,5,4,0,2.1,7.9]
print(dispatch(L))


[将于2018/8/29 更新堆排序]

 

八、堆排序

def heap_sort(L):
    count = len(L)
    for root in range(count//2-1, -1, -1):
        big_heap(L, root, count-1)
    for end in range(count-1,0,-1):
        L[end],L[0] = L[0],L[end]
        big_heap(L, 0, end-1)
    return L

def big_heap(L, root, end):
    """
        遍历当前节点和当前节点下方所有节点，确保当前节点一下数据为最大堆
    """
    while True:
        child = 2*root +1
        if child > end:
            break
        if child+1 <= end and L[child+1] > L[child]:
            child += 1
        if L[child] > L[root]:
            L[child],L[root] = L[root],L[child]
            root = child
        else:
            break

print(heap_sort([1,5,6,9,3,4,2,7,9.5,10.2]))

九、计数排序

[count_sort]
参考：https://www.cnblogs.com/developerY/p/3166462.html

[基本思想]
条件：存在一个列表L
根据列表最大值max[假设列表最小元素为0,所有数都在0~max之间],创建一个max+1大小的列表k[len(k)-1 = max]
然后遍历原始数据,在k中统计L中值和K序号相等的个数
创建一个和列表L相同大小的列表M
逆向遍历列表L,在k中L值对应的序号,在M中根据此序号值放入到M中[每进行一次操作,k中对应序号-1]

个人总结:
     计数排序是一种用空间换时间(效率)的排序,过程中需要额外构造新列表(尤其是k列表,对数据的规格要求比较高)
 但想法简单,可能适合有些情景(局限性较大),说实话,个人觉得这个算法没什么意思，本不想写的...,但为了博客完整性，还是写在下面了。

def count_sort(L):
    list_for_count = [0]*(max(L)+1)
    result_list = [0]*len(L)
    # 统计原始列表L中各值的元素个数,并将值填入list_for_count中
    for content in L:
        if list_for_count[content]==0:
            list_for_count[content] = L.count(content)
    for i in range(1, len(list_for_count)):
        list_for_count[i] = list_for_count[i]+list_for_count[i-1]
    # 逆向遍历L,在统计列表中查找指定元素的存放位置
    for content in L[-1::-1]:
        # 此处list_for_count[content]-1(是因为list_for_count统计的是个数,而序列号永远比个数少一)
        result_list[list_for_count[content]-1] = content
        list_for_count[content] -= 1
    return result_list

L = [1,2,9,6,5,4,0,5,8]
print(count_sort(L))

 

十、基数排序

import math

def bucket_sort(L):
    # 首先得到L中最大元素的位数[有几次表示要进行几次桶排序]
    max_digit = int(math.ceil(math.log(max(L),10)))
    # 根据max_digit创建桶(一共10个桶)
    bucket = [[] for i in range(10)]
    # eg:如果max_digit=4,当i=0表示判断个位
    for i in range(max_digit+1):
        # 将数据放入桶中
        for content in L:
            bucket[content//(10**i)%10].append(content) 
        # print(bucket)
        L = []
        # 从桶中取出数据,进行下一次桶排序
        for each in bucket:
            L.extend(each)
        # print(L)
        # 清空桶,方便下一次桶排序
        bucket = [[] for i in range(10)]
    return L

L = [1,2,9,6,5,4,0,10,100,45,67]
print(bucket_sort(L))

补充: content//(10**i)%10 基于
       1234//1%10    = 4   # 得到个位
       1234//10%10   = 3   # 得到十位
       1234//100%10  = 2   # 得到百位
       1234//1000%10 = 1   # 得到千位

 

 

To be a cool guy
关注
DSA:数据结构和算法的python实现
04-01
DSA 数据结构和算法的python实现
python算法思想简介
weixin_45290455的博客
08-12 364
算法是独立存在的一种解决问题的方法和思想。 算法的五大特性： 输入：算法具有0个或者多个输入 输出： 算法至少有1个或者多个输出 有穷性 确定性 可行性 例子：如果 a+b+c=500,且a^3+ b^3 = c^3(a,b,c为自然数)，如何求出所有a,b,c的值。首先想到的是采用枚举法。 python代码实现如下： import time #统计程序运行时间 start_time=tim...
python实现DSA
weixin_49563201的博客
11-12 685
由于在网上查找了很多python实现DSA的资料也没有找到合适的代码，所以最终还是凭着网上查找到的代码与自己研究勉强写下了以下代码。以上便是我所写的代码，如有欠妥之处，还请多多批评指正，以便共同进步。
【图解DSA数字签名算法】DSA签名算法的Python实现 | 物联网安全 | 信息安全
热门推荐
菜菜的菜园子
04-21 1万+
图解DSA签名算法，附Python实现过程
DSA python
qq_36298219的博客
12-29 1563
import hashlib def Euclid(a,b): x1 = 1 x2 = 0 x3 = a y1 = 0 y2 = 1 y3 = b while y3 != 0 : q = int(x3/y3) t1 = x1-q*y1 t2 = x2-q*y2 t3 = x3...
python实现换位加密算法的示例
09-20
在Python中实现换位加密算法可以方便地创建简单但有效的加密工具。 在提供的代码中，`translationCipher` 函数实现了换位加密的过程。它接受两个参数：`msg` 是待加密的字符串，`key` 是每行的字符数，即换位的单位...
python实现PageRank算法
07-25
总结来说，"python实现PageRank算法"是一个涉及数据处理、矩阵运算、迭代算法和可能的大数据并行计算的项目。通过理解并实现这个项目，不仅可以深入理解PageRank的工作原理，还能提升Python编程和大数据处理的技能。
Python实现调度算法代码详解
09-21
通过上述的 Python 实现，我们可以有效地将中缀表达式转换为后缀表达式，这不仅是调度算法的一个实例，同时也展示了词法分析、语法分析以及算法设计的基本思想。这种方法不仅可以应用于编译原理领域，还可以扩展到更...
python实现汉诺塔算法
01-20
除了最基本的之外，还有一题，给定一个数组，arr=[2,3,1,2,3]，其含义是这是一个有5个圆盘的汉诺塔，每一个数字代表这个圆盘所在的位置，1代表左边的柱子，2代表中间，3代表右边。给出这个序列代表了汉诺塔移动的第...
蚁群算法用python实现
05-17
蚁群算法的基本思想是模拟蚂蚁在搜索过程中释放信息素的行为。蚁群中的每只蚂蚁都会走动并在路径上释放信息素，在每次迭代中，蚂蚁根据信息素浓度选择路径，信息素浓度高的路径更容易被选择。通过多次迭代，蚁群逐渐...
DSAinPython:Python中数据结构和算法的不同实现以及一些现实生活中的应用程序项目
03-16
Udacity NanoDegree数据结构和算法项目 Python中有关数据结构和算法的一系列问题，包括： 在不同数据结构上的搜索和排序算法 评估算法效率，时间和空间复杂度 先进的算法，例如蛮力贪婪算法，图算法和动态编程 问题描述 问题1：将一系列开放性问题解构为较小的组件（例如，输入，输出，一系列功能）。 问题2：开放式练习问题：LRU缓存，专用块链，文件递归。 问题3：现实世界中的开放性问题：Web服务器的请求路由，搜索项自动完成和Fibonacci堆 问题4：使用A *算法来查找最短路径的路线规划算法，用于计算地图上两点之间的最短路径。
鸽群算法--python代码
02-08
2014 年 段 海 滨 教 授 通 过 归 纳 总 结 ， 提 出 鸽 群 算 法（Pigeon-inspired Optimization PIO），PIO 是模拟鸽子归巢行为而设计出来的群智能优化算法。PIO 具有原理简明的特点、需要调整参数极少、易于被实现。与其他算法比较有着计算相对简单，鲁棒性相对较强等明显的优点。
sm4国密算法python实现
01-05
实现SM4的加密和解密，加密前按PKCS#7对明文消息进行填充。 输入和输出要求：加密时，输出加密的每一轮的中间结果和最后的密文；解密时，输出解密的每一轮的中间结果和最后的明文。
dsa数字签名算法的验证及实现
06-26
实现数字签名算法以及验证数字签名算法的正确性。本程序经本人验证
python实现sm4国密算法
05-10
python实现的国产加密SM4算法
Python实现SM4加解密算法
最新发布
qq_42568323的博客
08-29 760
SM4是一种对称分组密码算法，每次操作128位数据块，密钥长度也为128位。SM4算法结构基于Feistel网络，拥有32轮加密和解密过程。主要包括密钥扩展、S盒替换、线性变换、轮密钥异或等步骤。SM4算法是一种高效的对称加密算法，在信息安全领域有着广泛应用。上述Python代码实现了SM4算法的加密和解密过程，可以帮助更深入理解其原理和应用。
Python:实现pigeon sort鸽巢算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-08 259
Python:实现pigeon sort鸽巢算法(附完整源码)
LZW算法的个人理解与简单Python实现
海洋顶端
05-13 3719
参考http://bcb.lcsoft.net/document-2027.html（我是参照他括号里给出不同的实现，即“STRING  =  STRING  + CHARACTER" 和 “CHARACTER  =  first  character  in  STRING "） 参考博文对LZW算法的解释比较详细。所以这里只谈谈我个人是如何理解这个算法。表达不是很清晰，请原谅。 压缩过程不
小丑鱼python_sm4加密 解密（oc）
weixin_39901685的博客
12-04 1359
前几天项目用到sm4加密解密，加密为十六进制字符串，再将十六进制字符串解密。网上百度了下，sm4是密钥长度和加密明文加密密文都为16个字节十六进制数据，网上的sm4 c语言算法很容易搜到，笔者刚开始没怎么理解，以为只能对16字节数据进行加密，并且不论是多少字节的数据加密出来都是16字节的。后来看了下源码，应该是加密的数据应该是16字节或者16的整数倍个字节的数据，若不够16倍数字节应该补0x00数...
Python实现随机森林算法详解及应用
- 在本教程中，作者使用Python实现了随机森林算法，并将其应用于声纳数据集，用于解决预测问题，如分类或回归。 6. **实验与实践**： - 实现随机森林算法的关键在于编写代码，包括数据预处理、特征选择、构建决策...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值