C++程序性能1

//C++程序性能1
//#include "ProgramPerformance.h"
//program performance
/*
程序性能（ program performance），是指运行一个程序所需要的内存大小和时间。
可以采用两种方法来确定一个程序的性能，
一个是分析的方法，
一个是实验的方法。
在进行性能分析（performance analysis）时，采用分析的方法，
而在进行性能测量（performancemeasurement）时，借助于实验的方法。
----
程序的空间复杂性（space complexity）是指运行完一个程序所需要的内存大小。
程序的时间复杂性（time  complexity）是指运行完该程序所需要的时间
----

任意程序P 所需要的空间S（P）可以表示为：
S (P) = c + Sp（实例特征）

*/

template<class T>
int SequentialSearch(T a[],const T& x,int n)  //顺序搜索
{
int i;
for(i=0;i<n && a[i]!=x;i++);
if(i==n) return -1;
return i;
}
/*
S顺序搜索(n)=0 :空间复杂性=0
Ssum(n)=0:  Sum程序所需要的空间与n 无关
Srsum(n)=6(n+1) :递归栈空间=递归次数(n+1)X每次需要6个字节
Sfactorial(n)=4*max{n,1}   //阶乘
Sperm(n)=10n               //排列
*/

template<class T>
int SequentialSearch_dg(T a[],const T& x,int n) //顺序搜索递归
{
if(n<1) return -1;
if(a[n-1]==x) return n-1;
return SequentialSearch_dg(a,x,n-1);
}
//SsequentialSearch_dg(n)=4n;

//对多项式进行求值的函数
template<class T>
T PolyEval(T coeff[],int n,const T& x)
{  //计算n次多项式的值，coeff[0:n]为多项式的系数
T y=1,value=coeff[0];
for(int i=1;i<=n;i++)
{
y*=x;
value+=y*coeff[i];
}
return value;
}
//利用Horner法则对多项式进行求值(与上述PolyEval函数少个乘法)
template<class T>
T Horner(T coeff[],int n,const T& x)
{   //计算n次多项式的值，coeff[0:n]为多项式的系数
T value=coeff
;
for(int i=1;i<=n;i++)
value=value*x+coeff[n-i];
return value;
}

//计算名次
template<class T>
void Rank(T a[],int n,int r[])
{  //计算a[0:n-1]中n个元素的排名
for(int i=0;i<n;i++)
r[i]=0;   //初始化
//逐对比较所有的元素
for(int i=0;i<n;i++)
for(int j=0;j<i;j++)
if(a[j]<=a[i]) r[i]++;
else r[j]++;
}

//利用附加数组重排数组元素
template<class T>
void Rearange(T a[],int n,int r[])
{//按序重排数据a中的元素,使用附加数组u
T *u=new T[n+1];
//在u中移动到正确的位置
for(int i=0;i<n;i++)
u[r[i]]=a[i];
//移回到a中
for(int i=0;i<n;i++)
a[i]=u[i];
delete []u;
}

//选择排序
template<class T>
void SelectionSort(T a[],int n)
{ //对数组a[0:n-1]中的n个元素进行排序
for(int size=n;size>1;size--)
{
int j=Max(a,size);
Swap(a[j],a[size-1]);
}
}

//冒泡排序
template<class T>
void Bubble(T a[],int n)  //一次冒泡
{ //把数组a[0:n-1]中最大的元素通过冒泡移到右边
for(int i=0;i<n-1;i++)
if(a[i]>a[i+1]) Swap(a[i],a[i+1]);
}

template<class T>
void BubbleSort(T a[],int n)
{  //对数组a[0:n-1]中的n个元素进行冒泡排序
for(int i=n;i>1;i--)
Bubble(a,i);
}

