应Alexia(minmin)网友之邀，到她的博客上看了一下她的关于“求比指定数大且最小的‘不重复数’问题”的代码(百度2014研发类校园招聘笔试题解答)，并在评论中粗略地发表了点意见。
由于感觉有些看法在评论中无法详细表达，也由于为了更详细地说明一下我的 算法：求比指定数大且最小的“不重复数”问题的高效实现 博文中没有说清楚的一些想法，并给出这个问题更加完美的代码，故制此文。欢迎Alexia(minmin)网友和其他网友指正。
Alexia(minmin)网友在其博文中对其算法思想描述得很清楚：
1. 给定N是一个正整数，求比N大的最小“不重复数”，这里的不重复是指没有两个相等的相邻位，如1102中的11是相等的两个相邻位故不是不重复数，而12301是不重复数。
算法思想：当然最直接的方法是采用暴力法，从N+1开始逐步加1判断是否是不重复数，是就退出循环输出，这种方法一般是不可取的，例如N=11000000，你要一个个的加1要加到12010101，一共循环百万次，每次都要重复判断是否是不重复数，效率极其低下，因此是不可取的。这里我采用的方法是：从N+1的最高位往右开始判断与其次高位是否相等，如果发现相等的（即为重复数）则将次高位加1，注意这里可能进位，如8921—>9021，后面的直接置为010101...形式，如1121—>1201，此时便完成“不重复数”的初步构造，但此时的“不重复数”不一定是真正的不重复的数，因为可能进位后的次高位变为0或进位后变成00，如9921—>10001，此时需要再次循环判断重新构造直至满足条件即可，这种方法循环的次数比较少，可以接受。
下面是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);
break;
}
}
}
int main()
{
int N;
while(scanf("%d", &N))
{
minNotRep(N + 1);
}
return 0;
}
我对这段代码的总体看法是，main()写的很好，因为很短，很容易看懂。
主要缺点是，main写在了源程序的后面，我个人认为这种风格欠佳——头重脚轻(参见《品悟C》p262，“贪小便宜——省略函数类型声明等问题”)。
理由是，看文章我们总是先看标题，同样的道理读代码也总是先读main()。把main()置于源代码的后部于人于己都不利于阅读。
这种写法唯一的好处是可以省写函数类型声明。这是初学者非常喜欢占的一个小便宜。但从长远以及稍微大一些规模的代码来看，这个小便宜微不足道得可以忽略不计。（我记得要么是在我以前发的博文中，要么就是在《品悟C》这本书里详细地讲过这件事。）
这段代码的另一个缺点是，minNotRep()太大。原因主要是minNotRep()这个函数不但完成了求不重复数，还顺便输出了这个不重复数。这很不好，函数的功能应该单一，而且函数应该越小越好。因此，minNotRep()不应该定义为
void minNotRep(int n);
的形式，更好一些的写法应该是返回不重复数
int minNotRep(int n);
或者
void minNotRep(int *n);
直接把原来的数改为不重复数，然后在main()中再考虑输出。
事情要一件一件地做，指望一个函数完成所有事情，代码显然不够从容，函数也必然臃肿。
所以，从整体上来说，代码这样安排为好
/*
诸函数类型声明：
输入N();
求最小不重复数();
输出();
*/
int main()
{
int N;
//输入N();
//求最小不重复数();
//输出();
return 0;
}
/*
诸函数定义：
输入N()
{
}
求最小不重复数();
{
}
输出();
{
}
*/
再来看minNotRep()函数。
在这个函数中，首先把n离散，然后将离散后的数字用一数组(int a[20])和数字的位数len表示。这个结构没有问题，很适合从高位到低位找重复数字要求(但是如果是我，则一定会把这两者构造成一个统一的数据结构。为什么？不解释。因为这是常识，)。问题在于这两个变量被放在了while(1)循环的内部，由于它们是局部auto变量，因而意味着每次循环都要重新建立这个数组和len变量。这显然是不妥的。这两个变量应该放在while(1)循环的外部，这样每次循环就不必重新建立这两个变量了。
与此类似，n的分解离散及合成也写在了while(1)循环之内，这就意味着每次循环都必须重新分解再重新合成，这也是无意义的多余动作。经与作者沟通交流发现，作者是因为没有很好地处理进位问题才不得不这样处理的。以19901212为例
首先，分解为 1、9、9、0、1、2、1、2存入数组，
while(n) { a[len++] = n % 10; n = n / 10; }
在数组中的顺序是：2 1 2 1 0 9 9 1
然后从高位到低位找重复数字
找到之后如果flag为false则加1
// 从高位开始遍历是否有重复位 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; } }
我不得不说，我很不喜欢这个flag，因为除了表现出一种别扭的思维，这里它没有别的用处。(参见flag标志什么？哦，它标志代码馊了 )这段代码完全可以这样写：
for(i = len - 1; i > 0; i--) { if(a[i] == a[i - 1] ) { a[i - 1]++; break ; } } for ( 从 i-2 到 0 ) { // 将重复位后面的位置为0101...形式 }
无论从逻辑上还是形式上都更为简洁。
关于这个flag要说的另一件事情是，它是bool类型。这种类型C语言中是没有的(C99中有_Bool类型)，作者恐怕是把C语言和C++混为一谈了。国内很多大学生都犯这个毛病，甚至专业程序员中也有很多人C和C++不分。这个错误很广泛，无疑首先是教材或书籍的责任。(参见《品悟C》p4，“C啊，多少C++假汝之名而行——C和C++不分”)
当然支持C99的编译器可以这样用，但前提是必须
#include <stdbool.h>
才行。可是在代码中我没有发现这条预处理命令。因此bool是误用无疑。
回到被打断的话题，加1之后，数组中变成了
2 1 2 1 0 10 9 1
由于作者没有及时处理这个10，所以才不得不在循环体内不断地分解与合成。其实这时只要对数组稍微处理一下，模拟一下进位，将数组改为
2 1 2 1 0 0 0 2
就用不着反复地分解、合成了。
紧接着，代码将0 0左侧的数组元素改写成了“0101...形式”：
0 1 0 1 0 0 0 2
这里的代码有两个问题。的问题是
第一，
a[i - 1] = b;
这句我认为是一个BUG。因为前面说的是a[i]与a[i-1]重复(并且有a[i - 1]++;)，所以“// 将重复位后面的位置为0101...形式”应该是从a[i-2]而不是a[i - 1]开始改。但 a[i-2]也不对，因为所在循环for(i = len - 1; i > 0; i--)中的 i 最小可以为1，所以a[i-2]存在数组越界的问题。
第二问题是，由于加1之后重复位前面可能又出现了新的重复位，所以这里的“将重复位后面的位置为0101...形式”几乎是一个无意义的操作。这个动作仅仅是在最后一次才有意义，这就是我不肯接受这种写法的原因。写代码其实和下围棋一样，任何一个高手下围棋绝对不肯走一步显而易见没有用处的“废棋”。反对直接填写“0101...”的另一个原因是，这是人“算”的，不是程序“算”的。程序员的任务是用程序发出命令让计算机去做，而不是越俎代庖地替代程序和计算机。
我在这里的写法是将重复位后面各个位置上的数字改为0。而且为了不至于反复地进行无意义地重复写0，使用了一点小技巧。这个小技巧，就评论情况来看，目前还没有人看懂。
好，评论就到这里。下面讲一下我在这里的处理。依然是以以19901212为例，在数组中的顺序是：2 1 2 1 0 9 9 1。
我首先用 end = 0 这个变量规定了重复位后面改为0的最后一位。
用b_point = search ( &map )确定最前面的重复位，在这个例子里应该是5 (199) 。然后将199加1，并在数组中模拟了进位( add_1( &map , b_point ) ; ) ，
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 ; }
(顺便说一句，这里的p_m->t[p_m->top ++ ] %= 10u ;一句一直是让我感到有些惴惴不安的，生怕“求道于盲”那样精通C语言的网友提出质疑。)
之后数组变为
2 1 2 1 0 0 0 2
然后将数组中从end到b_point-1的元素改为0(一共5个)，数组变为
0 0 0 0 0 0 0 2
最后再将b_point的值赋给end，由于每次循环修改的是从b_point-1到end之间的元素，这样下次就不会再修改数组最左面那5个元素的值了。
我的失误：
我的失算之处是，最初也被题目中的“给定任意一个正整数”中的“正整数”三个字给迷惑了。直到写完代码我才意识到，这个题目跟正整数几乎没什么关系。把输入视为一个十进制形式正整数的字符序列，不但完全满足原来问题的要求，而且不限于整数类型的范围限制。为此，重新给出可处理最多100位正整数的代码如下：
#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 () ) != '
' )
{
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('
');
}