代码共享

javascript版本的二分查找算法

Panic — Fri, 13 Apr 2007 03:43:00 GMT

/* javascript版本的二分查找算法，支持自定义的less_than函数 */
/* 作者： Panic  2007年4月13日 */
/* 网站： blog.vckbase.com/panic */
/* 参数说明：*/
/* arr:数组，下标必须从0开始，并且是连续非负整数，包含要查找的内容，必须是排序好的 */
/* item:要查找的目标 */
/* less_than:比较函数，定义为：function less_than(left,right) */
/* 这个函数必须和数组用于排序的less_than函数具有同样的行为 */
/* 当left < right时，返回-1 */
/* 当left == right 时，返回 0 */
/* 当left > right时，返回 1*/
/* 返回值说明：*/
/* 当目标存在时，函数返回目标所在位置的数组下标 */
/* 当目标不存在时，函数返回数组中第一个比目标大的元素下标 */
/* 当查找的目标比数组中任何元素都大，或者数组为空的时候，返回数组的长度 */
    function binary_search(arr,item,less_than)
    {
        var start = 0;
        var end    = arr.length
        var current = (arr.length + (arr.length%2) )/2; /* 晕死了，直接写var current = arr.length/2; 就会出错 */
        while( end != current )
        {
            if( less_than(item,arr[current]) == 1 )
                start =    current+1;
            else
                end = current;
            var tmp    = (start + end);
            current    = (tmp - (tmp%2))/2; /* 直接写 current = (start + end)/2; 也会出错，晕ing */
        }
        return current;
    }

代码描述已经很清楚了，里面两个注释是让我觉得莫名其妙的地方，期待指教。。。
如果按照注释中的写法，IE解析出错。。。

经周星星同学指点，发现问题是IE6下，javascript不支持浮点数到整数的自动截断引起的，代码改为：
var current = Math.floor(arr.length/2);
和
current = Math.floor((start + end)/2);
即可。

发布一个speedsim源代码

Panic — Wed, 29 Nov 2006 02:13:00 GMT

最近在玩一个网页游戏叫做ogame，详情请到 ogame.org 了解。
ogame简体中文版的网址是
ogame.com.cn

speedsim是ogame的战斗模拟器。
speedsim是一个开源项目，原作者好像是德国人，但是现有的release版对ogame.com.cn的支持不是很好，于是我下载了源代码做了一些修改。
代码和可执行文件下载请
点击这里

二叉堆的模板代码－－续“关于一道算法题《编写算法，从10亿个浮点数当中，选出其中最大的10000个》”

Panic — Mon, 19 Jun 2006 08:07:00 GMT

作者：Panic 2006年 6月 19日

原话题随笔：关于一道算法题《编写算法，从10亿个浮点数当中，选出其中最大的10000个》

这里是我写的使用二叉堆作为有序容器的代码。

代码的前半部分是二叉堆的实现，这个实现比较简陋，成员函数也不够完整。后面附带测试代码。

代码如下：

#include <vector>
#include <algorithm>
template <class T>
class binary_heap
{
public:
    void push(const T& x)
        {
                size_t index = _array.size();
                size_t index1 = (index - 1)/2;
                _array.push_back(x);
                while( (index>0) && (_array[index] < _array[index1]) )
                {
                        std::swap(_array[index],_array[index1]);
                        index = index1;
                        index1 = (index - 1)/2;
                }
        }

        bool replace_front(const T& x)
        {
                if( x > front() )
                {
                        _array[0] = x;
                        sort_front(0);
                        return true;
                }
                else
                {
                        return false;
                }
        }

        void pop()
        {
                _array[0] = _array.back();
                _array.pop_back();
                sort_front(0);
        }

        const T& front() const
        {
                return _array[0];
        }

        size_t size() const
        {
                return _array.size();
        }

private:
        void sort_front(size_t index)
        {
                size_t index1 = index * 2 + 1;
                size_t index2 = index * 2 + 2;
                 while( index1 < size() )
                 {
                        if( index2 >= size() ) //临界
                         {
                                 if( _array[index] > _array[index1] )
                                 {
                                         std::swap(_array[index],_array[index1]);
                                         index = index1;
                                 }
                                 else break;
                         }
                         else //普通情况
                         {
                                 if( _array[index1] < _array[index2] )
                                 {
                                         if ( _array[index] > _array[index1] )
                                         {
                                                 std::swap(_array[index],_array[index1]);
                                                 index = index1;
                                         }
                                         else break;
                                 }
                                 else
                                 {
                                         if ( _array[index] > _array[index2] )
                                         {
                                                 std::swap(_array[index],_array[index2]);
                                                 index = index2;
                                         }
                                         else break;
                                 }
                         }
                         index1 = index * 2 + 1;
                         index2 = index * 2 + 2;
                 }

        }
        std::vector<T> _array;

};

