一道面试排序题

百家争鸣么？我的话则会。。。

import java.util.Arrays;

public class App {

	public static void main(String[] args) {
		System.out.println(reverse(12345));
	}

	static int reverse(int... param) {
		if (param.length != 2)
			param = Arrays.copyOf(new int[] { param[0] }, 2);
		return param[0] > 10 ? reverse(param[0] / 10, param[1] * 10 + param[0]
				% 10) : param[1] * 10 + param[0] % 10;
	}
}

执行1亿次总耗时19.719秒。
算法方面，前面已经有人和我的做法一样了。
只是对参数的处理上。。。呃～你们知道的。

比我想的要好！我的：
public class DescInt {
    static StringBuffer sb = new StringBuffer();
    public static void transInt(int inputNum){
        int divNum = inputNum / 10;
        int leftNum = inputNum % 10;
        if(divNum != 0){
            sb.append(leftNum);
            transInt(divNum);
        }else{
            if(leftNum != 0){
                sb.append(leftNum);
            }
        }
    }
    public static void main(String args[]){
        transInt(100);
        System.out.println(sb.toString());
    }
}

我也试试：
public static void main(String[] args) {
System.out.println(f(12345, 0));
}

public static int f(int i, int j) {
return i / 10 != 0 ? f(i / 10, (i % 10 + j) * 10) : i+j;
}

执行1亿次总耗时3491毫秒。

	public static void main(String[] args)
	{
		long before = System.nanoTime();
		for(int i=0; i<100000000; i++)
		getNextInt(12345, 0);
		System.out.println(System.nanoTime() - before);
	}
	
	public static int getNextInt(int original, int result)
	{
		int nextOriginal = original/10;
		result = result+original%10;
		if(nextOriginal<=0)
			return result;
		else
			return getNextInt(nextOriginal, result*10);
	}

执行一亿次3242毫秒

private static String inversion(int high ) {
    return high<10?""+high:(high%10)+inversion(high/10);

}

 

正解

BS那出题人。程序应该是能实现功能且简单高效就行了，搞那么多条条框框干啥。
8成是他平时开发时遇到这个问题，自己想了很久，找到一个自认为非常好的方法，想拿出来炫耀一下，你写得不好时，他指出你的不足，然后把自己的做法拿出来炫耀。

现实生活中可以用以下简单代码实现，且支持较大的数字。比如
12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901反转成
10987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321
我就不信那种通过递归求余再反向求积的算法比这种高效。


public void reverse(BigInteger num){
StringBuilder sb=new StringBuilder(num.toString());
sb.reverse();
System.out.ptintln(sb.toString());
}

/**
* 题目：写一个方法，要求参数int类型，如：传入一个12345，返回结果54321。
* 面试的时候遇到这个题，还有个要求，是方法体内的代码不能超过8行，而且还要用递归。
* 
* @author Turing
* 
*/
import java.util.Arrays;

public class B {
static int index = 0;
static int[] result = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };

public static void main(String[] arg) {
int num = 5340323;
// TODO Auto-generated method stub
System.out.println("Before: " + num);
System.out.print("After:  ");
sortInt(num);
for (int i = result.length - 1; result[i] != -1; i--) {
System.out.print(result[i]);
}
}

private static void sortInt(int num) {
// TODO Auto-generated method stub
if (num > 0) {
int temp = num % 10;
num = num / 10;
result[index++] = temp;
sortInt(num);
}
if (num == 0) {
Arrays.sort(result);
}
}
}

这个算法，牛B了。。。

return number>=10? reverse(number/10, number%10 + result * 10):result * 10 + number;