s11d27 算法
Posted 王巧妹
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了s11d27 算法相关的知识，希望对你有一定的参考价值。
s11d27 算法
一、理论
1.1 时间复杂度和空间复杂度的理论:
1）空间复杂度:
是程序运行所以需要的额外消耗存储空间,一般的递归算法就要有o(n)的空间复杂度了,
简单说就是递归集算时通常是反复调用同一个方法，递归n次，就需要n个空间。
2）时间复杂度
一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
算法的基本操作重复执行的次数是模块n的某一个函数f（n），因此，算法的时间复杂度记做：T（n）=O（f（n））。
随着模块n的增大，算法执行的时间的增长率和f（n）的增长率成正比，所以f（n）越小，算法的时间复杂度越低，算法的效率越高。
1.2 函数调用的时间复杂度分析
按数量级递增排列，常见的时间复杂度有：
常数阶O(1), 对数阶O(log2n), 线性阶O(n), 线性对数阶O(nlog2n), 平方阶O(n^2)， 立方阶O(n^3),...， k次方阶O(n^k), 指数阶O(2^n)
常用的时间复杂度所耗费的时间从小到大依次是：O(1)<O(log2n)<O(n)<O(nlog2n)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)
常用的算法的时间复杂度和空间复杂度
|
排序法 |
平均时间复杂度 |
说明 |
稳定度 |
空间复杂度 |
备注 |
|
冒泡排序 |
O(n2) |
将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮 |
稳定 |
O(1) |
|
|
快速排序 |
O(n*log2n) |
先选择中间值，然后把比它小的放在左边，大的放在右边（具体的实现是从两边找，找到一对后交换）。然后对两边分别使用这个过程（递归）。 |
不稳定 |
O(log2n)~O(n) 因为用到了递归！ |
|
|
选择排序 |
O(n2) |
首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。以此递归。 |
稳定 |
O(1) |
|
|
插入排序 |
O(n2) |
逐一取出元素，在已经排序的元素序列中从后向前扫描，放到适当的位置 |
稳定 |
O(1) |
起初，已经排序的元素序列为空 |
|
堆排序 |
O(n*log2n) |
利用堆（heaps）这种数据结构来构造的一种排序算法。堆是一个近似完全二叉树结构，并同时满足堆属性：即子节点的键值或索引总是小于（或者大于）它的父节点。 |
不稳定 |
O(1) |
近似完全二叉树 |
|
希尔排序 |
O |
选择一个步长(Step) ,然后按间隔为步长的单元进行排序.递归,步长逐渐变小,直至为1. |
不稳定 |
O(1) |
|
|
箱排序 |
O(n) |
设置若干个箱子，把关键字等于 k 的记录全都装入到第k 个箱子里 ( 分配 ) ，然后按序号依次将各非空的箱子首尾连接起来 ( 收集 ) 。 |
|
O(1) |
分配排序的一种：通过" 分配 " 和 " 收集 " 过程来实现排序。 |
当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)
访问数组中的元素是常数时间操作，一个算法如果能在每个步骤去掉一半数据元素，如二分检索，通常它就取 O(logn)时间。
二、查找算法
2.1 两分法
aList = [1, 2, 3, 4, 5, 6, 7, 8]
def binarySearch(aList, t):
low = 0
heigh = len(aList) - 1
while low <= heigh: # 这里为了防止，low=height然后不进入程序，return正确的情况，如：t=3,low=heigh=2
mid = (low + heigh) / 2
print ‘mid:‘,mid
if t > aList[mid]:
low = mid + 1
elif t < aList[mid]:
heigh = mid - 1
else:
print "索引,值:",mid,aList[mid]
return mid # 返回索引值
print ‘low:‘,low
print ‘heigh:‘,heigh
return -1 # 为了防止元素找不到的情况，就返回-1
print binarySearch(aList,2)
三、排序算法
3.1 冒泡排序
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = ‘WangQiaomei‘
import random
import time
‘‘‘
aList=[]
for i in range(20):
aList.append(random.randrange(100))
print aList
‘‘‘
aList=[]
for i in range(50000):
aList.append(random.randrange(100000))
def bubble_sort(aList):# 例如 aList的个数是10个
for i in range(len(aList)): # 循环索引 0-9
for j in range(len(aList)-i-1): # 第一次循环索引j为：8,这里为啥要-1，因为下面会有j+1
if aList[j]>aList[j+1]:
temp=aList[j+1]
aList[j+1]=aList[j]
aList[j] = temp
return aList
start_time=time.time()
print bubble_sort(aList)[0:20]
end_time=time.time()
print end_time-start_time
# 给5万个数排序，282秒
3.2 选择排序
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = ‘WangQiaomei‘
import random
import time
‘‘‘
aList=[]
for i in range(20):
aList.append(random.randrange(100))
print aList
‘‘‘
aList=[]
for i in range(50000):
aList.append(random.randrange(100000))
#print aList
def select_sort(aList):
for i in range(len(aList)):
for j in range(i,len(aList)):
if aList[i]>aList[j]:
temp = aList[i]
aList[i]= aList[j]
aList[j]= temp
return aList
start_time=time.time()
print select_sort(aList)[0:20]
end_time=time.time()
print end_time-start_time
‘‘‘
第一层循环是循环整个列表
第二层是从i开始循环，到列表结尾。
如果找到比aList[i]小的元素，就和aList[i]交换。
和冒泡算法的时间和空间复杂度基本是一样的。区别是：
1）冒泡算法是两两交换，循环交换的结果把最大的数依次放在最后面。
2）选择排序是把当前的数和aList[i],循环结果就是把最小的数依次放在前面。
# 给5万个数排序，225秒
‘‘‘
3.3 直接插入排序
插入排序(Insertion Sort)的基本思想是：将列表分为2部分，左边为排序好的部分，右边为未排序的部分，循环整个列表，每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = ‘WangQiaomei‘
import random
import time
‘‘‘
aList=[]
for i in range(20):
aList.append(random.randrange(100))
print aList
‘‘‘
‘‘‘
插入排序，是已经有一个已排序列表，索引是：0到i-1,靠向右移动一个位置，腾出一个空位来插入当前值。
详细：
由于插入排序是：通过从索引“0到i-1”已经排好序的列表中，由iCur（aList[i]）去从跟从i-1，一直旺座不停的比对，一直到<某个元素,
就插入到某个元素的前面。其实就是顺序查找插入，时间复杂度;O(n)。
注意：这里不可能改变列表的个数，当然更不能用insert语句了。
那怎么保持原列表不变，从已经排好序的列表里（0到i-1）,插入一个数呢？
就通过：
如果iCur的左边的紧靠的元素比它大,要把左边的元素一个一个的往右移一位,
直到iCur比aList[position-1]小,iCur插入到左边挪一个位置出来
也就是靠向右移动位置，给icur腾出一个空位，以便插入！
‘‘‘
aList=[]
for i in range(50000):
aList.append(random.randrange(100000))
def insert_sort(aList):
for i in range(1,len(aList)): # 默认列表第一个已经排好序了
iCur= aList[i]
position=i
while position>0 and iCur<aList[position-1]:
aList[position]=aList[position-1]
position-=1
aList[position]=iCur
return aList
start_time=time.time()
print insert_sort(aList)[0:20]
end_time=time.time()
print end_time-start_time
‘‘‘
# 给5万个数排序，149秒
‘‘‘
四、快速排序
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动
注：在待排序的文件中，若存在多个关键字相同的记录，经过排序后这些具有相同关键字的记录之间的相对次序保持不变，该排序方法是稳定的；若具有相同关键字的记录之间的相对次序发生改变，则称这种排序方法是不稳定的。
要注意的是，排序算法的稳定性是针对所有输入实例而言的。即在所有可能的输入实例中，只要有一个实例使得算法不满足稳定性要求，则该排序算法就是不稳定的。
4.1 快速排序--清爽代码
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = ‘WangQiaomei‘
def quick_sort(aList, left, right):
if left >= right:
return
low = left
high = right
k = aList[left]
while low < high:
while high > 0 and low != high and aList[low] <= aList[high]:
high -= 1
temp = aList[low]
aList[low] = aList[high]
aList[high] = temp
while low != high and aList[high] > aList[low]:
low += 1
temp = aList[high]
aList[high] = aList[low]
aList[low] = temp
quick_sort(aList, left, low - 1)
quick_sort(aList, low + 1, right)
aList = [83, 83, 94, 51, 9, 79, 40, 68, 12, 17]
print aList
quick_sort(aList, 0, len(aList) - 1)
print aList
‘‘‘
打印结果：
[83, 83, 94, 51, 9, 79, 40, 68, 12, 17]
[9, 12, 17, 40, 51, 68, 79, 83, 83, 94]
‘‘‘
4.2 快速排序-错误示范讲解
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = ‘WangQiaomei‘
import random
‘‘‘
aList=[6,2,5,11,3,8,9]
6,2,5,11,3,8,9 current_val=6 索引：low=0,high=6 初始值
此时算hight的：从后往前，跟6比大小，high的索引递减，这里递减了2次，注意：直到遇见比6小的，才交换位置。
3,2,5,11,6,8,9 current_val=6 索引：low=0,high=4
此时算low的：从前往后，跟6比大小，low的索引递增，这里递增了3次，注意：直到遇见比6大的，才交换位置。
3,2,5,6,11,8,9 current_val=6 索引：low=3,high=4
此时算hight的：从后往前，因为11比6大，high的索引-1=3,不交换位置。此时：low=high=6，
这是第一次排序，把比6小的发在6的左边，把比6大的放在6的右边。
3,2,5,6,11,8,9 current_val=6 索引：low=3,high=3
开始第二次排序，先排序6的左边：此时6的位置已经固定，不需要排它了！
注意：此时low和high的索引还是针对完整列表（第一次排序好的列表：
[3,2,5,6,11,8,9]）来说的。因为是给aList排序，不是给[3,2,5]排序！
3,2,5 current_val=3 索引：low=0,high=2 初始值
2,3,5 current_val=3 索引：low=0,high=1 从后向前，交换
2,3,5 current_val=3 索引：low=1,high=1 不交换
开始第三次排序，排6的右边：此时6的位置已经固定，不需要排它了！
注意：此时low和high的索引还是针对第二次排序好的列表：
[2,3,5,6,11,8,9]）来说的。
11,8,9 current_val=11 索引：low=4,high=6 初始值
9,8,11 current_val=11 索引：low=4,high=5 从后向前，交换
8,9,11 current_val=11 索引：low=5,high=5 从前向后，交换
第三次排序好的列表，就是最终结果，因为左边列表 和右边的列表，都分别得到了一个值。
最终结果：
[2,3,5,6,8,9,11]
‘‘‘
def quick_sort(aList, left,right): # left 和right是为了递归用的。
# if low==high and low>0:
if left>=right:
return
low=left # 这两句是为了递归用的
high= right
k = aList[left] # 定的固定值，以它为标杆排序
while low<high:
# print ‘aList[low]:‘,aList[low]
# print ‘aList[high]:‘,aList[high]
# print ‘low:‘,low
# print ‘high:‘,high
print aList
# while high>0 and low!=high and aList[low]<=aList[high]: # 此时 aList[low]是关键字，递归low的值。这是对的
‘‘‘
注意:这里high是递减的，可能high会减成负数，会报错，所以high>0
high是递减的，如果high减的跟low相等了，不应该再执行，结果再执行high-=1,则high<low，结果错误的交换了！
如下所示：
[9, 12, 51, 17, 40, 68, 79, 83, 94, 83]
low1: 5
high1: 5
low2: 5
high2: 4
[9, 12, 51, 17, 68, 40, 79, 83, 94, 83]
所以，这里应该写成：
while high>0 and low!=high and aList[low]<=aList[high]:
或者直接写成：
while low<high and aList[low]<=aList[high]:
‘‘‘
# 有时候有多个相同的元素，所以要写成<=
while high>0 and aList[low]<=aList[high]: # 此时 aList[low]是关键字，递归low的值。应该加上条件：and low!=high
# while high>0 and k<=aList[high]: # 这样写也是对的,关键字就是k。这时候k就是aList[low]
if low==high:
print ‘low1:‘,low
print ‘high1:‘,high
high-=1
print ‘low2:‘,low
print ‘high2:‘,high
temp=aList[low] # 其实是low和high之间互换位置。
aList[low]= aList[high]
aList[high]=temp
print aList
#print ‘sec_aList[low]:‘,aList[low]
#print ‘sec_aList[high]:‘,aList[high]
# 因为low和high是互相变动的，有的时候low是关键字，有的时候high是关键字，有的时候low=high=关键字
# 而每次while循环，都只针对一个固定值，小的放左边，大的放右边
‘‘‘
这里也一样，如果low+=1的话，low和high相等的时候（本来不应该执行了），low再加1，则又做了错误的交换了。
‘‘‘
# while low!=high and aList[high]>aList[low]: # 此时 aList[high]是关键字，递归low的值 是对的
while aList[high]>aList[low]: # 此时 aList[high]是关键字，递归low的值 ，应该加上条件：andand low!=high
# while k>aList[low]: # 这样写也是对的，关键字就是k。这时候k就是aList[high]
if low==high:
print ‘low3:‘,low
print ‘high3:‘,high
low+=1
temp=aList[high]
aList[high]= aList[low]
aList[low]=temp
#print ‘result:‘,aList
# if low==high and low>0:
# quick_sort(aList, 0,low-1)
#print ‘left:‘,left
#print ‘low-1:‘,low-1
# quick_sort(aList, 0,low-1)
quick_sort(aList, left,low-1)
# quick_sort(aList, low+1,len(aList)-1)
quick_sort(aList, low+1,right)
#print aList
‘‘‘
aList=[]
for i in range(20):
aList.append(random.randrange(100))
print aList
aList=[6,2,5,11,3,8,9]
aList=[]
for i in range(10):
aList.append(random.randrange(100))
‘‘‘
aList=[83, 83, 94, 51, 9, 79, 40, 68, 12, 17]
# aList=[83, 83, 94, 51, 9, 79, 40]
print aList
quick_sort(aList, 0,len(aList)-1)
print aList
4.3 快速排序--正确
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = ‘WangQiaomei‘
import random
‘‘‘
aList=[6,2,5,11,3,8,9]
6,2,5,11,3,8,9 current_val=6 索引：low=0,high=6 初始值
此时算hight的：从后往前，跟6比大小，high的索引递减，这里递减了2次，注意：直到遇见比6小的，才交换位置。
3,2,5,11,6,8,9 current_val=6 索引：low=0,high=4
此时算low的：从前往后，跟6比大小，low的索引递增，这里递增了3次，注意：直到遇见比6大的，才交换位置。
3,2,5,6,11,8,9 current_val=6 索引：low=3,high=4
此时算hight的：从后往前，因为11比6大，high的索引-1=3,不交换位置。此时：low=high=6，
这是第一次排序，把比6小的发在6的左边，把比6大的放在6的右边。
3,2,5,6,11,8,9 current_val=6 索引：low=3,high=3
开始第二次排序，先排序6的左边：此时6的位置已经固定，不需要排它了！
注意：此时low和high的索引还是针对完整列表（第一次排序好的列表：
[3,2,5,6,11,8,9]）来说的。因为是给aList排序，不是给[3,2,5]排序！
3,2,5 current_val=3 索引：low=0,high=2 初始值
2,3,5 current_val=3 索引：low=0,high=1 从后向前，交换
2,3,5 current_val=3 索引：low=1,high=1 不交换
开始第三次排序，排6的右边：此时6的位置已经固定，不需要排它了！
注意：此时low和high的索引还是针对第二次排序好的列表：
[2,3,5,6,11,8,9]）来说的。
11,8,9 current_val=11 索引：low=4,high=6 初始值
9,8,11 current_val=11 索引：low=4,high=5 从后向前，交换
8,9,11 current_val=11 索引：low=5,high=5 从前向后，交换
第三次排序好的列表，就是最终结果，因为左边列表 和右边的列表，都分别得到了一个值。
最终结果：
[2,3,5,6,8,9,11]
‘‘‘
def quick_sort(aList, left,right): # left 和right是为了递归用的。
# if low==high and low>0:
if left>=right:
return
low=left # 这两句是为了递归用的
high= right
k = aList[left] # 定的固定值，以它为标杆排序
while low<high:
# print ‘aList[low]:‘,aList[low]
# print ‘aList[high]:‘,aList[high]
# print ‘low:‘,low
# print ‘high:‘,high
print aList
# while high>0 low!=high and aList[low]<=aList[high]: # 此时 aList[low]是关键字，递归low的值。这是对的
‘‘‘
注意:这里high是递减的，可能high会减成负数，会报错，所以high>0
high是递减的，如果high减的跟low相等了，不应该再执行，结果再执行high-=1,则high<low，结果错误的交换了！
如下所示：
[9, 12, 51, 17, 40, 68, 79, 83, 94, 83]
low1: 5
high1: 5
low2: 5
high2: 4
[9, 12, 51, 17, 68, 40, 79, 83, 94, 83]
所以，这里应该写成：
while high>0 and low!=high and aList[low]<=aList[high]:
或者直接写成：
while low<high and aList[low]<=aList[high]:
‘‘‘
# 有时候有多个相同的元素，所以要写成<=
while high>0 and low!=high and aList[low]<=aList[high]:
# while high>0 and aList[low]<=aList[high]: # 此时 aList[low]是关键字，递归low的值。应该加上条件：and low!=high
# while high>0 and k<=aList[high]: # 这样写也是对的,关键字就是k。这时候k就是aList[low]
‘‘‘
if low==high:
print ‘low1:‘,low
print ‘high1:‘,high
‘‘‘
high-=1
print ‘low2:‘,low
print ‘high2:‘,high
temp=aList[low] # 其实是low和high之间互换位置。
aList[low]= aList[high]
aList[high]=temp
print aList
#print ‘sec_aList[low]:‘,aList[low]
#print ‘sec_aList[high]:‘,aList[high]
# 因为low和high是互相变动的，有的时候low是关键字，有的时候high是关键字，有的时候low=high=关键字
# 而每次while循环，都只针对一个固定值，小的放左边，大的放右边
‘‘‘
这里也一样，如果low+=1的话，low和high相等的时候（本来不应该执行了），low再加1，则又做了错误的交换了。
‘‘‘
while low!=high and aList[high]>aList[low]: # 此时 aList[high]是关键字，递归low的值 是对的
#while aList[high]>aList[low]: # 此时 aList[high]是关键字，递归low的值 ，应该加上条件：andand low!=high
# while k>aList[low]: # 这样写也是对的，关键字就是k。这时候k就是aList[high]
‘‘‘
if low==high:
print ‘low3:‘,low
print ‘high3:‘,high
‘‘‘
low+=1
temp=aList[high]
aList[high]= aList[low]
aList[low]=temp
#print ‘result:‘,aList
# if low==high and low>0:
# quick_sort(aList, 0,low-1)
#print ‘left:‘,left
#print ‘low-1:‘,low-1
# quick_sort(aList, 0,low-1)
quick_sort(aList, left,low-1)
# quick_sort(aList, low+1,len(aList)-1)
quick_sort(aList, low+1,right)
#print aList
‘‘‘
aList=[]
for i in range(20):
aList.append(random.randrange(100))
print aList
aList=[6,2,5,11,3,8,9]
aList=[]
for i in range(10):
aList.append(random.randrange(100))
‘‘‘
aList=[83, 83, 94, 51, 9, 79, 40, 68, 12, 17]
# aList=[83, 83, 94, 51, 9, 79, 40]
print aList
quick_sort(aList, 0,len(aList)-1)
print aList
以上是关于s11d27 算法的主要内容，如果未能解决你的问题，请参考以下文章
Java 虚拟机原理垃圾回收算法 ( 标记-清除算法 | 复制算法 | 标记-整理算法 )
Java 虚拟机原理垃圾回收算法 ( 标记-清除算法 | 复制算法 | 标记-整理算法 )