python第三十二天-----算法

算法（Algorithm）：一个计算过程，解决问题的方法
时间复杂度：用来评估算法运行效率的一个东西
ps：在日常使用中，请使用sort()，because no zuo no die！

1.冒泡排序：
指针如同气泡一样一个个由下向上浮，每次上浮如果上面的数比自己小则交换位置，这样就保证每次可以使最大的数字排列在最上面，重复此过程直到所有数有序；时间复杂度为O(n2)，wtf,平方怎么打，就酱吧。

1 def bubble_sort_x(data):
2     for i in range(len(data)-1):                        # 在循环到最后一个数的时候就不需要再比较了，因为此时列表已经排列好了
3         for j in range(len(data)-i-1):                    # 指针一点点上浮的过程
4             if data[j] > data[j+1]
5             data[j+1], data[j] = data[j], data[j+1]

"调优后"，但是你会发现并不是真正的调优，时快时慢，因为此调优仅对当某次交换完成后发现下面的数并未进行交换(也就是已经排序好了)，那么就可以认为已经完成可以返回了，但是因为是这种特殊情况并不是每次都会出现，但是每次循环你必须要做一次判断，so，这个时间开销却是必须的，因此权衡利弊这下，北神还是觉得上面的好，简单易懂，萌萌哒。

1 def bubble_sort(data):
2     for i in range(len(data)-1):
3         exchange = False
4         for j in range(len(data) - i - 1):
5             if data[j] > data[j+1]:
6                 data[j], data[j+1] = data[j+1], data[j]
7                 exchange = True
8         if not exchange:
9             return

2.选择排序：
默认以无序区第一个数为列表内的最小数，然后遍历列表开始跟默认比较大小，如果发现了比默认值小的则成为新的默认最小数，遍历完成后会发现列表中的最小数再与第一个数互换位置，重复此过程就可以保证列表从第一个数开始由小到大排序；时间复杂度为O(n2)，运行时间比冒泡快，因为它与冒泡一样都对数就行了比较，但是并没有直接互换位置，直到一次循环完成后找到了最小数才进行了一次位置互换，so，冒泡排序被吊打了。

1 def insert_sort_x(data):
2     for i in range(len(data)-1):
3         min_loc = i
4         for j in range(i+1, len(data)):                        # 从下一个开始跟i比较
5             if data[j] < data[min_loc]:
6                 min_loc = j
7         data[i], data[min_loc] = data[min_loc], data[i]

