C++博客-C++ Jounior-随笔分类-算法＋数据结构

银行家算法

snowball — Sun, 06 Jul 2008 14:16:00 GMT

摘要: reference ; http://www.yuanma.org/data/2008/0116/article_2945.htm算法的实现一、初始化由用户输入数据，分别对可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION、需求矩阵NEED赋值。二、银行家算法在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性... 阅读全文

snowball 2008-07-06 22:16 发表评论

求得含有最多连续特定字符个数的字符串

snowball — Wed, 02 Apr 2008 01:30:00 GMT

int GetMaxCountofContinuousLetter( char * p, char searchChar)
{
     int maxCount = 0 ;
     int currentCount = 0 ;
     while ( 1 )
     {
         if ( * p == searchChar)
         {
            currentCount = 0 ;
             while ( * p && * p == searchChar)
             {
                currentCount ++ ;
                p ++ ;
            }
             if (maxCount < currentCount)
                maxCount = currentCount;
        }
         if ( * p == ' \0 ' )
             break ;
         else
            p ++ ;
    }
     return maxCount;
}
int main()
{
     char * p[ 3 ] =
     {
         " String(1)8818882348888856788888888988888888880 " ,
         " String(2)881888234888885678888888898888888880 " ,
         " String(3)8818882348888856788888888988888888888888880 "
    } ;
     int location = 0 ;
     char searchChar = ' 8 ' ;
     int tempCount = 0 ;
     int maxCount = 0 ;
     for ( int i = 0 ;i < sizeof (p) / sizeof ( * p);i ++ )
     {
        tempCount = GetMaxCountofContinuousLetter(p[i],searchChar);
         if ( tempCount > maxCount)
         {
            maxCount = tempCount;
            location = i;
        }
    }
    cout << " the string of maxCount is : " << p[location] << endl;
    cout << " the count of  the continuous letters is : " << maxCount << endl;
    cin. get ();
}

snowball 2008-04-02 09:30 发表评论

排序

snowball — Wed, 02 Apr 2008 01:26:00 GMT

摘要: 排序算法阅读全文

snowball 2008-04-02 09:26 发表评论

从str中删除remove中含有的字符

snowball — Wed, 02 Apr 2008 01:25:00 GMT

/* **************************************** */
/* 从str中删除remove中含有的字符           */
/* **************************************** */
void RemoveChar( char str[], char remove[])
{
     int dst,src;
     char removeArray[ 256 ];
    puts(str);
    puts(remove);
     for (src = 0 ;src < 256 ;src ++ )
     {
       removeArray[src] = 0 ;
    }
    src = 0 ;
     while (remove[src])
     {
       removeArray[remove[src ++ ]] = 1 ;
    }
    src = 0 ;dst = 0 ;
     while (str[src])
     {
         if ( ! removeArray[str[src]])
         {
            str[dst ++ ] = str[src];
        }
        src ++ ;
    }
    str[dst] = 0 ;
    puts(str);
}

snowball 2008-04-02 09:25 发表评论

Write a routine that prints out a 2-D array in spiral order

snowball — Wed, 02 Apr 2008 01:23:00 GMT

jeccy (燕飞月天) 于 2006年10月28日21:37:09 星期六提到：

我的理解，给定2维数组
1 2 3三角形判断
8 9 4
7 6 5
“螺旋式”顺序输出：1 2 3 4 5 6 7 8 9
【在 bluexyz (数据结构是根本) 的大作中提到: 】

