python 实现经典算法

  1 import time
  2 start_time = time.clock()
  3
  4 list_ = [9, 2, 7, 4, 5, 6, 3, 8, 1]
  5
  6
  7 """
  8 # 堆排序
  9 # 最大堆调整:将堆的末端子节点调整,使得子节点永远小于父节点。
 10 # 建立最大堆:将堆所有数据重新排序。
 11 # 堆排序:移除位在第一个数据的根节点,并做最大堆调整的递归运算。
 12 import random
 13
 14
 15 def max_heapify(heap, heapsize, root):
 16     # 最大堆调整
 17     left = 2 * root + 1
 18     right = left + 1
 19     larger = root
 20     if left < heapsize and heap[larger] < heap[left]:
 21         larger = left
 22     if right < heapsize and heap[larger] < heap[right]:
 23         larger = right
 24     if larger != root:
 25         heap[larger], heap[root] = heap[root], heap[larger]
 26         max_heapify(heap, heapsize, larger)
 27
 28
 29 def build_max_heap(heap):
 30     # 构造一个堆,将堆中所有数据重新排序
 31     heapsize = len(heap)
 32     for i in range((heapsize - 2) // 2, -1, -1):
 33         max_heapify(heap, heapsize, i)
 34
 35
 36 def heapsort(heap):
 37     # 将根节点去除与最后一位做对调,对前面len-1个节点继续进行对调整过程。
 38     build_max_heap(heap)
 39     for i in range(len(heap) - 1, -1, -1):
 40         heap[0], heap[i] = heap[i], heap[0]
 41         max_heapify(heap, i, 0)
 42     return heap
 43
 44
 45 if __name__ == ‘__main__‘:
 46     a = [30, 50, 57, 77, 62, 78, 94, 80, 84]
 47     print(a)
 48     heapsort(a)
 49     print(a)
 50     # b = [random.randint(1, 1000) for i in range(1000)]
 51     # print(b)
 52     # heapsort(b)
 53     # print(b)
 54 # --------------------------------------------------------------
 55
 56 # 归并排序
 57 # 首先用分割的方法将这个序列分割成一个个已经排好序的子序列,然后
 58 # 再利用归并的方法将一个个的子序列合并成排序号的序列
 59 def merge(left, right):
 60     result = []
 61     while left and right:
 62         result.append(left.pop(0)) if left[0] < right[0] else result.append(right.pop(0))
 63     while left:
 64         result.append(left.pop(0))
 65     while right:
 66         result.append(right.pop(0))
 67     return result
 68
 69
 70 def mergesort(l):
 71     if len(l) < 2:
 72         return l
 73     mid_index = len(l) // 2
 74     left = mergesort(l[:mid_index])
 75     right = mergesort(l[mid_index:])
 76     return merge(left, right)
 77
 78
 79 print(mergesort(list_))
 80 # --------------------------------------------------------------
 81
 82 # 希尔排序
 83 def shell_sort(l):
 84     n = len(l)
 85     gap = n // 2
 86     while gap > 0:
 87         for i in range(gap, n):
 88             temp = l[i]  # 每个步长进行插入排序
 89             j = i
 90             # 插入排序
 91             while j >= gap and l[j - gap] > temp:
 92                 l[j] = l[j - gap]
 93                 j -= gap
 94             l[j] = temp
 95         gap = gap // 2
 96     return l
 97
 98
 99 print(shell_sort(list_))
100 # --------------------------------------------------------------
101
102 # 插入排序
103 # 从索引1开始,一次与其左边的数相比较,若比自己大则插入并删除自己。
104 def insertsort(l):
105     len_ = len(l)
106     for i in range(1, len_):
107         for j in range(i):
108             if l[j] > l[i]:
109                 l.insert(j, l[i])
110                 l.pop(i+1)
111                 break
112     return l
113
114
115 print(insertsort(list_))
116 # --------------------------------------------------------------
117
118 # 快速排序
119 # 选定一个基数如第一个元素
120 # 将比基数小的和比基数大的元素分别放在新列表里并按顺序排列相加
121 # 递归直到新列表元素只有一个
122 def quicksort(l):
123     len_ = len(l)
124     if len_ < 2:
125         return l
126     else:
127         pivot = l[0]
128         less = [i for i in l[1:] if i < pivot]
129         greater = [j for j in l[1:] if j > pivot]
130         print(less, greater)
131         return quicksort(less) + [pivot] + quicksort(greater)
132
133
134 print(quicksort(list_))
135 # --------------------------------------------------------------
136
137 # 选择排序
138 # 将第一个数与右边数的最小值相比较,若本身较大则与最小值调换位置
139 # 依次遍历即可
140 def selectsort(l):
141     len_ = len(l)
142     for i in range(len_ - 1):
143         for j in range(i+1, len_):
144             min_ = min(l[j:])
145             min_index = l.index(min_)
146             if l[i] > min_:
147                 l[i], l[min_index] = l[min_index], l[i]
148     return l
149
150
151 print(selectsort(list_))
152 # --------------------------------------------------------------
153
154 # 冒泡排序
155 # 从索引0开始依次本身和右边的元素,若右边小则调换位置,来取得最大值
156 # 然后依次循环把较大的轮换到右边
157 def bubblesort(l):
158     len_ = len(l)
159     for i in range(len_ - 1):
160         for j in range(len_ - i - 1):
161             if l[j] > l[j+1]:
162                 l[j], l[j+1] = l[j+1], l[j]
163     return l
164
165
166 print(bubblesort(list_))
167 """
168
169 end_time = time.clock()
170 print(end_time - start_time)

目前对于堆排序还不太熟练,以备后续重温复习。

原文地址:https://www.cnblogs.com/guolei2570/p/8794566.html

