又一面试题,又一伪命题 - 关于C中字符数组逆序的方法

最新推荐文章于 2022-02-25 20:00:37 发布

rednaxelafx

最新推荐文章于 2022-02-25 20:00:37 发布

阅读量126

点赞数

分类专栏： Optimization C Java C# C++ 文章标签： C C++ C# 面试

Java 同时被 3 个专栏收录

86 篇文章 0 订阅

订阅专栏

38 篇文章 0 订阅

订阅专栏

C++

10 篇文章 0 订阅

订阅专栏

最近土豆同学经常去参加各种面试和笔试,而我也获益不少,得以见识到这些"题目"的诡异.这次听到的,是一个关于C语言中字符串逆序的问题.问题的核心是: 用什么办法,可以最高效的把一个char[]内容的顺序逆转? 最好是不用额外的存储空间.

我陷入了沉思.土豆同学问我的时候,一再强调既不需要用"额外的存储空间,也不需要加减或者异或运算";跟算法没关系,而是与类似语言特性的特性相关.想想也是,要逆序,无论如何也要遍历整个字符数组,不可能达到比O(n)还好的下限.但是不使用"额外"的空间...

并且,假设函数原型是类似: [color=Blue]void[/color] reverse( [color=Blue]char[/color]* str );

于是我只想到了两种可能,要么利用了数组之前(也就是例如"array[-1]"之类)的"安全空间",要么利用数组最后的"\0".当然,前者不是语言规定要有,而是编译器特定的行为,不靠谱;后者则是C语言里字符串的标准表示方式所规定的: 字符串以'\0'表示结束,可以放心利用.想到这里,土豆点头了,说面试官提出的就是这么一种[i]使用结束位置上的0来完成交换的,"既没有使用额外的存储空间,又比加减或者异或运算快的方法"[/i].

...
我随即表示了反对.我从一开始就觉得这个方法很糟糕,所以没纳入考虑范围.不过面试官的思路我们也琢磨不透就是了.下面将说明我反对这种方法的理由.

把问题稍微简单化,将上面涉及的三种方案都写成代码如下.foo1()是面试官的建议版,foo2()是使用额外临时变量版,foo3()是运算版.

#include <stdio.h>
#include <string.h>

/*
 * reverse string via the terminating zero
 */
void foo1(char* a) {
    int len = strlen(a);
    int i;

    for (i = 0; i < len / 2; i++) {
        a[len] = a[i];
        a[i] = a[len - i - 1];
        a[len - i - 1] = a[len];
    }

    a[len] = 0;
}

/*
 * reverse string via a temp variable
 */
void foo2(char* a) {
    char temp;
    int len = strlen(a);
    int i;

    for (i = 0; i < len / 2; i++) {
        temp = a[i];
        a[i] = a[len - i - 1];
        a[len - i - 1] = temp;
    }
}

/*
 * reverse string via XORs
 */
void foo3(char* a) {
    int len = strlen(a);
    int i;

    for (i = 0; i < len / 2; i++) {
        a[len - i - 1] ^= a[i];
        a[i] ^= a[len - i - 1];
        a[len - i - 1] ^= a[i];
    }
}

void main(void) {
    /* declare few strings to be put into test */
    char* a = "abcd";
    char* b = "abcde";
    char* c = "abcdef";

    /* reverse the strings above */
    foo1(a);
    foo2(b);
    foo3(c);

    /* print results */
    printf("%s\n%s\n%s\n", a, b, c);
}

inline void swap(int& a, int& b) {
    a ^= b ^= a ^= b;
}

