一道面试排序题

/**
* @param source
* @param ret初始为""
* 测试递归(将数据翻转)
*/
private static String recursive(int source, String ret){
if(source < 10){
return ret+source;
}else{
ret += source%10;
source = source/10;
return recursive(source,ret);
}
}


public static void main(String[] args) throws IOException{
int i = 12345;
String ret = "";
System.out.println("reverse string: " + recursive(i,ret));
}

这个应该是题目所要求的递归吧。

	//12345 -> 54321
	//-12345 -> 54321-
	public void reverse(int i){
		if(Math.abs(i) >= 10){
			System.out.print(Math.abs(i%10));
			reverse(i/10);
		} else {
			System.out.print(Math.abs(i));
			System.out.println(i>=0?"":"-");
		}
	}

private String someMethod(int n){

if (n < 0){
int m = Math.abs(n);
return m < 10 ? "-" + m : "-" + (m % 10) + someMethod(m/10);
}
return n < 10 ? String.valueOf(n) : (n % 10) + someMethod(n/10);
}

	/**
	 * 递归翻转
	 * @param source
	 * @param index
	 */
	public static void recursiveTurnover(String source,int index){
		char[] a = source.toCharArray();
		if(index<=a.length/2){
			System.out.print(a[(a.length-1)-index]);
			a[(a.length-1)-index] = a[index];
			recursiveTurnover(new String(a), index+=1);
		}else{
			System.out.print(new String(a,(a.length/2+1),a.length-(a.length/2+1)));
		}
	}

楼上的是正解

static int reverse(int num){
		if(num<10){
			return num;
		}
		int decimal = (int)Math.pow(10, (int)Math.log10(num));
		int first = num /decimal;
		return first + reverse(num-first*decimal)*10;
	}
	
static int reverse2(int num){
		if(num<10){
			return num;
		}
		return num %10 *(int)Math.pow(10, (int)Math.log10(num)) + reverse2(num/10);
}

public static void main(String[] args) {
		long before,after;
		before = System.currentTimeMillis();
		for(long i=0;i<1000000;i++)reverse(12345);
		after = System.currentTimeMillis();
		System.out.printf("time interval : %d\n",after-before);
		before = System.currentTimeMillis();
		for(long i=0;i<1000000;i++)reverse2(12345);
		after = System.currentTimeMillis();
		System.out.printf("time interval : %d\n",after-before);
}

两种算法比了下第二种稍快。

  public void reverseInt(int i) {
    if (i < 10) {
      System.out.print(i);
      return;
    }
    System.out.print(i % 10);
    reverseInt(i / 10);
  }

	public static int reverseInt(int number) {
		if (number > 10) {
			String aString = new Double((double) number / 10).toString();
			Integer aInteger = Integer.parseInt(aString.substring(aString.indexOf(".") + 1));
			aString = aString.substring(0, aString.indexOf("."));

			return (int) (aInteger * Math.pow(10, aString.length())) + reverseInt(Integer.parseInt(aString));
		} else {
			return number;
		}
	}

   厉害

public static void main(String[] args) {

    System.out.println(reverse(12345, 0));
  }


********
  public static int reverse(int n, int pre){
    if(n / 10 == 0){
      return 10 * pre + n;
    }
    return reverse(n / 10, pre * 10 + n % 10);
  }


整这么复杂干什么，还用String，java的String效率很低的