【编程珠玑】读书笔记 第二章 算法

2013-07-11 22:00:28

第二章 算法

本章围绕三个问题进行算法讨论，包括元素的查找、字符串的旋转、以及变位词的查找。

下面给出了实现代码、以及测试结果。

问题一 查找不存在的元素

思路一：用位图；

思路二：用二分搜索法，这种方法需要先对数组排序；

若用二分搜索法，有以下限制：

满足以下假设：
1)数组中没有重复元素
2）数组中必有缺失元素

书中给出的问题也正是具有这样的特殊性，因此可以使用二分法进行缺失元素的查找。

下面的代码给出了上述两种方法的实现代码，以及测试代码所需要的数据产生程序、位图排序程序，后面附上了测试结果。

注意：此处的代码没有数据的合法性检查，假设数据满足上面的条件。

完整代码：

#include <iostream>
#include <bitset>
#include <ctime>
using namespace std;

const int MAX_NUMBER = 10000010;
const int NUMBER_OF_DATA = 10000000;

//产生在区间[lowerBound,upperBound]内的一个随机数
int RandomInt(const int lowerBound,const int upperBound)
{
    return ( lowerBound + ( RAND_MAX * rand() + rand() ) % (upperBound - lowerBound + 1) );
}

//产生在[0,maxOfRandomInt]范围内的numberOfRandomInt个随机数
//结果存入数组randomInt中
void RandomIntGen(const int numberOfRandomInt,const int maxOfRandomInt,int randomInt[])
{
    int i;
    int tmp;
    int randomTmp;
    int *sequenceInt = new int[maxOfRandomInt];

    srand((unsigned) time(NULL));

    for (i = 0; i < maxOfRandomInt; i++)
    {
        sequenceInt[i] = i;    
    }

    for (i = 0; i < numberOfRandomInt; i++) 
    {
        randomTmp = RandomInt(i, maxOfRandomInt - 1);
        tmp = sequenceInt[randomTmp];
        sequenceInt[randomTmp] = sequenceInt[i];
        sequenceInt[i] = tmp;
        randomInt[i] = sequenceInt[i];    //随机数保存在数组中
    }

    delete [] sequenceInt;   //释放内存
}

//注意写初始化函数
void Init(int BitmapArray[],const int n)
{
    for (int i = 0;i < n;++i)
    {
        BitmapArray[i] = 0;
    }
}

//用int型模拟位图，实现的位图排序
const int BitsPerInt = 32;
const int Div32Shift = 5;
const int Mod32Mask = 0x1F;

//BitmapSort_2:用位运算实现置位、清零、判断是否为1
void SetBit(int BitmapArray[],const int BitToSet)
{
    //BitmapArray[ (BitToSet >> Div32Shift) ] | = ( 1 << (BitToSet & Mod32Mask) );  //error C2059: syntax error : '='
    BitmapArray[ (BitToSet >> Div32Shift) ] = BitmapArray[ (BitToSet >> Div32Shift) ] 
    | ( 1 << (BitToSet & Mod32Mask) ); 
}

void ClearBit(int BitmapArray[],const int BitToClear)
{
    BitmapArray[ (BitToClear >> Div32Shift) ] = BitmapArray[ (BitToClear >> Div32Shift) ] 
    & ~( 1 << (BitToClear & Mod32Mask) ); 
}

bool IsBitSet(const int BitmapArray[],const int BitToCheck)  //定义为const类型，在不小心改变时，会给出报错信息
{
    return ( BitmapArray[ (BitToCheck >> Div32Shift) ] & ( 1 << (BitToCheck & Mod32Mask) ) ); 
}

void BitmapSort_2(int ArrayUnsorted[],const int n)
{
    int i ;
    int cnt = 0;
    int *BitmapArray = new int[1 + MAX_NUMBER/BitsPerInt];   //当MaxRandomInt较大时，必须从对上分配内存，否则内存不够用，导致出错

    if (NULL == BitmapArray)
    {
        cout<<"memory allocation error !"<<endl;
        exit(0);
    }

    Init(BitmapArray,1 + MAX_NUMBER/BitsPerInt);   //初始化为0

    for (i = 0;i < n;++i)
    {
        SetBit(BitmapArray,ArrayUnsorted[i]);
    }

    for (i = 0;i < MAX_NUMBER;++i)  //不是for (i = 0;i < n;++i)
    {
        if ( IsBitSet(BitmapArray,i) )
        {
            ArrayUnsorted[cnt++] = i;
        }
    }

    delete [] BitmapArray;
}