好吧,用异或运算本来就很难支持泛型(因为不是什么都能拿来算--除非cast成指针,那没话说了),所以这里只是简单的用了int型而没用template.这么写在C++里是(很可能)没问题,但并不意味着能广泛应用到其它C-like语言中.就不提C++的pass-by-reference语法不能在C或者Java里用,关键是中间的那句:
[code]a ^= b ^= a ^= b;[/code]
要是在Java或者C#执行这句,就会发现b虽然正确的得到了a原本的值,但a在结束时却总是0.所以同一个简写,换到Java与C#中得这样写:
[code]a = (b ^= a ^= b) ^ a;[/code]
原因也是与运算顺序的规定相关.C/C++中虽然没规定表达式的运算顺序,不过规定了赋值顺序一定是右结合的,所以那个简单版的简写(多半能)行得通(行不通的例子请参考[url=http://gcc.gnu.org/bugzilla/show_bug.cgi?id=39121]这里[/url]).但Java/C#严格定义了表达式的运算顺序一定是从左向右,赋值顺序是从右向左,所以在遇到^=运算符时,需要首先将左操作数装载,再装载右操作数.这么做的后果是最左边的^=的左操作数的值是"旧"的,因而在简单版简写中等同于与自身做了异或,结果自然是0.
以JVM bytecode来说明,简单版简写编译出来是这样:
[code]iload_1 // 关键差异
iload_2
iload_1
iload_2
ixor
dup
istore_1
ixor
dup
istore_2
ixor
istore_1[/code]

而带括号的版本是这样:
[code]iload_2
iload_1
iload_2
ixor
dup
istore_1
ixor
dup
istore_2
iload_1 // 关键差异
ixor
istore_1[/code]
可以观察到注释为"关键差异"的行出现的位置的不同,导致了最终运算结果的不同.

下面具体举几个例子:
·可以用简单版简写的:
C/C++: (Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 14.00.50727.42 for 80x86测试)

#include <stdio.h>

void main(void) {
    int i = 1, j = 2, k = 3, l = 4;

    i ^= j ^= i ^= j;
    k = (l ^= k ^= l) ^ k;

    printf("i = %d, j = %d\nk = %d, l = %d",
        i, j, k, l); // i = 2, j = 1, k = 4, l = 3
}

D: (DMD 2.004测试)
[code]void main(char[][] args) {
int i = 1, j = 2, k = 3, l = 4;

i ^= j ^= i ^= j;
k = (l ^= k ^= l) ^ k;

printf("i = %d, j = %d\nk = %d, l = %d",
i, j, k, l); // i = 2, j = 1, k = 4, l = 3
}[/code]
TJS2: (KiriKiri 2.29测试)
[code][iscript]
tf.i = 1, tf.j = 2, tf.k = 3, tf.l = 4;
tf.i ^= tf.j ^= tf.i ^= tf.j;
tf.k = (tf.l ^= tf.k ^= tf.l) ^ tf.k;
[endscript]
tf.i = [emb exp="tf.i"], tf.j = [emb exp="tf.j"][r]
tf.k = [emb exp="tf.k"], tf.l = [emb exp="tf.l"][l][r]
; tf.i = 2, tf.j = 1, tf.k = 4, tf.l = 3[/code]

·需要用括号版简写的:
Java: (JRE 1.5.0/1.6.0测试)

public class Swap {
    public static void main(String[] args) {
        int i = 1, j = 2, k = 3, l = 4;

        i ^= j ^= i ^= j;
        k = (l ^= k ^= l) ^ k;

        System.out.printf("i = %d, j = %d\nk = %d, l = %d",
            i, j, k, l); // i = 0, j = 1, k = 4, j = 3
    }
}

C#: (.NET Framework 2.0测试)
[code]using System;

public class Swap {
public static void Main(string[] args) {
int i = 1, j = 2, k = 3, l = 4;

i ^= j ^= i ^= j;
k = (l ^= k ^= l) ^ k;

Console.WriteLine("i = {0}, j = {1}{2}k = {3}, l = {4}",
i.ToString(), j.ToString(), Environment.NewLine,
k.ToString(), l.ToString()); // i = 0, j = 1, k = 4, j = 3
}
}
[/code]
JavaScript: (IE6/IE7/FF2测试)
[code]<html>
<body>
<script type="text/javascript">
var i = 1, j = 2, k = 3, l = 4;
i ^= j ^= i ^= j;
k = (l ^= k ^= l) ^ k;
document.write("i = " + i + ", j = " + j + "<br />k = " + k + ", l = " + l);
// i = 0, j = 1, k = 4, j = 3
</script>
</body>
</html>[/code]

rednaxelafx

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
又一面试题,又一伪命题 - 关于C中字符数组逆序的方法

最近土豆同学经常去参加各种面试和笔试,而我也获益不少,得以见识到这些"题目"的诡异.这次听到的,是一个关于C语言中字符串逆序的问题.问题的核心是: 用什么办法,可以最高效的把一个char[]内容的顺序逆转? 最好是不用额外的存储空间.我陷入了沉思.土豆同学问我的时候,一再强调既不需要用"额外的存储空间,也不需要加减或者异或运算";跟算法没关系,而是与类似语言特性的特性相关.想想也是,要逆序...
复制链接

扫一扫