//测试代码
#include <windows.h>
__int64 getrand()
{
        static __int64 i = 0;
        ++i;
        return i;
}
int main(int argc, char* argv[])
{
        int I = 100000;
        int J = 10000;

        int t = GetTickCount();
        binary_heap<__int64> s;
        while(s.size() < 10000)
                s.push(getrand());
        for( int j = 0; j < J; j++)
                for( int i = 0; i < I; i++)
                {
                        __int64 temp = getrand();
                        s.replace_front(temp);
                }
                t = GetTickCount() - t;
                printf( "Time = %d ms",t);
                return 0;
}

几点说明：

1，一般认为二叉堆用数组存储，其首元素保留，而从下标为1的元素开始会比较自然，这里我直接从0开始，后果是每个计算增加一次加法运算。

2，这个实现直接用给定类型作为数组成员，当此类型是用户自定义类型，并且尺寸较大的时候，swap等操作的效率比较低。可以考虑以间接方式存取。

3，除了push和size之外，其他的成员函数调用都必须满足堆不为空，用户必须自己检测容器当前的size。

4，理论上，用户自定义容器的行为，应该尽量向标准容器靠拢，提供尽量兼容的外部接口，这样的容器就更容易使用标准库中的各种范型算法，从而增加应用效能。这个版本的二叉堆是一个简化版本，详细的，更接近标准容器行为的二叉堆实现，请参考《STL源码剖析》，这本书中给出了足够详细的描述和代码。（个人感觉如果不是为了成为库，或者提供足够的通用性，写得像标准容器实在累--b）

5，关于二叉堆的其他信息，可以参考我的另一篇随笔《[翻译]在A*寻路中使用二叉堆》

一个池代理模板代码

Panic — Thu, 03 Nov 2005 06:17:00 GMT

一个池代理模板代码

作者： Panic 2005年11月3日

简介:在内部维护池（默认是在堆上），在栈空间创建代理对象的同时，在池中生成被代理的实际对象。
    两者拥有相同的生存周期，并且可以获取相同的值语义。
    PoolAgent模板类的用途有两个，
                    1，是使用池减少频繁的内存分配和释放，
                    2，池对象映射为栈对象。保留原先的创建语法和生存周期。

    由于程序调用栈有限，在栈上构造大型对象往往会引起栈溢出，而频繁new/delete容易引起内存碎片。
    使用这个模板的目的就是避免以上情况的发生。默认情况下，每个代理对象只占据4字节的栈空间。
    这个模板也支持构造超过最大栈空间的对象。

推荐使用的数据类型：以值语义使用的非数组自定义类型。

    推荐使用的场合：
                    1，递归算法，创建较大的栈对象。
                    2，需要频繁申请和释放的短生存周期，但大尺寸的变量。
                    3，容易造成内存碎片的工程，

    禁止使用的场合：
                    1，数组。
                    2，非值类型对象。例如引用，指针等。
                    3，全局，或者静态变量。
                    4，小型对象(本模板会对每个对象造成默认8字节的额外开销，太小的对象会引起内存浪费)
                    5，工厂模式等间接创建的对象。
                    6，多线程。请自己修改代码以实现多线程安全。

总的原则是，可以在栈上直接创建的对象，除数组外，大多都能直接使用本模板。
源代码和测试代码下载：
http://blog.vckbase.com/Files/Panic/PoolAgent.rar

公共接口说明：

namespace Panic
{
    template<typename value_type,typename size_type = size_t,typename buffer_type = char>
        class PoolAgent
    {
        public:
            //存取被代理对象的函数。
            value_type & ref(); //获取引用
            value_type * ptr(); //获取指针

            const value_type &c_ref() const; //获取const引用
            const value_type * c_ptr() const; //获取const指针
            value_type val() const; //获取值

            //重载operator =()，这个是为了让PoolAgent具有值语义。
            PoolAgent & operator = ( const PoolAgent& other);