//用位图的方法查找丢失元素
//满足以下假设：
//1)数组中没有重复元素
//2）数组中必有缺失元素
int FindLostByBitmap(int arrayToFind[],int numberOfData)
{
    int i ;
    int cnt = 0;
    int *BitmapArray = new int[1 + MAX_NUMBER/BitsPerInt];   //当MaxRandomInt较大时，必须从对上分配内存，否则内存不够用，导致出错

    if (NULL == BitmapArray)
    {
        cout<<"memory allocation error !"<<endl;
        exit(0);
    }

    Init(BitmapArray,1 + MAX_NUMBER/BitsPerInt);   //初始化为0

    for (i = 0;i < numberOfData;++i)
    {
        SetBit(BitmapArray,arrayToFind[i]);
    }

    for (i = 0;i < MAX_NUMBER;++i)  //不是for (i = 0;i < n;++i)
    {
        if ( !IsBitSet(BitmapArray,i) )
        {
            return i;
        }
    }

    if (MAX_NUMBER == i)
    {
        cout<<"no element is lost!"<<endl;
        return -1;
    }

    delete [] BitmapArray;
}

//二分搜索法
//满足以下假设：
//1)数组中没有重复元素
//2）数组中必有缺失元素
int FindLostByBinarySearch(int arrayToFind[],int numberOfData)
{
    int cnt = 0;
    int begin  = 0;
    int end = numberOfData - 1;
    int mid = 0;

    if (NULL == arrayToFind || numberOfData < 2)
    {
        cout<<"the input array is invalid!"<<endl;
        return -1;
    }

    while (begin < end - 1)
    {
        mid = (begin + end)/2;
        if (arrayToFind[mid] - arrayToFind[begin] > mid - begin)
        {
            end = mid;
        }
        else
        {
            begin = mid;
        }
    }

    if (arrayToFind[end] - arrayToFind[begin] > 1)
    {  
        return (arrayToFind[begin] + 1);
    }
    else 
    {
        cout<<"no element is lost!"<<endl;
        return -1;
    }
}

