目录
简介
定义和特征
定义：算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。
一个算法应该具有以下五个重要的特征：
- 有穷性：算法的有穷性是指算法必须能在执行有限个步骤之后终止；
- 确切性：算法的每一步骤必须有确切的定义；
- 输入项：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件；
- 输出项：一个算法有一个或多个输出，以反映对输入数据加工后的结果，没有输出的算法是毫无意义的；
- 可行性：算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步，即每个计算步都可以在有限时间内完成（也称之为有效性）。
设计要求
算法设计的要求:
- 确定性: 指的是算法至少应该有输入,输出和加工处理无歧义性，能正确反映问题的需求,能够得到问题的正确答案。确定性大体分为四个层次:
- 算法程序无语法错误;
- 算法程序对于合法的输入产生满足要求的输出;
- 对于非法输入能够产生满足规格的说明;
- 算法程序对于故意刁难的测试输入都有满足要求的输出结果。
- 可读性: 程序便于阅读,理解交流。
- 健壮性: 当输入数据不合法时,算法也能作出相关处理，而不是产生异常,崩溃或者莫名其妙的结果。
- 时间效率高和存储量低。
算法效率的度量方法
事后统计方法：主要是通过设计好的测试程序和数据，利用计算机计时器对不同算法编制的程序的运行时间进行比较，从而确定算法效率的高低，但这种方法有很大缺陷，一般不予采纳。
事前分析估算方法：在计算机程序编制前，依据统计方法对算法进行估算。
一个用高级语言编写的程序在计算机上运行时所消耗的时间取决于以下因素：
- 算法采用的策略，方法；（算法好坏的根本）
- 编译产生的代码质量；（由软件来支持）
- 问题的输入规模；（由数据决定）
- 机器执行指令的速度。（看硬件的性能）
算法时间复杂度
定义：在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随n的变化情况并确定T(n)的数量级。算法的时间复杂度，也就是算法的时间量度，记作：T(n) = O(f(n))。它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。其中f(n)是问题规定n的某个函数。
根据定义，求解算法的时间复杂度的具体步骤是：
- 找出算法中的基本语句；算法中执行次数最多的那条语句就是基本语句，通常是最内层循环的循环体。
- 计算基本语句的执行次数的数量级；只需计算基本语句执行次数的数量级，这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可，可以忽略所有低次幂和最高次幂的系数。这样能够简化算法分析，并且使注意力集中在最重要的一点上：增长率。
- 用大Ο记号表示算法的时间性能。将基本语句执行次数的数量级放入大Ο记号中。
如何推导大o阶呢？下面是基本的推导方法：
- 用常数1取代运行时间中的所有加法常数。
- 在修改后的运行次数函数中，只保留最髙阶项。
- 如果最高阶项存在且不是1,则去除与这个项相乘的常数。
简单的说，就是保留求出次数的最高次幂，并且把系数去掉。 如T(n)=n2+n+1 =O(n2)
一些例子
######复杂度O(1)
print("this is wd")
######复杂度O(n)
for i in range(n):
print(i)
######复杂度O(n2)
for i in range(n):
for j in range(n):
print(j)
######复杂度O(n3)
for i in range(n):
for j in range(n):
for k in range(n):
print('wd')
######复杂度O(log2n)
while n > 1:
print(n)
n = n // 2常见的复杂度按效率排序：O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(2nlogn)<O(n2)
常见的时问复杂度如表所示。
空间复杂度
空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。算法的输入输出数据所占用的存储空间是由要解决的问题决定的，是通过参数表由调用函数传递而来的，它不随本算法的不同而改变。存储算法本身所占用的存储空间与算法书写的长短成正比，要压缩这方面的存储空间，就必须编写出较短的算法。算法在运行过程中临时占用的存储空间随算法的不同而异，有的算法只需要占用少量的临时工作单元，而且不随问题规模的大小而改变，这种算法是节省存储的算法；有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元。
如当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)；当一个算法的空间复杂度与以2为底的n的对数成正比时，可表示为0(log2n)；当一个算法的空间复杂度与n成线性比例关系时，可表示为0(n).若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。
最坏情况与平均情况
我们查找一个有n 个随机数字数组中的某个数字，最好的情况是第一个数字就是，那么算法的时间复杂度为O(1)，但也有可能这个数字就在最后一个位置上待着，那么算法的时间复杂度就是O(n)，这是最坏的一种情况了。
最坏情况运行时间是一种保证，那就是运行时间将不会再坏了。 在应用中，这是一种最重要的需求， 通常， 除非特别指定， 我们提到的运行时间都是最坏情况的运行时间。
而平均运行时间也就是从概率的角度看， 这个数字在每一个位置的可能性是相同的，所以平均的查找时间为n/2次后发现这个目标元素。平均运行时间是所有情况中最有意义的，因为它是期望的运行时间。也就是说，我们运行一段程序代码时，是希望看到平均运行时间的。可现实中，平均运行时间很难通过分析得到，一般都是通过运行一定数量的实验数据后估算出来的。一般在没有特殊说明的情况下，都是指最坏时间复杂度。
搜索算法
搜索是在一个数据集合中找到一个特定数据的算法，通常的答案是真的或假的。搜索的常见方法有二分查找、哈希查找等
二分法查找
二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好。缺点是要求待查表为有序表。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。
二分查找的工作原理
- 首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功。
- 否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。
- 重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
二分查找的实现
def binary(l, val):
max = len(l)
min = 0
while min <= max:
mid = (max + min) // 2
if l[mid] > val:
max = mid - 1
elif l[mid] < val:
min = mid + 1
elif l[mid] == val:
print(mid)
break
else:
print('no')
def binary_rec(l, val, min, max):
mid = (max + min) // 2
if min > max:
print('no')
return 'no'
if l[mid] == val:
print(mid)
return mid
elif l[mid] < val:
return binary_rec(l, val, mid+1, max)
elif l[mid] > val:
return binary_rec(l, val, min, mid-1)排序算法
冒泡排序（Bubble Sort）
- 时间复杂度：最优时间复杂度：O(n)，最坏时间复杂度：O(n²)。
- 优点：稳定，简单
- 缺点：效率不很高，运行时间较长
原理如下：
- 比较相邻的元素，如果第一个比第二个大，就交换他们两个；
- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。做完以后，最后的元素会是最大的数，这里可以理解为走了一趟；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较，最后数列就是从大到小一次排列；
代码实现
def bubble_sort(data):
"""
冒泡排序
:param data:
:return:
"""
for i in range(len(data)-1): # 趟数
for j in range(len(data)-i-1): # 遍历数据，依次交换
if data[j]>data[j+1]: # 当较大数在前面
data[j],data[j+1]=data[j+1],data[j] #交换两个数的位置优化版本：当某一趟走完以后发现并没有进行数据交换，那么此时的数列已经排列好了，没有必要在进行下去。例如：极端情况下，数列本来已经排序好的，我们只需要走一趟即可完成排序。
def bubble_sort(data):
"""
冒泡排序优化版
:param data:
:return:
"""
for i in range(len(data)-1): # 趟数
exchange=False # 交换标志
for j in range(len(data)-i-1): # 遍历数据，依次交换
if data[j]>data[j+1]: # 当较大数在前面
data[j],data[j+1]=data[j+1],data[j] # 交换两个数的位置
exchange = True # 改变标志
if not exchange: # 如果某一趟没有进行交换，代表排序完成
break
return i # 返回次数的趟数选择排序（Selection Sort）
- 时间复杂度：最优时间复杂度：O(n²)；最坏时间复杂度：O(n²)
- 稳定性：不稳定
- 优点：移动次数少
- 缺点：比较次数多
工作原理
- 每一次从待排序的列表中选出一个元素，并将其与其他数依次比较，若列表中的某个数比选中的数小，则交换位置，把所有数比较完毕，则会选出最小的数，将其放在最左边（这一过程称为一趟）；
- 重复以上步骤，直到全部待排序的数据元素排完；
实现
def select_sort(data):
"""
选择排序
:param data: 待排序的数据列表
:return:
"""
for i in range(len(data)-1): #趟数
min_index=i # 记录i趟开始最小的数的索引，我们从最左边开始
for j in range(i+1,len(data)): # 每一次趟需要循环的次数
if data[j] < data[min_index]: # 当数列中的某一个数比开始的数要小时候，更新最小值索引位置
min_index=j
data[i],data[min_index]=data[min_index],data[i] # 一趟走完，交换最小值的位置，第一趟最小插入排序（Insert Sort）
- 时间复杂度：最优时间复杂度：O(n)；最坏时间复杂度：O(n²)
- 稳定性：稳定
- 优点：稳定，比较快
- 缺点：比较次数不确定，数据量越大，该算法越渣
工作原理如下：
- 以从小到大排序为例，元素0为第一个元素，插入排序是从元素1开始，尽可能插到前面。
- 插入时分插入位置和试探位置，元素i的初始插入位置为i，试探位置为i-1，在插入元素i时，依次与i-1,i-2······元素比较，如果被试探位置的元素比插入元素大，那么被试探元素后移一位，元素i插入位置前移1位，直到被试探元素小于插入元素或者插入元素位于第一位。
- 重复上述步骤，最后完成排序
实现
def insert_sort(data):
"""
插入排序
:param data: 待排序的数据列表
:return:
"""
for i in range(1, len(data)): # 无序区域数据
tmp = data[i] # 第i次插入的基准数
for j in range(i, -1, -1):
if tmp < data[j - 1]: # j为当前位置，试探j-1位置
data[j] = data[j - 1] # 移动当前位置
else: # 位置确定为j
break
data[j] = tmp # 将当前位置数还原快速排序（Quick Sort）
- 时间复杂度：
- 最优时间复杂度：O(nlogn)遍历每个数是O(n)，访问每个数是O(logn)，最终是O(nlogn)可以转换为求二叉树深度的思想
- 最坏时间复杂度：O(n²)
- 稳定性：不稳定
- 优点：效率高，数据移动比较少，数据量越大，优势越明显
- 缺点：不稳定
快速排序（Quicksort），又称划分交换排序（partition-exchange sort）。通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序。整个排序过程可以递归进行，以此达到整个数据变成有序序列。
工作原理如下：
- 从数列中随机挑选出一个数作为基数；
- 重新排列数列，使得比基数小的元素在左边，比基数大元素在右边，相等的元素放左边或者右边都可以，最后使得该基数在处于数列中间位置，这个称为分区操作；
- 递归上述操作，完成排序
实现
def quick_sort(data,left,right):
"""
快速排序
:param data: 待排序的数据列表
:param left: 基准数左边元素的索引
:param right: 基准数右边元素的索引
:return:
"""
if left < right:
mid = partition(data,left,right) # 分区操作,mid代表基数所在的索引
quick_sort(data,left,mid-1) # 对基准数前面进行排序
quick_sort(data,mid+1,right) # 对基准数后面进行排序
def partition(data,left,right):
tmp=data[left] # 随机选择的基准数,从最左边开始选
while left < right:
while left < right and data[right] >= tmp: # 右边的数比基准数大
right-=1 # 保留该数，然后索引指针往左移动
data[left]=data[right] # 否则此时右边数比基数小，则将该数放到基准位置
while left < right and data[left] <= tmp: # 右边的数比基准数小
left+=1 # 此时保持该数位置不动，索引指针往前移动
data[right]=data[left] # 否则此时左边的数比基数大，则将该数放到右边
data[left] = tmp # 最后将基准数量放回中间
return left # 返回基准数位置归并排序（Merge Sort）
- 最优时间复杂度：O(nlogn)最坏时间复杂度：O(nlogn)
- 稳定性：稳定
- 优点：稳定，数据量越大越优秀
- 缺点：需要额外空间
归并排序（MergeSort）是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。
归并排序是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。
工作原理如下：
- 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
- 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
- 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
- 重复步骤3直到某一指针达到序列尾；
- 将另一序列剩下的所有元素直接复制到合并序列尾
实现
def merge(data, low, mid, high):
"""
合并函数
:param data: 数据列表
:param low: 列表开头位置
:param mid: 分割中间位置
:param high: 列表最后位置
:return:
"""
i = low # 第一个指针
j = mid + 1 # 第二个指针
tmp = [] # 临时存放的列表
while i <= mid and j <= high: # 分割的列表当两边都有数才进行
if data[i] < data[j]:
tmp.append(data[i])
i += 1 # 低的指针往右移动
else:
tmp.append(data[j]) # 右边大，存右边的数
j += 1 # 同时指针右移动
while i <= mid: # 左边分割有剩下
tmp.append(data[i])
i += 1
while j <= high: # 右边有剩下
tmp.append(data[j])
j += 1
data[low:high + 1] = tmp # 最后将tmp中的数写入到原来的列表中
def merge_sort(data, low, high):
"""
归并排序
:param data: 待排序的数据列表
:param low: 数据列表开始位置
:param high: 数据列表结束位置
:return:
"""
if low < high: # 至少有两个元素才进行
mid = (low + high) // 2 # 分割
merge_sort(data, low, mid) # 递归分割上一部分
merge_sort(data, mid + 1, high) # 递归分割下一部分
merge(data, low, mid, high) # 合并
堆排序Heap Sort）
- 时间复杂度：最优时间复杂度：O(nlogn)，最坏时间复杂度：O(nlogn)
- 稳定性：不稳定
本质是一个完全二叉树，如果根节点的值是所有节点的最小值称为小根堆，如果根节点的值是所有节点的最大值，称为大根堆。
原理：
- 将待排序数据列表建立成堆结构(建立堆)；
- 通过上浮(shift_up)或下沉(shift_down)等操作得到堆顶元素为最大元素（已大根堆为例）；
- 去掉堆顶元素，将最后的一个元素放到堆顶，重新调整堆，再次使得堆顶元素为最大元素（相比第一次为第二大元素）；
- 重复3操作，直到堆为空，最后完成排序；
# -*- coding:utf8 -*-
import random
def sift(li, low, high):
# li表示树, low表示树根, high表示树最后一个节点的位置
tmp = li[low]
i = low
j = 2 * i + 1 # 初识j指向空位的左孩子
# i指向空位,j指向两个孩子
while j <= high: # 循环退出的第二种情况: j>high,说明空位i是叶子节点
if j + 1 <= high and li[j] < li[j+1]: #如果右孩子存在并且比左孩子大,指向右孩子
j += 1
if li[j] > tmp:
li[i] = li[j]
i = j
j = 2 * i + 1
else: # 循环退出的第一种情况:j位置的值比tmp小,说明两个孩子都比tmp小
break
li[i] = tmp
def heap_sort(li):
n = len(li)
# 1. 构造堆
for low in range(n//2-1, -1, -1):
sift(li, low, n-1)
# 2. 挨个出数
for high in range(n-1, -1, -1):
li[0], li[high] = li[high], li[0] # 退休 棋子
sift(li, 0, high-1)
import copy
li = list(range(1000))
random.shuffle(li)
heap_sort(li)
print li
希尔排序（Shell Sort）
- 最优时间复杂度：根据步长序列的不同而不同，最优是1.3，根据数学运算算出的gap
- 最坏时间复杂度：O(n²)
- 稳定性：不稳定
- 优点：平均时间短，数据移动少
- 缺点：不稳定
希尔排序（Shell Sort）是插入排序的一种，也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法，是DL．Shell于1959年提出的。
工作原理如下：
- 先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。
- 先在各组内进行直接插入排序；
- 取第二个增量d2<d1重复上述的分组和排序，直至所取的增量 =1( < …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
def shell_sort(data):
"""
希尔排序
:param data:待排序的数据列表
:return:
"""
d1 = len(data) // 2 # 设置分割大小为d1，
while d1 > 0:
for i in range(d1, len(data)): # 在插入排序中 d1 为 1
tmp = data[i] # 当前分割元素位置
j = i - d1 # 上一个分割元素位置
while j >= 0 and tmp < data[j]: # 上一个元素分割位置比当前分割位置要大，则需要调整位置
data[j + d1] = data[j] # 后移动当前分割元素位置
j -= d1 # 往前移d1
data[j + d1] = tmp
d1 //= 2 # 继续分割计数排序（count_sort）
- 时间复杂度：最优时间复杂度：O(n)，最坏时间复杂度：O(n)
- 稳定性：稳定
- 优点：速度快
- 缺点：有局限性，范围不能太大，只能是整数
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。
算法描述
- 找出待排序的数组中最大和最小的元素；
- 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
def count_sort(li, max_num):
count = [0 for i in range(max_num + 1)] #设置计数序列并初始化为0
for num in li:
count[num] += 1
i = 0
for num,m in enumerate(count):
for j in range(m):
li[i] = num
i += 1
桶排序（Bucket Sort）
- 时间复杂度：最优时间复杂度：O(n)，最坏时间复杂度：O(n)
- 稳定性：稳定
- 缺点：如果数据分布集中，如只分布在一个桶，效果不好。需要额外空间
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。
桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。
算法描述
- 设置一个定量的数组当作空桶；
- 遍历输入数据，并且把数据一个一个放到对应的桶里去；
- 对每个不是空的桶进行排序；
- 从不是空的桶里把排好序的数据拼接起来。
def bucket_sort(data):
buckets = [0] * ((max(data) - min(data)) + 1) # 初始化桶元素为0
for i in range(len(data)):
buckets[data[i] - min(data)] += 1 # 遍历数组a，在桶的相应位置累加值
ret_data = []
for i in range(len(buckets)):
if buckets[i] != 0:
ret_data += [i + min(data)] * buckets[i]
print(ret_data)
return ret_data基数排序（Radix Sort）
- 时间复杂度：最优时间复杂度：O(n)，最坏时间复杂度：O(n)
- 稳定性：稳定
- 缺点：只能处理正整数。需要额外空间
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
基数排序基于分别排序，分别收集，所以是稳定的。但基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n) ，当然d要远远小于n，因此基本上还是线性级别的。
基数排序的空间复杂度为O(n+k)，其中k为桶的数量。一般来说n>>k，因此额外空间需要大概n个左右。
算法描述
- 取得数组中的最大数，并取得位数；
- arr为原始数组，从最低位开始取每个位组成radix数组；
- 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
def radix_sort(li):
max_num = max(li)
i = 0
while (10 ** i <= max_num):
buckets = [[] for _ in range(10)]
for val in li:
digit = val // (10 ** i) % 10
buckets[digit].append(val)
li.clear()
for bucket in buckets:
for val in bucket:
li.append(val)
i += 1
总结
618
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
