通常swap(a,b),都是用中间变量
public static void Swap1(ref int a, ref intb)
{int temp =a;
a=b;
b=temp;
}
生成的IL如下(去除ref)
.maxstack 1
.locals init (
[0] int32 temp)
L_0000: ldarg.0
L_0001: stloc.0
L_0002: ldarg.1
L_0003: starg.s a
L_0005: ldloc.0
L_0006: starg.s b
L_0008: ret
如果面试官问你不适用任何第三方变量,那么可以这样
public static void Swap2(ref int a, ref intb)
{
a= a +b;
b= a -b;
a= a -b;
}
这样做,a+b可能超出范围,抛异常。所以得用位运算。
public static void Swap3(ref int a, ref intb)
{
a^=b;
b^=a;
a^=b;
}
哇,位运算高效么?计算机原理总是说位运算是最快的。没错!!!
可是,C#作为高级语言,性能跟生成的最终指令有关系,我们往往忽略了编译器生成的最终指令。
位运算一看就是三组运算,生成IL如下:
.method public hidebysig static void int32 a, int32 b)cilmanaged
{
.maxstack 8
L_0000: ldarg.0
L_0001: ldarg.1
L_0002: xor
L_0003: starg.s a
L_0005: ldarg.1
L_0006: ldarg.0
L_0007: xor
L_0008: starg.s b
L_000a: ldarg.0
L_000b: ldarg.1
L_000c: xor
L_000d: starg.s a
L_000f: ret
}
可见,比第一种用临时变量生成的IL要多不少,所以可以得出其速度慢于temp交换。事实的性能测试,也证明了如此。
其实还有一种更为巧妙的swap
public static void Swap4(ref int a, ref intb)
{
b= a + 0 * (a =b);
}
生成的IL十分诡异:
.maxstack 8
L_0000: ldarg.0
L_0001: ldarg.1
L_0002: starg.s a
L_0004: starg.s b
L_0006: ret
奇怪,怎么a=b; b=a;就可以实现了?
好吧,其实我们又被编译器给欺骗了,最终生成的汇编指令是这样的么?
(话说,我还不知道如何看C#生成的汇编指令,不知道哪个大牛告诉一下?)
通过一番蛋疼的性能测试。
我得出一个结论:
位运算交换——慢。
temp交换——非常快。
诡异的交换——非常快。与temp不相上下,当然,百亿级的测试,还是temp微弱优势取胜。
其实,那个诡异的方法,最终也是寄存器交换操作,生成的机器指令应该和temp是一样的。当然,这是我猜测的。O(∩_∩)O哈!