//向一个有序数组中插入元素
template<class T>
void Insert(T a[],int& n,const T& x)
{ //向有序数组a[0:n-1]中插入元素x
//假定a的大小超过n
int i;
for(i=n-1;i>=0 && x<a[i];i--)
a[i+1]=a[i];
a[i+1]=x;
n++; //添加了一个元素
}
template<class T>
void Insert_noSeq(T a[],int& n,const T& x)
{ //向有序数组a[0:n-1]中插入元素x
//假定a的大小超过n
int i;
for(i=n-1;i>=0 && x<a[i];i--)
a[i+1]=a[i];
a[i+1]=x;
}
//插入排序
template<class T>
void InsertionSort(T a[],int n)
{  //对a[0;n-1]进行排序
for(int i=1;i<n;i++)
{
T t=a[i];
Insert_noSeq(a,i,t);
}
}
//另外一种插入排序 最好比较次数是n-1,最坏比较次数为(n-1)n/2
template<class T>
void InsertionSort_other(T a[],int n)
{
for(int i=1;i<n;i++)
{
T t=a[i];
int j;
for(j=i-1;j>=0 && t<a[j];j--)
a[j+1]=a[j];
a[j+1]=t;
}
}

//原地重排数组元素
template<class T>
void Rearrange_ydSort(T a[],int n,int r[])
{  //原地重排数组元素
for(int i=0;i<n;i++)
//获取应该排在a[i]处的元素
while(r[i]!=i)
{
int t=r[i];
Swap(a[i],a[t]);
Swap(r[i],r[t]);
}
}

//及时终止的选择排序
template<class T>
void SelectionSort_intimestop(T a[],int n)
{ //及时终止的选择排序
bool sorted=false;
for(int size=n;sorted==false &&(size>1);size--)
{
int pos=0;
sorted=true;
//找最大元素
for(int i=1;i<size;i++)
if(a[pos]<=a[i]) pos=i;
else sorted=false; //未按序排列
Swap(a[pos],a[size-1]);
}
}

//及时终止的冒泡排序
template<class T>
bool Bubble_intimestop(T a[],int n)
{
bool swapped=false;
for(int i=0;i<n-1;i++)
if(a[i]>a[i+1])
{
Swap(a[i],a[i+1]);
swapped=true;//发生了交换
}
return swapped;
}
template<class T>
void BubbleSort_intimestop(T a[],int n)
{ //及时终止的冒泡排序
for(int i=n;i>1 && Bubble_intimestop(a,i)==true;i--);
}

//执行步数
//矩阵加法
template<class T>
void Add(T **a,T **b,T **c,int rows,int cols)
{  //矩阵a和b相加得到矩阵c
for(int i=0;i<rows;i++)
for(int j=0;j<cols;j++)
c[i][j]=a[i][j]+b[i][j];
}
//count为总执行步数
template<class T>
void Add_step(T **a,T **b,T **c,int rows,int cols)
{  //矩阵a和b相加得到矩阵c
int count=0;
for(int i=0;i<rows;i++)                           //rows+1
{   count++;  //对应于上一条for语句
for(int j=0;j<cols;j++)                       //rows(cols+1)
{   count++;  //对应于上一条for语句
c[i][j]=a[i][j]+b[i][j];                  //rows*cols
count++;  //对应于赋值语句
}
count++; //对应j的最后一次for循环
}
count++; //对应i的最后一次for循环
std::cout<<"总执行步数为："<<count<<std::endl;
std::cout<<"公式计算总执行步数为："<<2*rows*cols+2*rows+1<<std::endl;
} //执行步数为：2rows*cols+2rows+1

//矩阵转置
template<class T>
void Transpose(T **a,int rows)
{  //对矩阵a[0:rows-1][0:rows-1]进行转置
for(int i=0;i<rows;i++)
for(int j=i+1;j<rows;j++)
Swap(a[i][j],a[j][i]);
} //执行步数为：rows^2+rows+1  O(n^2)

//低效前缀求和函数
template<class T>
void Inef(T a[],T b[],int n)
{  //计算前缀和
for(int j=0;j<n;j++)
b[j]=Sum(a,j+1);
} //执行步数为：n^2+6n+1  O(n^2)

//两个n X n矩阵的乘法
template<class T>
void Mult(T **a,T **b,T **c,int n)
{   //两个n X n矩阵 a和b相乘得到c
int cc=0;
for(int i=0;i<n;i++)                      //n+1
{   cc++;
for(int j=0;j<n;j++)                  //n(n+1)
{   cc++;
T sum=0;  cc++;                   //n^2
for(int k=0;k<n;k++)              //n^2(n+1)
{   cc++;
sum+=a[i][k]*b[k][j]; cc++;   //n^3
}cc++;
c[i][j]=sum; cc++;                //n^2
}cc++;
}cc++;
std::cout<<"总执行步数为："<<cc<<std::endl;
std::cout<<"公式计算总执行步数为："<<2*n*n*n+4*n*n+2*n+1<<std::endl;
} //执行步数为2n^3+4n^2+2n+1     O(n^3)

