一、数据结构-算法的时间复杂度和空间复杂度
在编程题之前，首先我们先来聊聊时间复杂度：
算法复杂度分为时间复杂度和空间复杂度。其作用: 时间复杂度是指执行算法所需要的计算工作量;而空间复杂度是指执行这个算法所需要的内存空间。(算法的复杂性体现在运行该算法时的计算机所需资源的多少上，计算机资源最重要的是时间和空间(即寄存器)资源，因此复杂度分为时间和空间复杂度)。
简单理解：
（1）时间复杂度：执行这个算法需要消耗多少时间。
时间复杂度：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。这是一个关于代表算法输入值的字符串的长度的函数。时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数。
（2）空间复杂度：这个算法需要占用多少内存空间。
空间复杂度(Space Complexity) 是对一个算法在运行过程中临时占用存储空间大小的量度，记做 S(n)=O(f(n)) ，其中n为问题的规模。利用算法的空间复杂度，可以对算法的运行所需要的内存空间有个预先估计。
一个算法执行时除了需要存储本身所使用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些计算所需的辅助空间。算法执行时所需的存储空间包括以下两部分。
（1）固定部分。这部分空间的大小与输入/输出的数据的个数、数值无关。主要包括指令空间（即代码空间）、数据空间（常量、简单变量）等所占的空间。这部分属于静态空间。
（2）可变空间，这部分空间的主要包括动态分配的空间，以及递归栈所需的空间等。这部分的空间大小与算法有关。
1.1 算法的时间复杂度
（1）语句频度T(n)： 一个算法执行所花费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。而且一个算法花费的时间与算法中的基本操作语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度，记为T(n)。
（2）时间复杂度： 在刚才提到的语句频度中，n称为问题的规模，当n不断变化时，语句频度T(n)也会不断变化。但有时我们想知道它的变化呈现什么规律。为此，我们引入时间复杂度概念。 一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。
T(n) 不同，但时间复杂度可能相同。 如：T(n)=n² 5n 6 与 T(n)=3n² 3n 2 它们的T(n) 不同，但时间复杂度相同，都为O(n²)。
（3）常见的时间复杂度有：常数阶O(1)，对数阶O(log2n)，线性阶O(n)，线性对数阶O(nlog2n)，平方阶O(n2)，立方阶O(n3)， k次方阶O(nk)，指数阶O(2n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。
（4）平均时间复杂度和最坏时间复杂度：
平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下，该算法的运行时间。
最坏情况下的时间复杂度称最坏时间复杂度。一般讨论的时间复杂度均是最坏情况下的时间复杂度。 这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限，这就保证了算法的运行时间不会比最坏情况更长。
（5）如何求时间复杂度：
【1】如果算法的执行时间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。
public static void main(String[] args) {
int x = 91;
int y = 100;
while (y > 0) {
if (x > 100) {
x = x - 10;
y--;
} else {
x ;
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
该算法的时间复杂度为：O(1)
这个程序看起来有点吓人，总共循环运行了1100次，但是我们看到n没有?
没。这段程序的运行是和n无关的，
就算它再循环一万年，我们也不管他，只是一个常数阶的函数
【2】当有若干个循环语句时，算法的时间复杂度是由嵌套层数最多的循环语句中最内层语句的频度f(n)决定的。
int x = 1;
for (int i = 1; i <= n; i ) {
for (int j = 1; j <= i; j ) {
for (int k = 1; k <= j; k ) {
x ;
}
}
}
1
2
3
4
5
6
7
8
该算法的时间复杂度为：O(n3)
该程序段中频度最大的语句是第5行的语句，内循环的执行次数虽然与问题规模n没有直接关系，但是却与外层循环的变量取值有关，而最外层循环的次数直接与n有关，因此该程序段的时间复杂度为 O(n3)
1 int i = n - 1;
2 while (i >= 0 && (A[i] != k)) {
3 i--;
4 }
5 return i;
1
2
3
4
5
该算法的时间复杂度为：O(n)
此算法中第3行语句的频度不仅与问题规模n有关，还与输入实例A中的各元素取值和k的取值有关：如果A中没有与k相等的元素，那么第3行语句的频度为 f(n)=n ，该程序段的时间复杂度为 O(n)
（6）用时间复杂度来评价算法的性能
用两个算法A1和A2求解同一问题，时间复杂度分别是O(100n2)，O(5n3)
（1） 5n3/100n2=n/20 ，当输入量n＜20时，100n2 > 5n3 ，这时A2花费的时间较少。
（2）随着问题规模n的增大，两个算法的时间开销之比 5n3/100n2=n/20 也随着增大。即当问题规模较大时，算法A1比算法A2要高效的多。它们的渐近时间复杂度O(n2)和O(n3) 评价了这两个算法在时间方面的性能。在算法分析时，往往对算法的时间复杂度和渐近时间复杂度不予区分，而经常是将渐近时间复杂度 O(f(n)) 简称为时间复杂度，其中的f(n)一般是算法中频度最大的语句频度。
（7）小结
算法的时间复杂度和两个因素有关：算法中的最大嵌套循环层数；最内层循环结构中循环的次数。
一般来说，具有多项式时间复杂度的算法是可以接受的；具有指数（不是对数）时间复杂度的算法，只有当n足够小时才可以使用。一般效率较好的算法要控制在O(log2n) 或者 O(n)
通常：容易计算的方法是看看有几重for循环，只有一重则时间复杂度为O（n）,二重则为O（n^2），依此类推，如果有二分则为O(logn)，二分例如快速幂、二分查找，如果一个for循环套一个二分，那么时间复杂度则为O(nlogn)
1.2常见算法时间复杂度整理
各种常用排序算法
类别
排序方法
时间复杂度
空间复杂度
稳定性
复杂性
特点
最好
平均
最坏
辅助存储
简单
插入
排序
直接插入
O(N)
O(N2)
O(N2)
O(1)
稳定
简单
希尔排序
O(N)
O(N1.3)
O(N2)
O(1)
不稳定
复杂
选择
排序
直接选择
O(N)
O(N2)
O(N2)
O(1)
不稳定
堆排序
O(N*log2N)
O(N*log2N)
O(N*log2N)
O(1)
不稳定
复杂
交换
排序
冒泡排序
O(N)
O(N2)
O(N2)
O(1)
稳定
简单
1、冒泡排序是一种用时间换空间的排序方法，n小时好
2、最坏情况是把顺序的排列变成逆序，或者把逆序的数列变成顺序，最差时间复杂度O(N^2)只是表示其操作次数的数量级
3、最好的情况是数据本来就有序，复杂度为O(n)
快速排序
O(N*log2N)
O(N*log2N)
O(N2)
O(log2n)~O(n)
不稳定
复杂
1、n大时好，快速排序比较占用内存，内存随n的增大而增大，但却是效率高不稳定的排序算法。
2、划分之后一边是一个，一边是n-1个，
这种极端情况的时间复杂度就是O(N^2)
3、最好的情况是每次都能均匀的划分序列，O(N*log2N)
归并排序
O(N*log2N)
O(N*log2N)
O(N*log2N)
O(n)
稳定
复杂
1、n大时好，归并比较占用内存，内存随n的增大而增大，但却是效率高且稳定的排序算法。
基数排序
O(d(r n))
O(d(r n))
O(d(r n))
O(rd n)
稳定
复杂
注：r代表关键字基数，d代表长度，n代表关键字个数
注：
1、归并排序每次递归都要用到一个辅助表，长度与待排序的表长度相同，虽然递归次数是O(log2n)，但每次递归都会释放掉所占的辅助空间，
2、快速排序空间复杂度只是在通常情况下才为O(log2n)，如果是最坏情况的话，很显然就要O(n)的空间了。当然，可以通过随机化选择pivot来将空间复杂度降低到O(log2n)。
1.3 算法的空间复杂度计算
举例分析算法的空间复杂度：
public void reserse(int[] a, int[] b) {
int n = a.length;
for (int i = 0; i < n; i ) {
b[i] = a[n - 1 - i];
}
}
参考前面的空间复杂度定义，上方的代码中，当程序调用 reserse() 方法时，要分配的内存空间包括：引用a、引用b、局部变量n、局部变量i
因此 f(n)=4 ，4为常量。所以该算法的空间复杂度 S(n)=O(1)
二、数组方面
注意*****以下程序在python3上进行执行
1
1. 数组中重复的数字
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组【2,3,1,0,2,5,3】，那么对应的输出是第一个重复的数字2。
相似题型解答：统计一个数字在排序数组中出现的次数。
#官方答案
# -*- coding:utf-8 -*-
import collections
class Solution:
# 这里要特别注意~找到任意重复的一个值并赋值到duplication
# 函数返回True/False
def duplicate(self, numbers, duplication):
# write code here
flag=False
c=collections.Counter(numbers)
for k,v in c.items():
if v>1:
duplication=k
flag=True
break
return flag，duplication
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
执行形式
numbers=[2,3,1,0,2,5,3]
duplication=-1
Solution().duplicate(numbers,duplication)
1
2
3
在python中也可以对numbera进行处理
b=[]
for x in list(set(numbers)):
b.append(numbers.count(x))
print(max(b))
1
2
3
4
2. 连续子数组的最大和
Kadane算法又被称为扫描法，为动态规划（dynamic programming）的一个典型应用。我们用DP来解决最大子数组和问题：对于数组a，用ci标记子数组a[0..i]的最大和，那么则有
ci=max{ai,ci−1 ai}ci=max{ai,ci−1 ai}
# -*- coding:utf-8 -*-
#法一:动态规划 O(n),并输出了最大和元素所在的索引
class Solution:
def FindGreatestsumOfSubArray(self, array):
if not array:
return 0
start=[]
res,cur=array[0],array[0]
for i in range(1,len(array)):
cur =array[i]
#每次对比计算和和原来数值的大小
res=max(res,cur)
#判断新的累加和是否小于0，小于则赋予0
if cur<0:
start=[]
cur=0
else:
#记录构成最大元素和的索引
start.append(i 1)
return res,start
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
测试
array=[1,2,-4,2,6,8]
Solution().FindGreatestSumOfSubArray(array)
1
2
法二：穷举法
i, j的for循环表示x[i..j]，k的for循环用来计算x[i..j]之和。
maxsofar = 0
for i = [0, n)
for j = [i, n)
sum = 0
for k = [i, j]
sum = x[k]
/* sum is sum of x[i..j] */
maxsofar = max(maxsofar, sum)
1
2
3
4
5
6
7
8
有三层循环，穷举法的时间复杂度为O(n3)O(n3)
冒泡排序
主要是拿一个数与列表中所有的数进行比对，若比此数大(或者小)，就交换位置
执行一次for循环，遍历第一个元素,放到最后的位置
l=[5,3,6,2,1,4,8,7,9]
for j in range(len(l)-1):
if l[j] > l[j 1]:
l[j],l[j 1] = l[j 1],l[j]
print(l)
1
2
3
4
5
执行2次循环，在第一次的基础之上，每次执行一个元素与其他元素进行比对，之后插入相应的末尾
l=[5,3,6,2,1,4,8,7,9]
for i in range(len(l)-1):
for j in range(len(l)-1-i):
if l[j] > l[j 1]:
l[j],l[j 1] = l[j 1],l[j]
print(l)
1
2
3
4
5
6
7
8
插入排序
有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序
基本思想为：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。
插入排序就是用一个数与一个已排好序的序列进行比对,从右向左进行。
例：5与3进行比较，5>3，将5与3不进行交换。l=[3,5]，
此时再进行排序。4 < 5 l=[3,4,5] 3<4不进行交换，l=[3,4,5]
l=[1,5,4,7,9,3,2,6,8]
#索引为0，注意从1开始
for i in range(1,len(l)):
#步长为-1
for j in range(i,0,-1):
if l[j] < l[j-1]:
l[j],l[j-1] = l[j-1],l[j]
else:
break
1
2
3
4
5
6
7
8
9
二分法查找
二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。
此方法适用于不经常变动而查找频繁的有序列表。
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
实例：
#encoding:utf-8
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
find_num = int(input('请输入一个数字：'))
start = 0
end = len(l) - 1
while True:
middle = (start end) // 2
if find_num == l[middle]:
print('找到了！索引是：', middle)
break
elif find_num > l[middle]:
start = middle 1
elif find_num < l[middle]:
end = middle - 1
if start > end:
print('没找到!', find_num)
break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
快速排序（quickSort）
时间复杂度：O(nlgn)
快速排序（Quicksort）是对冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
一趟快速排序的算法是：
1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
4）从i开始向后搜索，即由前开始向后搜索(i )，找到第一个大于key的A[i]，将A[i]和A[j]互换；
5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i 1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i 或j-完成的时候，此时令循环结束）。
第一种，容易理解，参考严蔚敏书中的伪代码实现
#coding:utf-8
def partion(nums,left,right):
key = nums[left]
while left < right:
# right下标位置开始，向左边遍历，查找不大于基准数的元素
while left < right and nums[right] >= key:
right -= 1
if left < right: # 找到小于准基数key的元素,然后交换nums[left],nums[right]
nums[left],nums[right] = nums[right],nums[left]
else: # left〉=right 跳出循环
break
# left下标位置开始，向右边遍历，查找不小于基准数的元素
while left < right and nums[left] < key:
left = 1
if left < right: # 找到比基准数大的元素，然后交换nums[left],nums[right]
nums[right],nums[left] = nums[left],nums[right]
else: # left〉=right 跳出循环
break
return left #此时left==right 所以返回right也是可以的
#realize from book "data struct" of author 严蔚敏
def quick_sort_standord(nums,left,right):
if left < right:
key_index = partion(nums,left,right)
quick_sort_standord(nums,left,key_index)
quick_sort_standord(nums,key_index 1,right)
if __name__ == '__main__':
nums = [5, 6, 4, 2, 3,1]
print nums
quick_sort_standord(nums,0,len(nums)-1)
print nums
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
第二种 特别常见的
# -*- coding: utf-8 -*-
def sub_sort(array,low,high):
key = array[low]
while low < high:
while low < high and array[high] >= key:
high -= 1
while low < high and array[high] < key:
array[low] = array[high]
low = 1
array[high] = array[low]
array[low] = key
return low
def quick_sort(array,low,high):
if low < high:
key_index = sub_sort(array,low,high)
quick_sort(array,low,key_index)
quick_sort(array,key_index 1,high)
if __name__ == '__main__':
array = [5, 6, 4, 2, 3,1]
print '原：',array
quick_sort(array,0,len(array)-1)
print '现：',array
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
第三种方式：
1、 算法描述：
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。
python代码
#!/usr/bin/python
# -*- coding: utf-8 -*-
def sub_sort(array,low,high):
key = array[low]
while low < high:
while low < high and array[high] >= key:
high -= 1
while low < high and array[high] < key:
array[low] = array[high]
low = 1
array[high] = array[low]
array[low] = key
return low
def quick_sort(array,low,high):
if low < high:
key_index = sub_sort(array,low,high)
quick_sort(array,low,key_index)
quick_sort(array,key_index 1,high)
if __name__ == '__main__':
array = [8,10,9,6,4,16,5,13,26,18,2,45,34,23,1,7,3]
print array
quick_sort(array,0,len(array)-1)
print array
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
贪心算法
三道贪心算法例题
1.找零钱问题：假设只有 1 分、 2 分、五分、 1 角、二角、 五角、 1元的硬币。在超市结账 时，如果 需要找零钱， 收银员希望将最少的硬币数找给顾客。那么，给定 需要找的零钱数目，如何求得最少的硬币数呢？
# -*- coding:utf-8 -*-
def main():
d = [0.01,0.02,0.05,0.1,0.2,0.5,1.0] # 存储每种硬币面值
d_num = [] # 存储每种硬币的数量
s = 0
# 拥有的零钱总和
temp = input('请输入每种零钱的数量：')
d_num0 = temp.split(" ")
for i in range(0, len(d_num0)):
d_num.append(int(d_num0[i]))
s = d[i] * d_num[i] # 计算出收银员拥有多少钱
sum = float(input("请输入需要找的零钱:"))
if sum > s:
# 当输入的总金额比收银员的总金额多时，无法进行找零
print("数据有错")
return 0
s = s - sum
# 要想用的钱币数量最少，那么需要利用所有面值大的钱币，因此从数组的面值大的元素开始遍历
i = 6
while i >= 0:
if sum >= d[i]:
n = int(sum / d[i])
if n >= d_num[i]:
n = d_num[i] # 更新n
sum -= n * d[i] # 贪心的关键步骤，令sum动态的改变，
print("用了%d个%f元硬币"%(n, d[i]))
i -= 1
if __name__ == "__main__":
main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
2.求最大子数组之和问题：给定一个整数数组（数组元素有负有正），求其连续子数组之和的最大值。
# -*- coding:utf-8 -*-
def main():
s = [12,-4,32,-36,12,6,-6]
print("定义的数组为：",s)
s_max, s_sum = 0, 0
for i in range(len(s)):
s_sum = s[i]
if s_sum >= s_max:
s_max = s_sum # 不断更新迭代s_max的值，尽可能的令其最大
elif s_sum < 0:
s_sum = 0
print("最大子数组和为：",s_max)
if __name__ == "__main__":
main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.一辆汽车加满油后可行驶n公里。旅途中有若干个加油站。设计一个有效算法，指出应在哪些加油站停靠加油，使沿途加油次数最少。 对于给定的n(n <= 5000)和k(k <= 1000)个加油站位置，编程计算最少加油次数。
# 设汽车加满油后可行驶n公里，且旅途中有k个加油站
def greedy():
n = 100
k = 5
d = [50,80,39,60,40,32]
# 表示加油站之间的距离
num = 0
# 表示加油次数
for i in range(k):
if d[i] > n:
print('no solution')
# 如果距离中得到任何一个数值大于n 则无法计算
return
i, s = 0, 0
# 利用s进行迭代
while i <= k:
s = d[i]
if s >= n:
# 当局部和大于n时则局部和更新为当前距离
s = d[i]
# 贪心意在令每一次加满油之后跑尽可能多的距离
num = 1
i = 1
print(num)
if __name__ == '__main__':
greedy()
---------------------
作者：IT界的小小小学生
来源：CSDN
原文：https://blog.csdn.net/hhtnan/article/details/80279965
版权声明：本文为博主原创文章，转载请附上博文链接！