private static void PrintNumberasSpiralOrder()
         {
             // 1  2  3   4
             // 12 13 14  5
             // 11 16 15  6
             // 10 9   8  7

             // 1,  2 , 3,  4,  5
             // 16, 17, 18, 19, 6
             // 15, 24, 25, 20, 7
             // 14, 23, 22, 21, 8
             // 13, 12, 11, 10, 9
             int [,] a = new int [,]
             { { 1 , 2 , 3 , 4 , 5 } ,
             { 16 , 17 , 18 , 19 , 6 } ,
             { 15 , 24 , 25 , 20 , 7 } ,
             { 14 , 23 , 22 , 21 , 8 } ,
             { 13 , 12 , 11 , 10 , 9 } } ;
             // int[,] a = new int[,] { { 1, 2, 3, 4 }, { 12, 13, 14, 5 }, { 11, 16, 15, 6 }, { 10, 9, 8, 7 } };
             // int[,] a = new int[,] { { 1, 2 }, {4,3} };
             const int N = 5 ;
             // spiral
             for ( int i = N - 1 , j = 0 ; i > 0 ; i -- , j ++ )
             {
                 // i 从最大维度数开始
                 // j 从最小维度数开始
                 // i--来缩小范围
                 // j++来缩小范围
                 // k 增长缩小因子
                 for ( int k = j; k < i; k ++ )
                    System.Console.Write( " {0} " , a[j, k]); Console.WriteLine( "" );
                 for ( int k = j; k < i; k ++ )
                    System.Console.Write( " {0} " , a[k, i]); Console.WriteLine( "" );
                 for ( int k = i; k > j; k -- )
                    System.Console.Write( " {0} " , a[i, k]); Console.WriteLine( "" );
                 for ( int k = i; k > j; k -- )
                    System.Console.Write( " {0} " , a[k, j]); Console.WriteLine( "" );
            }
             // special case for middle element if N is odd
             // 如果是奇数，则要条印中间的数。
             if (N % 2 == 1 ) System.Console.Write(a[(N - 1 ) / 2 , (N - 1 ) / 2 ]);
        }

Reference : http://bigtiger2005.spaces.live.com/blog/cns!4e967c6fe38e7c14!141.entry?wa=wsignin1.0

snowball 2008-04-02 09:23 发表评论

100扇门，100个人，第i个人经过门号可以整除i的门。经过时，如果门开就关，如果门关就开。问最后所有门的状态是什么。

snowball — Wed, 02 Apr 2008 01:20:00 GMT

#include    < stdio.h >

#define    N   100
#define    OPEN   1
#define    CLOSED   0

void    switch_door( int     * door)
{
         if ( * door    ==    OPEN)
                 * door    =    CLOSED;
         else
                 * door    =    OPEN;
}

int    main( void )
{
         int    door[N    +     1 ];    //    waste   a   door
         int    person;
         int    i;

         for (i    =     1 ;   i    <=    N;   i ++ )
                door[i]    =    OPEN;    //    all   doors   are   open   at   first

         for (i    =     1 ;   i    <=    N;   i ++ )
                 for (person    =     1 ;   person    <=    N;   person ++ )    //    person   pass   through   the   door
                         if (i    %    person    ==     0 )
                                switch_door( & door[i]);

         for (i    =     1 ;   i    <=    N;   i ++ )
                printf( " door   %d:   %s\n " ,   i,   door[i]    ?     " Open "    :    " Closed " );

         return     0 ;
}

给一个此题的思想：
要看门的状态，主要是看这扇门开关次数，开关奇数次会使门的状态改变，而偶数次就不会。而只要能够知道当前门的编号能够整除的自然数，就可以知道门的状态是否改变了。从而知道门当最终的状态。

