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
01背包问题
def fastMaxVal(w, v, i, aW, m):
global numCalls
numCalls += 1
# print 'maxVal called with:',i,aW
try:
return m[(i, aW)] except KeyError:
if i == 0:
if w[i] <= aW:
m[(i, aW)] = v[i]
return v[i]
else:
m[(i, aW)] = 0
return 0
without_i = fastMaxVal(w, v, i - 1, aW, m)
if w[i] > aW:
m[(i, aW)] = without_i
return without_i
else:
with_i = v[i] + fastMaxVal(w, v, i - 1, aW - w[i], m)
res = max(with_i, without_i)
m[(i, aW)] = res
return res def maxVal0(w, v, i, aW):
m = {}
return fastMaxVal(w, v, i, aW, m)
weights = [5, 3, 2]
vals = [9, 7, 8]
numCalls = 0
res = maxVal0(weights, vals, len(vals) - 1, 5)
print 'max Val=', res, 'number of calls = ', numCalls
装饰器:
def auth(func):
def inner(*args,**kwargs):
# key = kwargs['token']
# del kwargs['token']
key = kwargs.pop('token')
is_login = login(key)
if not is_login:
return '非法用户'
temp = func(*args,**kwargs)
print 'after'
return temp
return inner
三层装饰器:
s11d27 算法的更多相关文章
- B树——算法导论(25)
B树 1. 简介 在之前我们学习了红黑树,今天再学习一种树--B树.它与红黑树有许多类似的地方,比如都是平衡搜索树,但它们在功能和结构上却有较大的差别. 从功能上看,B树是为磁盘或其他存储设备设计的, ...
- 分布式系列文章——Paxos算法原理与推导
Paxos算法在分布式领域具有非常重要的地位.但是Paxos算法有两个比较明显的缺点:1.难以理解 2.工程实现更难. 网上有很多讲解Paxos算法的文章,但是质量参差不齐.看了很多关于Paxos的资 ...
- 【Machine Learning】KNN算法虹膜图片识别
K-近邻算法虹膜图片识别实战 作者:白宁超 2017年1月3日18:26:33 摘要:随着机器学习和深度学习的热潮,各种图书层出不穷.然而多数是基础理论知识介绍,缺乏实现的深入理解.本系列文章是作者结 ...
- 红黑树——算法导论(15)
1. 什么是红黑树 (1) 简介 上一篇我们介绍了基本动态集合操作时间复杂度均为O(h)的二叉搜索树.但遗憾的是,只有当二叉搜索树高度较低时,这些集合操作才会较快:即当树的高度较高(甚至一种极 ...
- 散列表(hash table)——算法导论(13)
1. 引言 许多应用都需要动态集合结构,它至少需要支持Insert,search和delete字典操作.散列表(hash table)是实现字典操作的一种有效的数据结构. 2. 直接寻址表 在介绍散列 ...
- 虚拟dom与diff算法 分析
好文集合: 深入浅出React(四):虚拟DOM Diff算法解析 全面理解虚拟DOM,实现虚拟DOM
- 简单有效的kmp算法
以前看过kmp算法,当时接触后总感觉好深奥啊,抱着数据结构的数啃了一中午,最终才大致看懂,后来提起kmp也只剩下“奥,它是做模式匹配的”这点干货.最近有空,翻出来算法导论看看,原来就是这么简单(先不说 ...
- 神经网络、logistic回归等分类算法简单实现
最近在github上看到一个很有趣的项目,通过文本训练可以让计算机写出特定风格的文章,有人就专门写了一个小项目生成汪峰风格的歌词.看完后有一些自己的小想法,也想做一个玩儿一玩儿.用到的原理是深度学习里 ...
- 46张PPT讲述JVM体系结构、GC算法和调优
本PPT从JVM体系结构概述.GC算法.Hotspot内存管理.Hotspot垃圾回收器.调优和监控工具六大方面进行讲述.(内嵌iframe,建议使用电脑浏览) 好东西当然要分享,PPT已上传可供下载 ...
随机推荐
- JAVA 从头开始<三>
一.数据类型转换 取反:1变0,0变1 强转 Insteger.toBinaryString(-7); 下面这样写会出错,要用l来接收 为什么byte b 可以接收int类型(而不是10b),大数据类 ...
- DDoS防护之TCP防护
本文由 网易云 发布. TCP协议,相信对于每一个开发工程师都不陌生.由于该协议是一个面向连接,可靠的特性,广泛应用于现在互联网的应用中.如常见的Web.SSH.FTP等都是基于TCP协议.目前TC ...
- Android 导入 aar 库文件
1. 在需要导入 aar 的 module 目录下创建一个名叫 "aars" 的目录,并把 aar 文件复制到这里. 2. 在项目的 build.gradle 文件里添加 allp ...
- day52 进程与守护进程
http://www.cnblogs.com/Eva-J/articles/8253549.html 博客参考. 多进程聊天 守护进程. 多进程 1.Unix/Linux:fork()调用实现多进程. ...
- 深入学习c++--左值引用和右值引用
#include <iostream> #include <string> #include <vector> using namespace std; int m ...
- 1007. Minimum Domino Rotations For Equal Row
In a row of dominoes, A[i] and B[i] represent the top and bottom halves of the i-th domino. (A domi ...
- Nginx + uWSGI 部署Django 项目,并实现负载均衡
一.uWSGI服务器 uWSGI是一个Web服务器,它实现了WSGI协议.uwsgi.http等协议.Nginx中HttpUwsgiModule的作用是与uWSGI服务器进行交换. 要注意 WSGI ...
- 程序猿的日常——Java基础之抽象类与接口、枚举、泛型
再次回顾这些基础内容,发现自己理解的又多了一点.对于一些之前很模糊的概念,渐渐的清晰起来. 抽象类与接口 抽象类通常是描述一些对象的通用方法和属性,并且默认实现一些功能,它不能被实例化.接口仅仅是描述 ...
- Flask从入门到精通之Flask表单
Flask请求对象包含客户端发出的所有请求信息.其中,request.form 能获取POST 请求中提交的表单数据.尽管Flask 的请求对象提供的信息足够用于处理Web 表单,但有些任务很单调,而 ...
- ssh密钥认证排错
sshd配置文件没问题: 目录权限设置也没问题: 但是 ssh -vvv 提示: debug3: no such identity: /Users/user/.ssh/id_rsa,/Users/us ...