对Alexia(minmin)网友代码的评论及对“求比指定数大且最小的‘不重复数’问题”代码的改进

// 求比指定数大且最小的“不重复数”

#include <stdio.h>

void minNotRep(int n)
{
    // 需要多次判断
    while(1)
    {
        int a[20], len = 0, i, b = 0;
        // flag为true表示是“重复数”，为false表示表示是“不重复数”
        bool flag = false;

        // 将n的各位上数字存到数组a中
        while(n)
        {
            a[len++] = n % 10;
            n = n / 10;
        }

        // 从高位开始遍历是否有重复位
        for(i = len - 1; i > 0; i--)
        {
            // 有重复位则次高位加1（最高位有可能进位但这里不需要额外处理）
            if(a[i] == a[i - 1] && !flag)
            {
                a[i - 1]++;
                flag = true;
            }
            else if(flag)
            {
                // 将重复位后面的位置为0101...形式
                a[i - 1] = b;
                b = (b == 0) ? 1 : 0;
            }
        }

        // 重组各位数字为n，如果是“不重复数”则输出退出否则继续判断
        for(i = len - 1; i >= 0; i--)
        {
            n = n * 10 + a[i];
        }

        if(!flag)
        {
            printf("%d\n", n);
            break;
        }
    }
}

int main()
{
    int N;

    while(scanf("%d", &N))
    {
        minNotRep(N + 1);
    }

    return 0;
}

/*
诸函数类型声明：
输入N();
求最小不重复数();
输出();
*/

int main()
{
    int N;

    //输入N();
    //求最小不重复数();
    //输出();

    return 0;
}

/*
诸函数定义：
输入N()
{
}
求最小不重复数();
{
}
输出();
{
}
*/

#include <stdio.h>

#define MAX 100 
typedef  struct
         {
            unsigned char t[ MAX + 1 ] ; 
            int top ;                //记录第一位数的下标 
         } 
         Map ;

void input( Map * );
void reverse( unsigned char [] , int );
void exchange( unsigned char * , unsigned char * );
void squeeze( Map * );
void find( Map * );
int  search( const Map * );
void add_1( Map * , const int );
void clear( Map * , const int , const int );
void out( const Map * );

int main( void )
{
   Map num ;
   
   input( & num );     //输入正整数 
   add_1( & num , 0 ); //加1 
   find ( & num );     //求不重复数 
   out  ( & num );     //输出 
   
   return 0;
}

void squeeze( Map * p_m )
{
   while ( p_m -> t[ p_m -> top ] == 0 ) 
      p_m -> top -- ;   
}

void exchange( unsigned char * p1 , unsigned char * p2 )
{
   unsigned char c = * p1 ;
   * p1 = * p2 ;
   * p2 = c ;
}

void reverse( unsigned char a[] , int n )
{
   int i ;
   
   for ( i = 0 , n -- ; i < n ; i ++ , n -- )
      exchange( a + i , a + n );

}

void input( Map *p_m )
{
   int c ;
   
   p_m -> top = -1 ;
   
   while ( ( c = getchar () ) != '\n' )
   {
      if ( c < '0' || c > '9' || p_m -> top > MAX )
         break ;

      p_m -> top ++ ;
      p_m -> t[ p_m -> top ] = c - '0' ;      
   }
   
   reverse( p_m -> t , p_m -> top + 1 );//颠倒次序 
   
   squeeze( p_m ); //去掉开头的0 
   
}

void clear( Map * p_m , const int from , const int to )
{
   int i ;
   
   for ( i = from - 1 ; i > to - 1; i -- )
      p_m->t[i] = 0u ;
}

void add_1( Map * p_m , const int from )
{
   int i ;
   
   p_m->t[from] ++;                             //最低位加1 
   
   for ( i = from ; i < p_m->top ; i ++ )       //进位处理 
   {
      p_m->t[i + 1] += p_m->t[i] / 10u ;
      p_m->t[i] %= 10u ;
   }
   
   if ( p_m->t[p_m->top] > 9u )                 //最高位有进位 
   {
      p_m->t[p_m->top + 1] = p_m->t[p_m->top] / 10u ;
      p_m->t[p_m->top ++ ] %= 10u ;
   }
}

int  search( const Map * p_m )
{
   int i ;
   
   for ( i = p_m->top ; i > 0  ; i-- )
   {
      if ( p_m->t[i] == p_m->t[i-1] )
         break ;
   }
   
   return i - 1 ; 
}

void find( Map * p_m )
{
   int end = 0 , b_point ;
   
   while ( ( b_point = search ( p_m ) ) > -1 ) //为-1时说明不是不重复数 
   {
      add_1( p_m , b_point );                 //重复数部分加1 
      clear( p_m , b_point , end );           //后面改为0 
      end = b_point ;                         //确定下次循环的处理范围 
   }
}

void out( const Map * p_m )
{
   for (int i = p_m -> top ; i >= 0 ; i -- )
      printf( "%u" , p_m -> t[i] );
      
   putchar('\n');            
}