            //以下是构造函数模板列表，用来适应不同参数个数的类型，这里只写出4个，用户可以根据需要扩充。
            template<typename param>
                explicit PoolAgent(param p);

            template<typename param1,typename param2>
                explicit PoolAgent(param1 p1,param2 p2);

            template<typename param1,typename param2,typename param3>
                explicit PoolAgent(param1 p1,param2 p2,param3 p3);

            template<typename param1,typename param2,typename param3,typename param4>
                explicit PoolAgent(param1 p1,param2 p2,param3 p3,param4 p4);
    };
};

这是以前写的两个小代码，仅供初学者参考

Panic — Tue, 01 Nov 2005 01:45:00 GMT

代码Move是一个在屏幕上跑来跑去的小鱼。
代码倒计时是一个简单的倒计时控制器，可以在经过给定的时间之后进行某种操作，关机或者执行某个可执行文件等等。

技术都十分简单。

代码下载：
http://blog.vckbase.com/Files/Panic/OldCode.rar

手动控制浮点数小数点后有效数字的位数

Panic — Mon, 31 Oct 2005 02:48:00 GMT

代码如下，效率很低，不过既然有人有这个需求，还是试一试吧。

#include <math.h>
#include <iostream>
using namespace std;

//说明：number是需要被舍入的数字，digit是小数点后要保留的位数。
//当number的小数位数超过digit规定时，会四舍五入，反之其实（理论上）没有做任何改变。

inline double roundingup(double number,double digit)
{
double k = pow(10.0,digit);
double f = number * k;
f = f > 0.0 ? floor(f+0.5) : ceil(f-0.5);
f /= k;
return f;
}

//测试代码：

int main(int argc, char* argv[])
{
cout << roundingup(10.123,2.0) << endl;;
return 0;
}

读取ini文件的类，只支持读int和string，权当参考。

Panic — Thu, 27 Oct 2005 10:07:00 GMT

说明：正常途径，除非是考虑读取多个键值的效率问题，一般不必要使用自定义的ini读取类，这里之所以这样做，主要是出于3个原因：
1，被读取的文件在安装后是以数据包的形式存在，硬盘上并没有独立的ini文件，所以读取的接口必须支持直接从内存中获取数据。
2，读取次数非常频繁，而ini的数量相对较多，所以效率是个大问题，而数据包在后台处理有做缓冲优化，所以从内存读取的效率比直接读取文件会高很多。
3，ini文件的修改只能通过数据包的升级完成，所以写入的接口完全不必要。

两个静态函数GetIniFileInt和GetIniFileString分别替代两个对应的API功能。主要目的是为了兼容api的调用方式。

//.h文件
#pragma warning (disable : 4786)
#include <map>
#include <string>
#include <iostream>

class CIniFile
{
public:
        CIniFile(const std::string &filename);
        CIniFile(const char * buf, unsigned long size)
        {
                FromString(buf,size);
        };
        virtual ~CIniFile();
        static long GetIniFileInt(
                const char * lpAppName, // section name
                const char * lpKeyName, // key name
                long nDefault,       // return value if key name not found
                const char * lpFileName // initialization file name
                );

        static unsigned long GetIniFileString(
                const char * lpAppName,        // section name
                const char * lpKeyName,        // key name
                const char * lpDefault,        // default string
                char * lpReturnedString, // destination buffer
                unsigned long nSize,              // size of destination buffer
                const char * lpFileName        // initialization file name
                );

        long GetIniFileInt(
                const char * section, // section name
                const char * key, // key name
                long defaultvalue       // return value if key name not found
                );

        unsigned long GetIniFileString(
                const char * section,        // section name
                const char * key,        // key name
                const char * defaultstring,        // default string
                char * destination, // destination buffer
                unsigned long size              // size of destination buffer
                );
private:
        void FromString(const char * buf, unsigned long size);
        typedef std::map<const std::string, std::string> KEY_VALUE;
        typedef std::map< const std::string, KEY_VALUE > SECTION_KEY ;
        SECTION_KEY _buf;
};

//.cpp文件

#include "IniFile.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CIniFile::CIniFile(const std::string &filename)
{
        //从文件读取。
        FILE * fp = fopen(filename.c_str(),"rw");
        if( fp )
        {
                fseek(fp,0,SEEK_END);
                int size = ftell(fp);
                char * p = new char[size+1];
                p[size] = 0;
                fseek(fp,0,SEEK_SET);
                fread(p,size,1,fp);
                fclose(fp);
                FromString(p,size);
                delete [] p;
        }
}