下面我们将所有的数分为两组，平方数（1，4，9……）和非平方数（为什么要这么分？下面就知道了）。
现在讨论非平方数的情况。我们假设门号为N,同时假设从1开始到int(N^(1/2))(也就是N的开方数舍小数取整），总共有M个数能整除N,则从int(N^(1/2))+1到N,总共则对应也有M个数能够将N整除。（这句话仔细想一下）。
在此，就有2*M个数能将N整除，它是一个偶数。因此门开关了偶数次，门的状态最后不会被改变。

现在讨论平方数，因为N^(1/2)这个数是一个整数，因此我们将从1到N的所有的数用N^(1/2)这个数分成两部分(不包括N^(1/2))，同样假设前半部分有M个数可以将N整除，则后半部分也有M个数可以将N整除，这样就有2*M个数可以整除N了，再加上N^(1/2)这个数。总共就有2*M+1个数可以整除N,也就是编号为N的门会开关2*M+1次，门的状态就会被改变了。

综上，如果门号数是平方数的，门的状态就会发生改变，而不是平方数的就不会改变状态了。因此，只要检查门是否为完全平方数就可以判断门的状态为开还是为关了。

帖上代码：
#include    < iostream >
#include    < cmath >
using     namespace    std;

int    main()
{
         int    k;
         for ( int    i    =     1 ;   i    <= 100 ;   i ++ )
         {
        cout    < <     " Door    "     < <    i   ;
        k    =     int (sqrt(i));
         if (k * k    ==    i)
        cout    < <     " :   Closed " ;
         else
        cout    < <     " :   Open " ;
        cout    < <    endl;
        }
return     0 ;
}
当然，这是利用了人数与门数是相等的情况。如果个数不同的话，还是按照一楼的来。

Reference : http://topic.csdn.net/u/20070620/14/3d5e96d5-169a-4bc6-887c-ca8639cd8c63.html

snowball 2008-04-02 09:20 发表评论

统计1的个数

snowball — Wed, 02 Apr 2008 01:17:00 GMT

统计1的个数

int func(x)
{
     int countx = 0 ;
     while (x)
     {
        countx ++ ;
        x = x & (x - 1 );
    }
     return countx;
}

假定x = 9999
10011100001111
答案: 8

将x转化为2进制，看含有的1的个数

x = x & (x - 1 ) 这种算法是把一个二进制数最右边的一个1变成0

然后呢？

x - 1与x区别在于最后二进制的1

每执行一次x = x & (x - 1 )，会将x用二进制表示时最右边的一个1变为0，因为x - 1将会将该位(x用二进制表示时最右边的一个1)变为0。

如果是二进制100, - 1 ，则为011

如果是二进制101， - 1则为100

与原数一与，就1后面的数，包括1全都与掉

明白，谢谢了

不客气

思路: 将x转化为2进制，看含有的1的个数。
注: 每执行一次x = x&(x-1)，会将x用二进制表示时最右边的一个1变为0，因为x-1将会将该位(x用二进制表示时最右边的一个1)变为0。(1) 如果一个数是2的n次方，那么这个数用二进制表示时其最高位为1，其余位为0。
判断一个数(x)是否是2的n次方

#include < stdio.h >

int func(x)
{
     if ( (x & (x - 1 )) == 0 )
         return 1 ;
     else
         return 0 ;
}

int main()
{
     int x = 8 ;
    printf( " %d\n " , func(x));
}

snowball 2008-04-02 09:17 发表评论

全排列的生成算法

snowball — Wed, 02 Apr 2008 01:06:00 GMT

摘要: 全排列的生成算法就是对于给定的字符集，用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。任何n个字符集的排列都可以与1～n的n个数字的排列一一对应，因此在此就以n个数字的排列为例说明排列的生成法。n个字符的全体排列之间存在一个确定的线性顺序关系。所有的排列中除最后一个排列外，都有一个后继；除第一个排列外，都有一个前驱。每个排列的后继都可以从它的前驱经过最少的变化而得到，全排列的生成算法就是... 阅读全文

snowball 2008-04-02 09:06 发表评论

进制转换程序

snowball — Wed, 02 Apr 2008 01:02:00 GMT

void test10_2( void )
   {
    static char const * szHexDigits = " 01 " ;
   unsigned char b = 16 ;
   cout << szHexDigits[(b >> 7 ) & 0x01 ] << szHexDigits[(b >> 6 ) & 0x01 ] << ' ' ;
   cout << szHexDigits[(b >> 5 ) & 0x01 ] << szHexDigits[(b >> 4 ) & 0x01 ] << ' ' ;
   cout << szHexDigits[(b >> 3 ) & 0x01 ] << szHexDigits[(b >> 2 ) & 0x01 ] << ' ' ;
   cout << szHexDigits[(b >> 1 ) & 0x01 ] << szHexDigits[(b >> 0 ) & 0x01 ] << ' ' ;
}

void test10_16( void )
   {
     static char const * szHexDigits = " 0123456789abcdef " ;
   unsigned char b = 16 ;
   cout << szHexDigits[(b >> 4 ) & 0x0f ] << szHexDigits[b & 0x0f ] << ' ' ;
}

snowball 2008-04-02 09:02 发表评论