以空间换时间思想

    今天面试时，最后一个问题问到了空间换时间的东东，说实在，真没怎么鼓捣过这个，网上找了点资料，贴来看看，末尾附有原帖地址，需要的可以爬链接……

    以前看过一篇文章“优化C代码常用的几招”，作者提到的第一招就是“以空间换时间”，还举了一个例子，由于比较经典，引用一下：计算机程序中最大的矛盾是空间和时间的矛盾，那么，从这个角度出发逆向思维来考虑程序的效率问题，我们就有了解决问题的第1招--以空间换时间。比如说字符串的赋值：

    方法A：通常的办法 #define LEN 32 char string1 [LEN]; memset (string1,0,LEN); strcpy (string1,"This is a example!!"); 方法B：const char string2[LEN] ="This is a example!"; char * cp; cp = string2;

    使用的时候可以直接用指针来操作。

    从上面的例子可以看出，A和B的效率是不能比的。在同样的存储空间下，B直接使用指针就可以操作了，而A需要调用两个字符函数才能完成。B的缺点在于灵活性没有A好。在需要频繁更改一个字符串内容的时候，A具有更好的灵活性；如果采用方法B，则需要预存许多字符串，虽然占用了大量的内存，但是获得了程序执行的高效率。笔者在编程练习过程中也遇到了不少可以用空间换时间的算法，把它们收集起来，以便初学者学习查阅。

 

 

    桶式排序算法

    数组的排序算法很多，其中快速排序是在实践中最快的已知排序算法，它的平均运行时间是O(nlogn)，堆排序算法在最坏的情况下，其时间复杂度也能达到O(nlogn)。相对于快速排序来说，这是它最大的优点，但是它需要一个记录大小供交换用的辅助存储空间——其实这也是用空间换时间的表现。

    但是，当数组的元素是一些较小的整型数据（小于1000000）时，用“桶式排序算法”可以使时间复杂度降到O(N)，可以很快地对年龄，成绩等整型数据进行排序。此外还可以使用桶式排序的方法求素数表。

    “桶式排序算法”的代码也很简单，只要建立一个长度为max的字符数组就可以了，代码如下：

 

    /* 函数功能：使用筒式排序法对数组进行排序，适用于元素值为较小整数 输入变量：int a[]，数组aint len，数组a的长度输出变量：无 返回值： 无 */ void Sort(int a[], int len){ int max = GetMax(a, len); char *p = new char[sizeof(char) * max + 1]; for (int i=0; i<=max; ++i) p = 0; for (int i=0; i<len; ++i) ++p[a]; for (int i=0,j=0; i<=max; ++i) { while(p > 0) { a[j++] = i; --p; } } delete []p; } /* 函数功能：返回数组的最大值 输入变量：int a[]，数组aint len，数组a的长度输出变量：无返回值： 数组的最大值*/ int GetMax(int a[], int len) { int max = a[0]; for (int i=1; i<len; i++) { if (max < a) max = a; } return max; }

 

    求第n个子集的所有元素

 

    一个好汉三个帮，三个好汉九个帮，九个好汉二十七个帮，...停，今天不是让你算n个好汉几个帮（有兴趣的网友可以自己算），我们来看这个集合{ 1, 3, 9, 27, 81, ... }，这个集合是一个递增的无限集，每个元素都是3的幂。

    我们把这个集合的所有子集按照元素和从小到大的顺序排好： {}(空集), { 1 }, { 3 }, { 1, 3 }, { 9 }, { 1, 9 }, { 3, 9 }, { 1, 3, 9 }, ...

    现在给定一个正整数n，求第n个子集的所有元素，并按从大到小的顺序排列好

    例：

    n的值    结果
    1        { }
    4        { 3, 1 }
    6        { 9, 1 }
    500      { 6561, 2187, 729, 243, 81, 3, 1 }    
    细节要求：
    1. n的范围： n >= 1 ，unsigned int
    2. 接口：    void HeroNeedThree(INT64* subset, unsigned int n);
    其中INT64是指64位整数，可以用 typedef long long INT64; 也可以自定义
    subset就是存放结果的数组，其中subset[0]存放结果子集的元素个数，
    然后子集元素从大到小存入subset[1],subset[2],......

 

    算法分析：除去空集，观察前n个子集

    {1}，----------------------------------------2^0 个子集

    {3}，{1，3}，--------------------------------2^1 个子集

    {9}，{1，9}，{3，9}，{1，3，9} --------------2^2 个子集

    {27}，{1，27}，{3，27}，{1，3，27}，{9，27}，{1，9，27}，{3，9，27}，{1，3，9，27}----------------------------------------2^3 个子集

    从上表可以看出对于有k个元素的集合，对应的有2^k（k<=32）个子集，而且每一行子集序列的第一个子集元素的大小恰好是3^0，3^1，3^2，3^3，…3^（k-1）。

    我们把n转换成二进制数，当n=5时，它的二进制数为0000…0101（共32位），即2^0+2^2，对应的子集为{3^0，3^2}，即{1，9}；

    当n=13时，它的二进制数为0000…1101（共32位），即2^0+2^2+2^3，对应的子集为{3^0，3^2，3^3}，即{1，9，27}；

    由此可得，要求第n个子集（注意还要加上空集，实际上是第n+1个），则只需将其转换成32位的二进制，则它就是所求的子集的二进制序列。把二进制中值为1的位对应的元素作为3的指数，求出3的幂就是对应的元素。

    根据此算法我们很容易的编出程序：

 

    /*主函数*/#include <stdio.h>#include <time.h>#include <stdlib.h>#define MAX_SIZE ( 50 )typedef long long INT64;void HeroNeedThree(INT64* subset, unsigned int n);int main(int argc, char *argv[]){ INT64 subset[MAX_SIZE] = {0}; int i; for (int k=1; k<500; k++) { HeroNeedThree(subset, k); printf("%d: { ", k); for (i = 0; subset[i] > 0; ++i) { printf("%I64d, ", subset[i]); } printf("}/n"); for (int i=0; i<MAX_SIZE; i++) subset[i] = 0; } system("pause"); return 0;}/*功能函数*/INT64 Power(unsigned int x, unsigned int n)//求x的n次幂{ if (n == 0) return 1; INT64 s = Power(x, n/2); s *= s; if (n % 2 == 0) return s; else return s * x;}void HeroNeedThree(INT64* subset, unsigned int n){ int t = 0; unsigned int m, s; n--; while (n > 0) //求n的二进制数的每一位 { for (s=n,m=0; s>1; s>>=1) m++; subset[++t] = Power(3, m); n -= 1 << m; } subset[0] = t;}

   在上面的程序中，我们每次都要去求3的m次幂，虽然我们采用分治法求幂，速度较快，但是当n值教大时，还是需要很多时间的，因为long long类型是32位的，我们可以预先把3的0-31次幂全部求出来，存放在数组中，这样就不用每次都进行求幂运算了，可以节省不少时间。同样的，我们也可以把2的0-31次幂全部求出来，存放在数组中，这样就不必每次都去判断二进制数中各个1所在的位置，而直接用下标表示了。

