1 + 2 - 3 + 4........n 提高运行速度

凌云光图像算法岗位笔试的一个题：

【编程实现sum = 1 + 2 - 3 + 4........n 并尽量提高运行速度。】

实现很容易，当时也用上了inline来提速。后来过了很长时间，想到用递归会不会更快呢？于是好好研究了一下：

/*******************一、普通循环法*****************************/
int sum(const int &n)
{
	if (n < 1)
		throw runtime_error("n须为大于或等于1的整数");
	int s = 1;
	for (int i = 2; i <= n; ++i)
	{
		s += pow(-1, i)*i;
	}
	return s;
}


/*******************二、递归法*****************************/
//!!! n大了如7777，会发生stack overflow，将预留的栈内存改大些就好了。
//但递归算法不适合次数太多的深层运算，即使栈不溢出，速度优势也不明显甚至慢了。
int sum_recur(const int &n)
{
	if (n < 1)
		throw runtime_error("n须为大于或等于1的整数");
	if (n > 1)
		return pow(-1, n)*n + sum_recur(n - 1);
	return 1;
}

/*******************三、一的内联版本*****************************/
inline int sum_inline(const int &n)
{
	if (n < 1)
		throw runtime_error("n须为大于或等于1的整数");
	int s = 1;
	for (int i = 2; i <= n; ++i)
	{
		s += pow(-1, i)*i;
	}
	return s;
}


/*******************四、数学法*****************************/
//直接推导出和的表达式，当然是最快的啦，但仅限于很容易的
int sum_math(const int &n)
{
	if (n < 1)
		throw runtime_error("n须为大于或等于1的整数");
	if (n % 2)
		return (3 - n) / 2.0;
	else 
		return (n + 4) / 2.0;
}

主函数 四种方式计时比较：

#include "stdafx.h"
#include <iostream>
#include <cmath>
#include <windows.h> 
using namespace std;

int sum(const int &n);
int sum_recur(const int &n);//!!!
inline int sum_inline(const int &n);
int sum_math(const int &n);
int _tmain(int argc, _TCHAR* argv[])
{
	int n;
	cin >> n;
	LARGE_INTEGER freq;
	LARGE_INTEGER start_t, stop_t;
	double exe_time;
	QueryPerformanceFrequency(&freq);
	try{
		//一及计时
		QueryPerformanceCounter(&start_t);
		cout << sum(n) << " ";
		QueryPerformanceCounter(&stop_t);
		exe_time = 1e3*(stop_t.QuadPart - start_t.QuadPart) / freq.QuadPart;
		cout << exe_time << endl;

		//二及计时
		QueryPerformanceCounter(&start_t);
		cout << sum_recur(n) << " ";
		QueryPerformanceCounter(&stop_t);
		exe_time = 1e3*(stop_t.QuadPart - start_t.QuadPart) / freq.QuadPart;
		cout << exe_time << endl;

		//三及计时
		QueryPerformanceCounter(&start_t);
		cout << sum_inline(n) << " ";
		QueryPerformanceCounter(&stop_t);
		exe_time = 1e3*(stop_t.QuadPart - start_t.QuadPart) / freq.QuadPart;
		cout << exe_time << endl;

		//四及计时
		QueryPerformanceCounter(&start_t);
		cout << sum_math(n) << " ";
		QueryPerformanceCounter(&stop_t);
		exe_time = 1e3*(stop_t.QuadPart - start_t.QuadPart) / freq.QuadPart;
		cout << exe_time << endl;
	}
	catch (runtime_error err)
	{
		cout << err.what() << endl;
	}
	system("pause");
	return 0;
}

【实验结果】

二已溢出，注释了。

【结论】

1、递归算法递归次数不能太多，否则栈会溢出，

即使预留更大的栈内存使不溢出，但递归的速度优势也不明显甚至慢了。

2、数学推到过程要费些功夫，且基本不实用。

就本题综合来看，还是普通循环的内联版本最合适。

参考：

点击打开链接 精确计时讲解