void CIniFile::FromString(const char * buf, unsigned long size)
{
        enum STATE { ENTER_SECTION,END_SECTION, ENTER_KEY, END_KEY ,ENTER_STRING, END_STRING,START };
        STATE s = START;
        std::string section;
        std::string key;
        std::string str;
        while ( *buf != '\0' )
        {
                switch( s )
                {
                case START:
                        {
                                if( *buf == '[' )
                                {
                                        section = "";
                                        s = ENTER_SECTION;
                                }
                        }break;
                case ENTER_SECTION:
                        {
                                if( *buf == ']' ) s = END_SECTION;
                                else section += *buf;
                        }break;
                case END_SECTION:
                        {
                                if( *buf == '\n' ) //换行，表示进入key的区域。
                                {
                                        key = "";
                                        s = ENTER_KEY;
                                }
                        }break;
                case ENTER_KEY:
                        {
                                if( *buf == '=' )
                                {
                                        str = "";
                                        s = END_KEY;
                                }
                                else
                                {
                                        if( *buf != ' '
                                                && *buf != '\t'
                                                && *buf != '\r'
                                                && *buf != '\n'
                                                )
                                                key += *buf;
                                }
                        }break;
                case END_KEY:
                        {
                                if( *buf != ' '
                                        && *buf != '\t'
                                        && *buf != '\r'
                                        && *buf != '\n'
                                        )
                                {
                                        str = *buf;
                                        s = ENTER_STRING;
                                }
                        }break;
                case ENTER_STRING:
                        {
                                if( *buf != '\n' ) //没有换行
                                {
                                        if( *buf != '\r' )
                                        str += *buf;
                                }
                                else //遇到换行
                                {
                                        _buf[section][key] = str;
                                        s = END_STRING;
                                }
                        }break;
                case END_STRING: //下一个有可能遇到section也有可能遇到key，不过key的面大些。
                        {
                                switch( *buf )
                                {
                                case '[': //新的section
                                        {
                                                section = "";
                                                s = ENTER_SECTION;
                                        }break;
                                case ' ': case '\r': case '\n': case '\t' ://空格，忽略。
                                        break;
                                default: //如果都不是，就是key了。
                                        {
                                                key = *buf;
                                                s = ENTER_KEY;
                                        }
                                }
                        }break;
                default:break;
                }
                buf++;
        }

}

CIniFile::~CIniFile()
{

}

unsigned long CIniFile::GetIniFileString(
                                                                  const char * section,        // section name
                                                                  const char * key,        // key name
                                                                  const char * defaultstring,        // default string
                                                                  char * destination, // destination buffer
                                                                  unsigned long size              // size of destination buffer
                                                                  )
{
        std::string ret = _buf[ std::string(section) ][ std::string(key) ];
        if( ret.length() == 0 ) //没有
        {
                ret = defaultstring;
        }
        strncpy( destination,ret.c_str(),size);
        return ret.length();
}

long CIniFile::GetIniFileInt(
                                   const char * section, // section name
                                   const char * key, // key name
                                   long defaultvalue       // return value if key name not found
                )
{
        std::string ret = _buf[ std::string(section) ][ std::string(key) ];
        if( ret.length() == 0 ) //没有
        {
                return defaultvalue;
        }
        else
        {
                return atoi(ret.c_str());
        }
}

long CIniFile::GetIniFileInt(
                                                  const char * lpAppName, // section name
                                                  const char * lpKeyName, // key name
                                                  long nDefault,       // return value if key name not found
                                                  const char * lpFileName // initialization file name
                                                  )
{
        return CIniFile(std::string(lpFileName)).GetIniFileInt(lpAppName,lpKeyName,nDefault);
}

unsigned long CIniFile::GetIniFileString(
                                                                          const char * lpAppName,        // section name
                                                                          const char * lpKeyName,        // key name
                                                                          const char * lpDefault,        // default string
                                                                          char * lpReturnedString, // destination buffer
                                                                          unsigned long nSize,              // size of destination buffer
                                                                          const char * lpFileName        // initialization file name
                )
{
        return CIniFile(std::string(lpFileName)).GetIniFileString(lpAppName,lpKeyName,lpDefault,lpReturnedString,nSize);
}

RSA相关代码，包含无符号大整数运算的实现。

Panic — Thu, 22 Sep 2005 03:22:00 GMT

RSA相关代码，包含无符号大整数运算的实现。