时间: 2024-10-11 07:06:07

python 实现经典算法的相关文章

python每日经典算法题5(基础题)+1(中难题)

现在,越来越多的公司面试以及考验面试对算法要求都提高了一个层次,从现在,我讲每日抽出时间进行5+1算法题讲解,5是指基础题,1是指1道中等偏难.希望能够让大家熟练掌握python的语法结构已经一些高级函数的应用.这些题目是在某些刷题的网站上登记的有水平的题目.这里如果有需要input的简单题,就略去了输出结果.如果时间充裕,则就会增加每日更多习题. 一:基础算法题10道 1.判断用户输入的年份是否为闰年 题目解析: (1)问题分析:能被4整除但不能被100整除的年份为普通闰年,能被400整除的年

python每日经典算法题5(基础题)+1(较难题)

一:基础算法题5道 1.阿姆斯特朗数 如果一个n位正整数等于其各位数字的n次方之和,则称该数为阿姆斯特朗数.判断用户输入的数字是否为阿姆斯特朗数. (1)题目分析:这里要先得到该数是多少位的,然后再把每一位的数字截取出来,把各位数字的n次方之和和该数一起判断即可.(2)算法分析:python中有len()函数可以得到一个字符串的长度,因此需要先把一个正整数转化为正整数字符串.然后从高位向低位截取(也可以反过来).或者高效算法利用for循环切片. 从高位到低位:用正整数除了10的n次方,得到的商就

python经典算法

# 非波拉锲数列 def fibs(num): the_list=[] a,b,i=0,1,1 for i in range(num-1): a,b=b,a+b print b fibs(10) python经典算法,布布扣,bubuko.com

机器学习经典算法详解及Python实现---朴素贝叶斯分类及其在文本分类、垃圾邮件检测中的应用

摘要: 朴素贝叶斯分类是贝叶斯分类器的一种,贝叶斯分类算法是统计学的一种分类方法,利用概率统计知识进行分类,其分类原理就是利用贝叶斯公式根据某对象的先验概率计算出其后验概率(即该对象属于某一类的概率),然后选择具有最大后验概率的类作为该对象所属的类.总的来说:当样本特征个数较多或者特征之间相关性较大时,朴素贝叶斯分类效率比不上决策树模型:当各特征相关性较小时,朴素贝叶斯分类性能最为良好.另外朴素贝叶斯的计算过程类条件概率等计算彼此是独立的,因此特别适于分布式计算.本文详述了朴素贝叶斯分类的统计学

机器学习经典算法具体解释及Python实现--线性回归(Linear Regression)算法

(一)认识回归 回归是统计学中最有力的工具之中的一个. 机器学习监督学习算法分为分类算法和回归算法两种,事实上就是依据类别标签分布类型为离散型.连续性而定义的. 顾名思义.分类算法用于离散型分布预測,如前面讲过的KNN.决策树.朴素贝叶斯.adaboost.SVM.Logistic回归都是分类算法.回归算法用于连续型分布预測.针对的是数值型的样本,使用回归.能够在给定输入的时候预測出一个数值.这是对分类方法的提升,由于这样能够预測连续型数据而不不过离散的类别标签. 回归的目的就是建立一个回归方程

机器学习经典算法具体解释及Python实现--K近邻(KNN)算法

(一)KNN依旧是一种监督学习算法 KNN(K Nearest Neighbors,K近邻 )算法是机器学习全部算法中理论最简单.最好理解的.KNN是一种基于实例的学习,通过计算新数据与训练数据特征值之间的距离,然后选取K(K>=1)个距离近期的邻居进行分类推断(投票法)或者回归.假设K=1.那么新数据被简单分配给其近邻的类.KNN算法算是监督学习还是无监督学习呢?首先来看一下监督学习和无监督学习的定义.对于监督学习.数据都有明白的label(分类针对离散分布,回归针对连续分布),依据机器学习产

机器学习经典算法详解及Python实现--基于SMO的SVM分类器

原文:http://blog.csdn.net/suipingsp/article/details/41645779 支持向量机基本上是最好的有监督学习算法,因其英文名为support vector machine,简称SVM.通俗来讲,它是一种二类分类模型,其基本模型定义为特征空间上的间隔最大的线性分类器,其学习策略便是间隔最大化,最终可转化为一个凸二次规划问题的求解. (一)理解SVM基本原理 1,SVM的本质--分类 给定一些数据点,它们分别属于两个不同的类,现在要找到一个线性分类器把这些

机器学习经典算法详解及Python实现--聚类及K均值、二分K-均值聚类算法

摘要 聚类是一种无监督的学习(无监督学习不依赖预先定义的类或带类标记的训练实例),它将相似的对象归到同一个簇中,它是观察式学习,而非示例式的学习,有点像全自动分类.说白了,聚类(clustering)是完全可以按字面意思来理解的--将相同.相似.相近.相关的对象实例聚成一类的过程.机器学习中常见的聚类算法包括 k-Means算法.期望最大化算法(Expectation Maximization,EM,参考"EM算法原理").谱聚类算法(参考机器学习算法复习-谱聚类)以及人工神经网络算法

机器学习经典算法详解及Python实现--CART分类决策树、回归树和模型树

摘要: Classification And Regression Tree(CART)是一种很重要的机器学习算法,既可以用于创建分类树(Classification Tree),也可以用于创建回归树(Regression Tree),本文介绍了CART用于离散标签分类决策和连续特征回归时的原理.决策树创建过程分析了信息混乱度度量Gini指数.连续和离散特征的特殊处理.连续和离散特征共存时函数的特殊处理和后剪枝:用于回归时则介绍了回归树和模型树的原理.适用场景和创建过程.个人认为,回归树和模型树