//将数组写入txt中，便于检查结果的正确性
void WriteArrayToUnsortedTxt(int array[],int n)
{
    FILE *fout;
    int i;

    fout = fopen("array_unsorted.txt","wt");

    if(fout == NULL)
    {
        printf("forward_i.txt open error!
");
        exit(0);
    }

    printf("file open success!
");

    for (i = 0;i < n;i++) 
    {
        fprintf(fout,"%d
",array[i]);
    }

    fclose(fout);    
}

//将数组写入txt中，便于检查结果的正确性
void WriteArrayToSortedTxt(int array[],int n)
{
    FILE *fout;
    int i;

    fout = fopen("array_sorted.txt","wt");

    if(fout == NULL)
    {
        printf("forward_i.txt open error!
");
        exit(0);
    }

    printf("file open success!
");

    for (i = 0;i < n;i++) 
    {
        fprintf(fout,"%d
",array[i]);
    }

    fclose(fout);    
}

//显示数组元素
void DisplayArray(int ArrayUnsorted[],int n)
{
    for (int i = 0;i < n;++i)
    {
        cout<<ArrayUnsorted[i]<<"	";
    }
    cout<<endl;
}

//测试代码
int main(void)
{
    const int numberOfData = NUMBER_OF_DATA;
    const int maxOfRandomInt = MAX_NUMBER;
    int *arrayToFind = new int[NUMBER_OF_DATA];
    int StartTime = 0;
    int TimeCost = 0; 

    cout<<"the max number of integer is : "<<maxOfRandomInt<<endl;
    cout<<"the number of integer is : "<<numberOfData<<endl;

    RandomIntGen(numberOfData,maxOfRandomInt,arrayToFind);
    WriteArrayToUnsortedTxt(arrayToFind,numberOfData);
    /*cout<<"the randomInt array is :"<<endl;
    DisplayArray(arrayToFind,numberOfData);*/
    
    //Test FindLostByBitmap
    cout<<"Test FindLostByBitmap..."<<endl;
    StartTime = clock();
    cout<<"the lost number is : "<<FindLostByBitmap(arrayToFind,numberOfData)<<endl;
    TimeCost = 1e6 * ( clock() - StartTime ) / CLOCKS_PER_SEC;
    cout<<"the time cost of FindLostByBitmap is : "<<TimeCost<<"ms"<<endl;

    //BitmapSort_2,为使用基于二分法的搜索进行排序的预处理
    cout<<"Test BitmapSort_2..."<<endl;

    StartTime = clock();
    BitmapSort_2(arrayToFind,numberOfData);
    TimeCost = 1e6 * ( clock() - StartTime ) / CLOCKS_PER_SEC;
    cout<<"the time cost of BitmapSort_2 is : "<<TimeCost<<"ms"<<endl;

    WriteArrayToSortedTxt(arrayToFind,numberOfData);
    /*cout<<"the sorted array is : "<<endl;
    DisplayArray(arrayToFind,numberOfData);  */

    //Test FindLostByBinarySearch
    cout<<"Test FindLostByBinarySearch..."<<endl;
    StartTime = clock();
    cout<<"the lost number is : "<<FindLostByBinarySearch(arrayToFind,numberOfData)<<endl;
    TimeCost = 1e6 * ( clock() - StartTime ) / CLOCKS_PER_SEC;
    cout<<"the time cost of FindLostByBinarySearch is : "<<TimeCost<<"ms"<<endl;

    delete [] arrayToFind;   //delete与new要配对出现
    return 0;
}

测试结果，1000,0010个数据中缺失10个时：

（可见，在该规模下，用二分搜索法的速度约为位图法的1000+倍）

the max number of integer is : 10000010
the number of integer is : 10000000
file open success!
Test FindLostByBitmap...
the lost number is : 7952
the time cost of FindLostByBitmap is : 1486000ms
Test BitmapSort_2...
the time cost of BitmapSort_2 is : 2078000ms
file open success!
Test FindLostByBinarySearch...
the lost number is : 7952
the time cost of FindLostByBinarySearch is : 8000ms
请按任意键继续. . .

上面的结果只是程序运行一次的结果，如果要得到比较靠靠的分析，应该多次测试，而且测试的结果可能与数据集有关，若要固定数据集，将随机数产生函数RandomIntGen中的//srand((unsigned) time(NULL));注释掉即可。

---

问题二 数组的旋转

对于该问题，大多数人都能想到比较直观的解决方法，书中已有说明，此处不再赘述，另外，书中给出了一种比较巧妙的解法，称为杂技法，并给出了代码实现，但对于该方法的原理没有介绍，杂技法不易理解，此处暂时不做讨论。

---

问题三 变位词的查找

可借助于[标识，单词]对，将变位词进行标识，根据标识划分变位词。

借助于C++的工具vector、以及map，可以方便地实现。

注意几点：

1. 数据结构的选择，存储单词采用 vector <string> ，因为每个单词是string类型 ；
2. 存储[标识，单词]，采用map < string ,vector <string> >，因为一个标识sign对应多个string类型的单词；
3. 标识通过对单词的排序得到，此处采用C++的排序函数sort，sort( sign.begin(),sign.end() );

完整代码如下：

//显示vector <string>类型对象的元素
void DisplayVector(vector <string> stringVector)
{
    vector <string> ::iterator iterVector;

    for (iterVector = stringVector.begin();iterVector != stringVector.end();++iterVector)
    {
        cout<<*iterVector<<"	";
    }
    cout<<endl;
}

//变位词的查找
void FindAnagrams()
{
    map < string ,vector <string> > signWordMap;  
    vector <string> dictVector;
    string word;
    string sign;
    
    cout<<"please enter a word ,end with ctrl+z: "<<endl;
    while (cin>>word)        //输入字典中单词
    {
        dictVector.push_back(word);
        cout<<"please enter a word ,end with ctrl+z: "<<endl;
    }
    cout<<"the dictionary is : "<<endl;
    DisplayVector(dictVector);

    vector <string> :: iterator iterVector;

    for (iterVector = dictVector.begin();iterVector != dictVector.end();++iterVector)  //制作标识、单词对
    {
        sign = *iterVector;
        sort( sign.begin(),sign.end() );
        signWordMap[sign].push_back(*iterVector);
    }

    map < string ,vector <string> > :: iterator iterMap;

    for (iterMap = signWordMap.begin();iterMap != signWordMap.end();++iterMap)//输出变位词
    {
        cout<<"the anagrams signed by "<<(*iterMap).first<<" is :"<<endl;
        for (iterVector = (*iterMap).second.begin() ;iterVector != (*iterMap).second.end();++iterVector)
        {
            cout<<*iterVector<<"	";
        }
        cout<<endl;
    }
}

int main(void)
{
    //test FindAnagrams
    FindAnagrams();
    return 0;
}

运行结果：

please enter a word ,end with ctrl+z:
tops  stop snap pans top ant at
please enter a word ,end with ctrl+z:
please enter a word ,end with ctrl+z:
please enter a word ,end with ctrl+z:
please enter a word ,end with ctrl+z:
please enter a word ,end with ctrl+z:
please enter a word ,end with ctrl+z:
please enter a word ,end with ctrl+z:
^Z
the dictionary is :
tops    stop    snap    pans    top     ant     at
the anagrams signed by anps is :
snap    pans
the anagrams signed by ant is :
ant
the anagrams signed by at is :
at
the anagrams signed by opst is :
tops    stop
the anagrams signed by opt is :
top
请按任意键继续. . .