算法：
计算=信息处理 借助某种工具，遵照一定规则，以明确而机械的形式进行

计算模型=计算机=信息处理工具所谓算法，旨在解决特定问题的指令序列     输入：待处理的信息（问题）输出：经处理的信息（答案）正确性：的确可以解决指定的问题确定性：任以算法都可以描述为一个由基本操作组成的序列可行性：每一基本操作都可实现，且在常熟时间内完成有穷性：对于任何输入，经过有穷次基本操作，都可以得到输出  .....Hailstone(n)={ {1}                      n<=1  {n} 并 Hailstone(n/2)    n 偶{n} 并 Hailstone(3n+1)   n 奇}int hailstone(int n)//计算序列hailstone(n)的长度
{int length=1;//从1开始，以下按定义逐步递推，并累计步数，直至n=1while(1<n){(n%2)? n=3*n+1:n/=2;length++;return length;//返回hailstone}好算法：正确：符合语法，能够编译，链接能够正确处理简单的输入能够正确处理大规模的输入能够正确处理一般性的输入能够正确处理退化的输入能够正确处理任意合法的输入健壮：能辨别不合法的输入并做适当处理，而不致非正常退出可读：结构化+准确命名+注释+...效率：速度更可能快；存储空间尽可能少data Structure +Algorithm（算法）  简称 DSA    RAM：Random Access Machine 算法分析：正确性成本：运行时间+所需存储空间上溢：当一个超长的数据进入到缓冲区时，超出的部分被写入到上级缓冲区，上级缓冲区，

上级缓冲区存放的可能是数据，上一条指令的指针，或者是其他程序的输出内容，这些内容被覆盖或
者破坏掉。

      下溢：当一个超长的数据进入到缓冲区时，超出的部分被写入下级缓冲区，下级缓冲区存放

的是下一条指令的指针，或者是其他程序的输出内容。

起泡排序：void bubblesort(int A[],int n){for(bool sorted=false;sorted=!sorted;n--)//逐趟扫描交换，直至完全有序for(int i=1;i<n;i++)//自左向右，逐对检查A[0,n)内各相邻元素if(a[i-1]>a[i]){swap(A[i-1],A[i]);//令其互换sorted=false;//清除（全局）有序标志  }}不变性：经过K轮扫描交换后，最大的K个元素必然就位单调性：经K轮扫描交换后，问题规模缩减至n-k正确性：经至多n趟扫描后，算法必然终止，且能给出正确解答计算n个整数之和：int sunI(int A[],int n)    E2{int sum=0;for(int i=0;i<n;i++)sum+=A[i];return sum;}减而治之：为求解一个大规模的问题，可以将其划分为两个子问题，其一是平凡，另一规模缩

减（//单调性），分别求解子问题，由子问题的解，得到原问题的解。

 数组求和：线性递归sum(int A[],int n){return (n<1) ?0:sum(A,n-1)+A[n-1];}数组倒置：任给数组A[0,n),将其前后颠倒统一接口：void reverse(int *A,int lo,int hi);递归版：if(lo<hi)//问题规模的奇偶性不变，需要两个递归基     E5{ swap(A[lo],A[hi]); reverse(A,lo+1,hi-1);}迭代原始版：next:if(lo<hi){swap(A[lo],A[hi]);lo++;hi--;goto next;}迭代精简版：while(lo<hi) swap(A[lo++],A[hi--]);分而治之：为求解一个更大规模的问题，可以将其划分为若干（通常2个）子问题，规模大体相当

分别求解子问题，由子问题的解，得到原问题的解。

  数组求和：二分递归sum(int A[],int lo,int hi)//区间范围A[lo,hi]{if(lo==hi)   return A[lo];int mi=(lo+hi)>>1;//右移，也相当于除2return sum(A,lo,mi)+sum(A,mi+1,hi)}//入口形式为sum(A,0,n-1)迭代1：从数组区间A[lo,hi)中找出最大两个整数A[x1]和A[x2]元素比较次数，要求尽可能地少void max2(int A[],int lo,int hi,int &x1,int &x2)//1<n=hi+lo  {for(x1=lo,int i=lo+1;i<hi;i++)//扫描A[lo,hi)，找出A[x1]if(A[x1]<A[i])   x1=i;//hi-lo-1=n-1for(x2=lo,int i=lo+1;i<x1;i++)  //扫描A[lo,x1)if(A[x2]<A[i])   x2=i;// x1-lo-1for(int i=x1+1;i<hi;i++)//再扫描A(x1,hi),找出A[x2]if(A[x2]<A[i])   x2=i;//hi-x1-1}   迭代2:问题同上void max2(int A[],int lo,int hi,int &x1,int &x2)//1<n=hi+lo {if(A[x1=lo]<A[x2=lo+1])   swap(x1,x2);for(int i=lo+2;i<hi;i++)if(A[x2]<A[i])if(A[x1]<A[x2=i])swap(x1,x2);}递归+分治：问题同上void max2(int A[],int lo,int hi,int &x1,int &x2){if(lo+2==hi)  { /*.....*/; return; }//T(2)=1if(lo+3==hi)d

00000000 { /...../; return; }//T(3)<=3
int mi=(lo+hi)/2; //divide
int x1L,x2L; max2(A,lo,mi,x1L,x2L);
int x1R,x2R; max2(A,mi,hi,x1R,x2R);
if(A[x1L]>A[x1R])
{
x1=x1L;x2=(A[x2L]>A[x1R])? x2L:x1R;
}else
{
x1=x1R; x2=(A[x1L]>A[x2R])? x1L : x2R;
}//1+1=2
}
动态规划： XC3
fib():迭代
动态规划：颠倒计算方向,由自顶而下递归，为自底而上迭代
f=0; g=1;//fib(0),fib(1)
while(0<n--)
{
g=g+f;
f=g-f;
}
return g;