算法的复杂度
参考链接：https://blog.csdn.net/itachi85/article/details/54882603
算法的复杂度主要分为时间复杂度和空间复杂度，时间复杂度评估算法的运行时间，体现对处理器的使用程度。空间复杂度评估算法所需要的运行内存，体现对计算机内存的使用程度。
在设计算法时，一般需要根据运行环境来权衡时间复杂度和空间复杂度，折中选取一个平衡点。不过时间复杂度显然是更容易产生问题，所以算法研究的主要也就是时间复杂度，不特别说明的情况下，复杂度也就是指的是时间复杂度
时间复杂度
时间频度：
一个算法中的语句（比如在循环里面的，而循环不算）执行次数称为语句频度或时间频度。记为T(n)。一个算法的运行时间是不能计算出来的，必须通过上机计算，而且在不同的处理器上也有差别；同时我们也不必要精确知道算法的运行时间，只需要比较两个算法，看谁花费的时间更少就行了。而算法的运行时间和算法中语句的执行次数成正相关。时间频度记作T(n)
时间复杂度
前面介绍的时间频度T(n)中的n代表问题的规模，当n不断改变时，时间频度也会不断发生变化，但为了了解他变化的规律，我们引入了时间复杂度。
大O表示法
前面的通过大O来表示时间复杂度的方法，称为大O表示法
算法复杂度一般分为最好情况、最坏情况、平均情况三种。由于平均情况一般和最坏情况持平，而且评估最坏情况能做好充足的准备，所以我们设计算法的时候一般都是估算的最坏情况下的时间复杂度。
常见的时间复杂度
推导大O阶
参考链接：https://blog.csdn.net/firefly_2002/article/details/8008987
时间复杂度是总运算次数表达式中受n的变化影响最大的那一项
算出来T(n)，然后求T(n)的同数量级，若同数量级他们间能求极限，就是他了
一些例子
对于for循环，常用的是计算有几轮循环，每轮的内层语句执行有多少次
这个例子
def select_sort2(collection):
'''选择排序2，通过交换移动位置'''
#通过交换腾出位置，我竟然没想到，而且这样的好处在于假如一个元素的位置是正确的，在排序的过程中就不用动他
#所以说，选择排序只需要n-1次交换，他和插入排序的不同再于他总是从未排序的序列中选出来最值，等于说他在未排序中遍历，而插入排序是从未排序
#的队头取值，在已排序的部分中遍历
length=len(collection)
def min_customize(collection):
min_index=0
for i in range(len(collection)):
if collection[i]<collection[min_index]:
min_index=i
return min_index
for loop_index in range(length):
min_index=min_customize(collection[loop_index:])
#注意返回的index是部分数组中的
collection[min_index+loop_index],collection[loop_index]=collection[loop_index],collection[min_index+loop_index]
return collection
需要n次循环（在最后的表达式中体现的是 里面的语句执行的次数 有几项），每次循环中需要一次寻找，这个寻找通过for循环来控制比较的次数，遍历剩余未排序的元素，n次寻找中，每个寻找的比较次数为（n,n-1,n-2,....1),则T(n)=【n+(n-1)+(n-2)+.....+1】（一共n项）=n*(n+1)/2,则T(n)的同数量级是n^2,所以T(n)=O(n^2)
主要关注for循环里面的语句执行了几次，他和for循环执行的次数是相等的。
外层循环执行n次，所以T(n)表达式有n项，而for循环里面还有一个循环，循环里面就是常数操作了，所以每一项都执行这个for循环控制的次数
for（i=1;i<=n;++i）
{
for(j=1;j<=n;++j)
{
c[ i ][ j ]=0; //该步骤属于基本操作 执行次数：n^2
for(k=1;k<=n;++k)
c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //该步骤属于基本操作 执行次数：n^3
}
}
则有 T（n）= n^2+n^3，根据上面括号里的同数量级，我们可以确定 n^3为T（n）的同数量级
则有f（n）= n^3，然后根据T（n）/f（n）求极限可得到常数c
则该算法的 时间复杂度：T（n）=O（n^3)
常数阶
int sum = 0,n = 100; //执行一次 sum = (1+n)*n/2; //执行一次 System.out.println (sum); //执行一次
for(i=1;i<=n;i++) //循环了n*n次，当然是O(n^2)
for(j=1;j<=n;j++)
s++;
for(i=1;i<=n;i++)//循环了(n+n-1+n-2+...+1)≈(n^2)/2，因为时间复杂度是不考虑系数的，所以也是O(n^2)
for(j=i;j<=n;j++)
s++;
#对与for循环中有内循环中如下面这样的，就把不同i取值对应的各种循环加起来在找规律求和就好了
for(i=1;i<=n;i++)//循环了(1+2+3+...+n)≈(n^2)/2,当然也是O(n^2)
for(j=1;j<=i;j++)
s++;
i=1;k=0;
while(i<=n-1){ k+=10*i; i++; }//循环了n-1≈n次，所以是O(n)
for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
for(k=1;k<=j;k++)
x=x+1;
循环了(1^2+2^2+3^2+...+n^2)=n(n+1)(2n+1)/6(这个公式要记住哦)≈(n^3)/3，不考虑系数，自然是O(n^3)
另外，在时间复杂度中，log(2,n)(以2为底)与lg(n)(以10为底)是等价的，因为对数换底公式：
log(a,b)=log(c,b)/log(c,a)
所以，log(2,n)=log(2,10)*lg(n),忽略掉系数，二者当然是等价的
如果一个问题的规模是n，解这一问题的某一算法所需要的时间为T(n)，它是n的某一函数 T(n)称为这一算法的“时间复杂性”。
当输入量n逐渐加大时，时间复杂性的极限情形称为算法的“渐近时间复杂性”。
我们常用大O表示法表示时间复杂性，注意它是某一个算法的时间复杂性。大O表示只是说有上界，由定义如果f(n)=O(n)，那显然成立f(n)=O(n^2)，它给你一个上界，但并不是上确界，但人们在表示的时候一般都习惯表示前者。
此外，一个问题本身也有它的复杂性，如果某个算法的复杂性到达了这个问题复杂性的下界，那就称这样的算法是最佳算法。
“大O记法”：在这种描述中使用的基本参数是 n，即问题实例的规模，把复杂性或运行时间表达为n的函数。这里的“O”表示量级 (order)，比如说“二分检索是 O(logn)的”,也就是说它需要“通过logn量级的步骤去检索一个规模为n的数组”记法 O ( f(n) )表示当 n增大时，运行时间至多将以正比于 f(n)的速度增长。
这种渐进估计对算法的理论分析和大致比较是非常有价值的，但在实践中细节也可能造成差异。例如，一个低附加代价的O(n2)算法在n较小的情况下可能比一个高附加代价的 O(nlogn)算法运行得更快。当然，随着n足够大以后，具有较慢上升函数的算法必然工作得更快。
O(1)
Temp=i;i=j;j=temp;
以上三条单个语句的频度均为1，该程序段的执行时间是一个与问题规模n无关的常数。算法的时间复杂度为常数阶，记作T(n)=O(1)。如果算法的执行时间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。
O(n^2)
2.1. 交换i和j的内容
sum=0； （一次）
for(i=1;i<=n;i++) （n次 ）
for(j=1;j<=n;j++) （n^2次 ）
sum++； （n^2次 ）
解：T(n)=2n^2+n+1 =O(n^2)
for (i=1;i<n;i++)
{
y=y+1; ①
for (j=0;j<=(2*n);j++)
x++; ②
}
解： 语句1的频度是n-1
语句2的频度是(n-1)*(2n+1)=2n^2-n-1
f(n)=2n^2-n-1+(n-1)=2n^2-2
该程序的时间复杂度T(n)=O(n^2).
O(n)
2.3.
a=0;
b=1;
算法的稳定性：
对于不稳定的排序算法，只要举出一个实例，即可说明它的不稳定性；而对于稳定的排序算法，必须对算法进行分析从而得到稳定的特性。需要注意的是，排序算法是否为稳定的是由具体算法决定的，不稳定的算法在某种条件下可以变为稳定的算法，而稳定的算法在某种条件下也可以变为不稳定的算法。
例如，对于冒泡排序算法，原本是稳定的排序算法，如果将记录交换的条件改成r[j]>=r[j+1]，则两个相等的记录就会交换位置，从而变成不稳定的算法。
再如，快速排序原本是不稳定的排序方法，但若待排序记录中只有一组具有相同关键码的记录，而选择的轴值恰好是这组相同关键码中的一个，此时的快速排序就是稳定的。