数据结构（暑假篇7.16）

又是一年的暑假来临，在课程学习之中明显感觉自己的代码功力尚有欠缺，希望利用这段时间弥补自己的不足，通过博客记录自己的成长，那么，开始吧。

递归实现1-N求和

#include<iostream>
using namespace std;
void printN(int N)
{
 if(N)
 {
  printN(N-1);
  cout<<N<<endl;
 }
}
int main()
{
 int n;
 while(cin>>n)
 {
  printN(n);
 }
}

通过递归调用printN()函数实现求和，发现当N较大如100000时，会直接爆掉，因为它所需要的空间大于它能用的空间，就爆掉了。

循环实现1-N求和

#include<iostream>
using namespace std;
void printN(int N)
{
 int i;
 for(int i=0;i<=N;i++)
 cout<<i<<endl;
}
int main()
{
 int n;
 while(cin>>n)
 {
  printN(n);
 }
}

这段代码就简单多了，只是为了和前面的递归调用作比较，说明在N较大时，递归调用空间的程度远超循环实现。

给定多项式在给定点x处的值两种方法比较

#include<iostream>
#include<time.h>
#include<math.h>
clock_t start,stop;
#define MAXL 10
#define MAXK 1e7
double duration;
using namespace std;
double f1(int n,double a[],double x)
{
 int i;
 double p=a[0];
 for(int i=0;i<=n;i++)
 p+=a[i]*pow(x,i);
}
double f2(int n,double a[],double x)
{
 int i;
 double p=a[n];
 for(int i=n;i>0;i--)
 p=p*x+a[i-1];
}
int main()
{
 int i;
 double a[MAXL];
 for(int i=0;i<MAXL;i++)
 a[i]=(double)i;
 start=clock();
 for(int i=0;i<MAXK;i++)
 f1(MAXL-1,a,1.1);
 stop=clock();
 duration=(double)(stop-start)/CLK_TCK/MAXK;
 printf("ticks= %f\n",(double)(stop-start));
 printf("duration=%6.2e\n",duration);
 
 start=clock();
 for(int i=0;i<MAXK;i++)
 f2(MAXL-1,a,1.1);
 stop=clock();
 duration=(double)(stop-start)/CLK_TCK/MAXK;
 printf("ticks= %f\n",(double)(stop-start));
 printf("duration=%6.2e\n",duration);
 
 } 

方法一：比较常规，就是从第一项一直加到最后一项；
方法二：利用秦九韶的算法，先从最后一项开始，令P=最后一项*x+倒数第二项，依次循环来实现。
在这里使用了clock()函数来实现计时，利用(stop-start)/CLK_TCK得到执行两种方法所需的时间，因执行一次时间过短，无法比较两者的区别，因而通过循环执行，如执行1e7次，再除以1e7得到每次执行的时间，可以发现方法二比前者快了一个数量级左右。

最大子列和算法2

#include<iostream>
#include<string.h>
using namespace std;
int main()
{
 int n;
 while(cin>>n)
 {
 int l[n];
 memset(l,0,n);
 for(int i=0;i<n;i++)
 cin>>l[i];
 int sum=0,maxsum=0;
 for(int i=0;i<n;i++)
 {
  sum=0;
  for(int j=i;j<n;j++)
   {
   sum+=l[j];
   if(sum>maxsum)
   maxsum=sum;
      }
  }
  cout<<maxsum<<endl;
    }
}

该算法通过两次循环得出结果，复杂度为O（n*2）

最大子列和算法3分而治之

#include<iostream>
using namespace std;
int Max3(int a,int b,int c)
{
 /* 返回3个整数中的最大值 */
 return a>b?a>c?a:c:b>c?b:c;
}
int DivideAndConquer(int list[],int left,int right)
{
 /* 分治法求List[left]到List[right]的最大子列和 */
    int MaxLeftSum, MaxRightSum; /* 存放左右子问题的解 */
    int MaxLeftBorderSum, MaxRightBorderSum; /*存放跨分界线的结果*/
 
    int LeftBorderSum, RightBorderSum;
    int center, i;
    if(left==right)
    {/* 递归的终止条件，子列只有1个数字 */
     if(list[left]>0)return list[left];
     else return 0;
 }
 
  /* 下面是"分"的过程 */
 center=(left+right)/2;/* 找到中分点 */
 /* 递归求得两边子列的最大和 */
 MaxLeftSum=DivideAndConquer(list,left,center);
 MaxRightSum=DivideAndConquer(list,center+1,right);
 
 /* 下面求跨分界线的最大子列和 */
 MaxLeftBorderSum=0;LeftBorderSum=0;
 for(int i=center;i>=left;i--)
 {/* 从中线向左扫描 */
  LeftBorderSum+=list[i];
  if(LeftBorderSum>MaxLeftBorderSum)
  MaxLeftBorderSum=LeftBorderSum;
 }/* 左边扫描结束 */
 
 MaxRightBorderSum=0;RightBorderSum=0;
 for(int i=center+1;i<=right;i++)
 { /* 从中线向右扫描 */
  RightBorderSum+=list[i];
  if(RightBorderSum>MaxRightBorderSum)
  MaxRightBorderSum=RightBorderSum;
 }/* 右边扫描结束 */
 
 
    /* 下面返回"治"的结果 */
 return Max3(MaxLeftSum,MaxRightSum,MaxLeftBorderSum+MaxRightBorderSum);
}
int MaxSubseqSum3(int list[],int n)
{/* 保持与前2种算法相同的函数接口 */
 return DivideAndConquer(list,0,n-1);
}
int main()
{
 int n;
 while(cin>>n)
 {
  int list[n];
  for(int i=0;i<n;i++)
  {
   cin>>list[i];
  }
  cout<<MaxSubseqSum3(list,n)<<endl;
 }
}

通过分治算法来实现最大子列和，复杂度为O（n*logn）（…分治算法理解的还不是很透彻，之后还要多看几遍的）

最大子列和算法4在线处理

#include<iostream>
using namespace std;
int main()
{
 int n;
 while(cin>>n)
 {
  int l[n];
  for(int i=0;i<n;i++)
  cin>>l[i];
  int sum=0,maxsum=0;
  for(int i=0;i<n;i++)
  {
   sum+=l[i];
   if(sum>maxsum)
   maxsum=sum;
   else if(sum<0)
   sum=0;
  }
  cout<<maxsum<<endl;
 }
}

这种算法实在是太巧妙了，复杂度为O（n），只有一次循环，若sum>maxsum，则maxsum=sum完成更新，若sum<0，代表此前的数列全部舍弃，从下一个开始记起，真的是越想越觉得奇妙！（陈越老师讲的课真的很不错！老师人也很可爱！）
总的来说第一天学到了不少知识，和自己的预期计划大致相当，不过果然编程这种东西是真的很烧脑啊啊啊啊，饱和的时候学学python放松一下？ 哈哈哈哈哈 。