//一个m X n矩阵与一个n X p矩阵之间乘法
template<class T>
void Mult(T **a,T **b,T **c,int m,int n,int p)
{ //m X n矩阵a与n X p矩阵b相乘得到c
for(int i=0;i<m;i++)
for(int j=0;j<p;j++)
{
T sum=0;
for(int k=0;k<n;k++)
sum+=a[i][k]*b[k][j];
c[i][j]=sum;
}
}

// Win32Console.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "baseCplusplus1.h";
#include "baseClassRelInfo2.h";
#include "TestProgram.h"
#include "ProgramPerformance.h"

void baseCplusplusOp();     //C++函数模板递归一二维数组动态分配存储空间实例1

void baseClassRelInfo2();   //C++类的相关基础2
void baseClassRelInfo2_1(); //C++类的相关基础2  //操作符重载

void ComputeRoots();        //计算根公式
void findMax();             //寻找最大值
void ProgramPerformance();   //程序性能

int _tmain(int argc, _TCHAR* argv[])
{
baseCplusplusOp();

baseClassRelInfo2();
std::cout<<"/操作符重载"<<std::endl;
baseClassRelInfo2_1();

std::cout<<"计算根公式"<<std::endl;
ComputeRoots();

std::cout<<"寻找最大值"<<std::endl;
findMax();

std::cout<<"程序性能"<<std::endl;
ProgramPerformance();

//暂停操作
char str;
std::cin>>str;
//程序结束
return 0;
}

//程序性能
void ProgramPerformance()
{
int n=9;
int a[9]={-1,2,1,9,20,6,11,5,0};
int r[9];
Rank(a,n,r);
for(int i=0;i<n;i++) std::cout<<a[i]<<" ";
std::cout<<std::endl;

for(int i=0;i<n;i++) std::cout<<r[i]<<" ";
std::cout<<std::endl;

std::cout<<"利用附加数组重排数组元素"<<std::endl;
Rearange(a,n,r);
for(int i=0;i<n;i++) std::cout<<a[i]<<" ";
std::cout<<std::endl;

std::cout<<"选择排序"<<std::endl;
int b[9]={-1,2,1,9,20,6,11,5,0};
SelectionSort(b,n);
for(int i=0;i<n;i++) std::cout<<b[i]<<" ";
std::cout<<std::endl;

std::cout<<"冒泡排序"<<std::endl;
int c[9]={-1,2,1,9,20,6,11,5,0};
//Bubble(c,n);
BubbleSort(c,n);
for(int i=0;i<n;i++) std::cout<<c[i]<<" ";
std::cout<<std::endl;

std::cout<<"向一个有序数组中插入元素"<<std::endl;
int d[10]={-1,2,1,9,20,6,11,5,0};
int n1=9;
int x=12;
BubbleSort(d,n1);
Insert(d,n1,x);
for(int i=0;i<n1;i++) std::cout<<d[i]<<" ";
std::cout<<std::endl;

int **aa;
int **bb;
int **cc;
Make2DArray(aa,4,4);
Make2DArray(bb,4,4);
Make2DArray(cc,4,4);
for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
{
aa[i][j]=4;
bb[i][j]=5;
}
std::cout<<"矩阵相加统计执行步数"<<std::endl;
Add_step(aa,bb,cc,4,4);
for(int i=0;i<4;i++)
{
for(int j=0;j<4;j++)
std::cout<<cc[i][j]<<" ";
std::cout<<std::endl;
}
std::cout<<"矩阵相乘统计执行步数"<<std::endl;
Mult(aa,bb,cc,4);
for(int i=0;i<4;i++)
{
for(int j=0;j<4;j++)
std::cout<<cc[i][j]<<" ";
std::cout<<std::endl;
}
Delete2DArray(aa,4);
Delete2DArray(bb,4);
Delete2DArray(cc,4);

}