改进后的代码如下：

    void HeroNeedThree(INT64* subset, unsigned int n){ // base3[k] = 3^k static INT64 base3[32] = {0x1LL,0x3LL,0x9LL,0x1bLL,0x51LL,0xf3LL,0x2d9LL,0x88bLL,0x19a1LL,0x4ce3LL,0xe6a9LL,0x2b3fbLL,0x81bf1LL,0x1853d3LL,0x48fb79LL,0xdaf26bLL,0x290d741LL,0x7b285c3LL,0x17179149LL,0x4546b3dbLL,0xcfd41b91LL,0x26f7c52b3LL,0x74e74f819LL,0x15eb5ee84bLL,0x41c21cb8e1LL,0xc546562aa3LL,0x24fd3027fe9LL,0x6ef79077fbbLL,0x14ce6b167f31LL,0x3e6b41437d93LL,0xbb41c3ca78b9LL,0x231c54b5f6a2bLL }; // base2[k] = 2^kstatic unsigned int base2[32] ={0x1LL,0x2LL,0x4LL,0x8LL,0x10LL,0x20LL,0x40LL,0x80LL,0x100LL,0x200LL,0x400LL,0x800LL,0x1000LL,0x2000LL,0x4000LL,0x8000LL,0x10000LL,0x20000LL,0x40000LL,0x80000LL,0x100000LL,0x200000LL,0x400000LL,0x800000LL,0x1000000LL,0x2000000LL,0x4000000LL,0x8000000LL,0x10000000LL,0x20000000LL,0x40000000LL,0x80000000LL }; INT64 num = 0; n--; for (int i=31; i>=0; --i) { if (n & base2[i]) // 计算n的第i位上是否是1 { subset[++num] = base3[i]; } } subset[0] = num;}

以空间换时间算法集锦：http://blog.pfan.cn/goal00001111/25028.html

此外，下面两帖子的探讨也有可观之处：

http://bbs.pfan.cn/post-295761.html

http://bbs.pfan.cn/post-293442-1.html