3.希尔排序：
选择排序的升级版本，讲列表进行多次分段后各自进行排序，最后形成一个偏向有序的大列表，然后对整个大列表进行一次选择排序形成最终有序列表，看不懂就对了，没什么卵用。

 1 def shell_sort_x(data):
 2     gap = int(len(data) // 2)
 3     while gap >= 1:
 4         for i in range(gap, len(data)):
 5             tmp = data[i]
 6             j = i - gap
 7             while j >= 0 and tmp < data[j]:
 8                 data[j + gap] = data[j]
 9                 j -= gap
10             data[i - gap] = tmp
11         gap = gap // 2

4.快速排序：
取第一个元素x使其归位，列表分成两部分，左边都比x小，右边都比x大，然后对这两边递归进行排序。

 1 def quick_sort_x(data, left, right):
 2     mid = partition(data, left, right)                        # x归位
 3     quick_sort_x(data, left, mid-1)
 4     quick_sort_x(data, mid+1, right)
 5
 6 def partition(data, left, right):
 7     tmp = data[left]
 8     while left < right:
 9         while left < right and data[range] >= tmp:
10             right -= 1
11         data[left] = data[right]
12         while left < right and data[left] <= tmp:
13             left += 1
14         data[right] = data[left]
15     data[left] = tmp

5.归并排序：
将数组递归切分成单个元素后对比排序合并。

 1 def merge_sort_x(data, low, high):
 2     if low < high:
 3         mid = (low + high) // 2
 4         merge_sort_x(data, low, mid)
 5         merge_sort_x(data, mid+1, high)
 6         merge(data, low, mid, high)
 7
 8 def merge(data, low, mid, high):
 9     i = low
10     j = mid + 1
11     ltmp = []
12     while i <= mid and j <= high:
13     if data[i] < data[j]:            # 两边数依次取出比较大小
14         ltmp.append(data[i])
15         i += 1
16     else:
17         ltmp.append(data[j])
18         j += 1
19     while i <= mid:                    # 下面2个while只有一个会执行
20         ltmp.append(data[i])
21         i += 1
22     while j <= high:
23         ltmp.append(data[j])
24         j += 1
25     data[low:high+1] = ltmp

6.插入排序:
默认第一个元素是有序的，然后根据依次比较下一个元素与有序区内元素确定其位置。

1 def insert_sort_x(data):
2     for i in range(1, len(data)):
3         tmp = data[i]
4         j = i - 1
5         while j >= 0 and tmp < data[j]:
6             data[j + 1] = data[j]
7             j -= 1
8         data[j + 1] = tmp

7.堆排序：
建立一个堆，后去掉堆顶元素为最大元素放置于堆末尾(之后不参与计算)，通过一次调整再次得到堆顶，循环重复此过程。

 1 def sift(data, low, high):
 2     i = low
 3     j = 2 * i + 1
 4     tmp = data[i]
 5     while j <= high:
 6         if j < high and data[j] < data[j + 1]:
 7             j += 1
 8         if tmp < data[j]:
 9             data[i] = data[j]
10             i = j
11             j = 2 * i + 1
12         else:
13             break
14     data[i] = tmp
15
16 def heap_sort_x(data):
17     n = len(data)
18     for i in range(n // 2 - 1, -1, -1):
19         sift(data, i, n - 1)
20     for i in range(n - 1, -1, -1):
21         data[0], data[i] = data[i], data[0]
22         sift(data, 0, i - 1)

转载于:https://www.cnblogs.com/bfmq/p/6761840.html

python第三十二天-----算法相关推荐

python数据结构与算法总结
python常用的数据结构与算法就分享到此处,本月涉及数据结构与算法的内容有如下文章: <数据结构和算法对python意味着什么?> <顺序表数据结构在python中的应用> ...
数学推导+纯Python实现机器学习算法：GBDT
Datawhale推荐作者:louwill,Machine Learning Lab 时隔大半年,机器学习算法推导系列终于有时间继续更新了.在之前的14讲中,笔者将监督模型中主要的单模型算法基本都过 ...
以图搜图Python实现Hash算法
以图搜图(一):Python实现dHash算法 http://yshblog.com/blog/43 以图搜图(二):Python实现pHash算法 http://yshblog.com/blog/4 ...
em算法python代码_EM 算法求解高斯混合模型python实现
注:本文是对<统计学习方法>EM算法的一个简单总结. 1. 什么是EM算法? 引用书上的话: 概率模型有时既含有观测变量,又含有隐变量或者潜在变量.如果概率模型的变量都是观测变量,可以直接 ...
Python：SMOTE算法——样本不均衡时候生成新样本的算法
Python:SMOTE算法直接用python的库, imbalanced-learn imbalanced-learn is a python package offering a number ...
Python基于聚类算法实现密度聚类(DBSCAN)计算
本文实例讲述了Python基于聚类算法实现密度聚类(DBSCAN)计算.分享给大家供大家参考,具体如下: 算法思想基于密度的聚类算法从样本密度的角度考察样本之间的可连接性,并基于可连接样本不断扩展聚 ...
NLP之ASR：基于python和机器学习算法带你玩转的语音实时识别技术
NLP之ASR:基于python和机器学习算法带你玩转的语音实时识别技术导读带你玩转python实现的语音实时识别技术(包括音频混音.回声消除.噪音滤除.杂音消除.静音检测等方法) 视频观看: 软 ...
python文字识别算法_Python图像处理之图片文字识别（OCR）
OCR与Tesseract介绍将图片翻译成文字一般被称为光学文字识别(Optical Character Recognition,OCR).可以实现OCR 的底层库并不多,目前很多库都是使用共同的几 ...
Python实现kNN算法
Python实现kNN算法 1. 原理 k-最近邻: kNN(k-NearestNeighbor)分类算法机器学习中最简单的分类方法之一.所谓K最近邻,就是k个最近的邻居的意思,说的是每个样本都可以用 ...
【机器学习基础】数学推导+纯Python实现机器学习算法30：系列总结与感悟
Python机器学习算法实现 Author:louwill Machine Learning Lab 终于到了最后的总结.从第一篇线性回归的文章开始到现在,已经接近有两年的时间了.当然,也不是纯写这3 ...

python第三十二天-----算法

python第三十二天-----算法相关推荐

最新文章

热门文章