代码说明：
大数运算仅为RSA算法设计，使用了固定数组作为元素存储的单元。
RSA中不需要使用的算法，本代码都没有实现。
大数运算中，部分代码出于效率的原因，使用了内联汇编。

RSA代码中，仅提供了数学实现，没有对密钥存储等细节作进一步封装。

注意，程序中默认定义的数组长度：
enum LIMIT{ LENGTH = 0xFF,SMALLPRIMES = 5000};
只有255，这个长度只能处理4080bit的密钥，也就是每个质数的长度不能超过2040bit，需要处理更大的密钥请自行修改这个定义的数值。

新上传的版本，这个数值已经改为0x3FF，这样每个质数的大小就达到8184bit，足够满足一般的应用了。

有任何疑问请到本博客留言或跟帖。

VC6.0工程源代码下载：
http://blog.vckbase.com/Files/Panic/rsa.rar

长整型开方的代码，用来避免sqrt调用

Panic — Thu, 28 Jul 2005 09:40:00 GMT

代码如下：

long ulTable[0x10000];

void inittable()
{
        static bool b = true;
        if( b )
        {
                b = false;
                for( int i = 0; i < 0x10000; i++)
                {
                        ulTable[i] = sqrt(i) + 0.5;
                }
        }
}

inline long lsqrt(long x)
{
        long upper = x  >> 16;
        if( upper )
        {
                long root = ulTable[upper] << 8;
                long    d = (x - root * root);
                d /= (root*2);
                for(;d != 0; )
                {
                        root += d;
                        d = (x - root * root);
                        d /= (root*2);
                }
                return root;
        }
        else
        {
                return ulTable[x];
        }
}

测试代码：

#include <iostream>
using namespace std;
int main()
{
        inittable();
        long x;
        cout << "Input: " ;
        cin >> x;
        cout << "root of x is: " << lsqrt(x) << endl;
        return 0;
}

经过测试，效率仍然不够高，请帮忙改进。

根据距离1900年1月1日的天数(0起始)，计算这一天的日期(年，月，日)

Panic — Fri, 22 Jul 2005 12:18:00 GMT

周星星的问题：已知1900年到某时刻经过的天数，如何求得这个时刻的年月日？（不用任何库函数） [所有相关帖子]

<本贴无正文>

探花周星星发表于 2005-7-22 16:29:55

以下是偶的代码，但是结果和星星的不一样。请大家帮忙检查。

#include <iostream>
#include <assert.h>
using namespace std;

//判断是否闰年
bool IsLeapYear(unsigned long year)
{
        if( year%4 ) return false;
        else
                if( year %100 ) return true;
                else
                        if( year % 400 ) return false;
                        else return true;
}

//根据一年中的第几天(0起始)，返回月份(1起始)，并且置天数为其在本月的索引(0起始)
unsigned long GetMonthByDay(unsigned long &day,bool leap)
{
        assert( day < (leap?366:365) );
        static unsigned long monthtable[] = { 31,29,31,30,31,30,31,31,30,31,30,31 } ;
        monthtable[1] = leap ? 29:28;

        unsigned long month = 0;
        unsigned long count = 0;
        unsigned long n = day;

        do
        {
                n = day - count;
                count += monthtable[month++];
        }while( day >= count );
        day = n;
        return month;
}

//距离1900年1月1日的天数(0起始)，返回年，并且置天数为其在本年的索引(0起始)
unsigned long GetYearByDay(unsigned long &day)
{
        unsigned long Y = day / 365;
        long D = day % 365;
        long  YY = Y-1;
        D -= YY/4;
        D += YY/100;
        D -= (YY+300)/400;
        while( D < 0)
        {
                Y--;
                D += IsLeapYear(Y+1900) ? 366 : 365;
        }
        day = D;
        return Y + 1900;
}

//距离1900年1月1日的天数(0起始)，计算这一天的日期(年，月，日)(1起始)。
void foo(unsigned long &day,unsigned long &year,unsigned long &month)
{
        year = GetYearByDay(day);
        month = GetMonthByDay(day,IsLeapYear(year));
        day += 1;
}

int main()
{
        unsigned long day = 38555;
        unsigned long year = 0;
        unsigned long month  = 0;
        foo(day,year,month);
        cout << year << "/" << month << "/" << day << endl;
        return 0;
}

环境：VC6 SP5,Win2kPro
结果：
2005/7/24
Press any key to continue