LeetCode07：Reverse Integer

原题目：

Reverse digits of an integer.

Example1: x = 123, return 321

Example2: x = -123, return -321

翻转输入的整数

算法分析：

算法1：

将整数转化为字符串，通过翻转字符串来实现数字的翻转。

算法2：

将整数放入字符数组中，通过从尾到头复制数组，来实现字符串的翻转。

算法3：

时间复杂度O(logn),空间复杂度O(1)。考虑：1.负数的情况；2.溢出的情况（正溢出&&负溢出）

                     通过for(; t > 0; t /= 10)

                        r = r*10 + t%10;        来实现数字的翻转，巧妙！

遇到问题及解决方法：

1.替换字符串中的指定字符： String  tmpstring  =  str .replaceAll( "-" ,  "" );             //通过replaceAll("-", "")来替换负号

2.调用reverse()函数来翻转字符串： str  =  stringbuf .reverse().toString();                //翻转字符串

3.将字符串转化为整数： res  = Long.parseLong( str )*(-1);

4.判断数字是否越界： if (res > Integer.MAX_VALUE || res < Integer.MIN_VALUE){        //判断是否越界

5.将字符数组转化为字符串： String  tmp  = String. valueOf ( newarr );                             //将字符数组转化为字符串

6.删除末尾字符： String  tmpstring  =  tmp .substring(0,  tmp .length()-1);              //删除末尾字符

错误代码：

 错误原因：没有考虑溢出的情况

LeetCode提交源码：

算法1：

   
   
public int reverse(int x){
		String str = x + "";							//通过在数字后加""来实现将整数转化为字符串
		long result;
		char[] arr = new char[str.length()];			//原字符数组
		char[] newarr = new char[str.length()];			//用于存放翻转后的字符
		arr = str.toCharArray();
		if(x < 0){
			for(int j = str.length() - 1,i = 0; j > 0; j--){
				newarr[i] = arr[j];						//将原字符数组中的字符从尾到头输出到新字符数组中
				i++;
			}
			String tmp = String.valueOf(newarr);							//将字符数组转化为字符串
			String tmpstring = tmp.substring(0, tmp.length()-1); 			//删除末尾字符
		//	System.out.println("tmpstring=" + tmpstring + "length=" + tmpstring.length());
			result = Long.parseLong(tmpstring)*(-1);						//将字符串转化为长整型整数
		}
		else{
			for(int i = 0; i < str.length(); i++){
				newarr[i] = arr[i]; 
			}
			String tmp = String.valueOf(newarr);		//将字符数组转化为字符串
			System.out.println("tmp=" + tmp);
			result = Long.parseLong(tmp);
		}
		
		return (int)result;
	}

 

算法3：

   
   
public int reverse(int x){
		long r = 0;
		long t = x;
		t = t > 0 ? t : -t;   		//先将负数也转化为正数
		for(; t > 0; t /= 10)
			r = r*10 + t%10;		//翻转，
		
		boolean sign = x > 0? false:true;
		if(r > 2147483647 || (sign && r > Integer.MAX_VALUE)){  	//一句话判断了最大值和最小值情况
			return 0;
		}
		else{
			if(sign){
				return (int)-r; 		//将long型强制转化为int并返回，因为函数要求返回int
			}
			else{
				return (int)r;			//将long型强制转化为int并返回，因为函数要求返回int
			}
		}
	}

 

完整运行程序：

   
   
/**************************************************************      
* Copyright (c) 2016      
* All rights reserved.                   
* 版 本 号：v1.0                   
* 题目描述： Reverse Integer
* 			Reverse digits of an integer.
*			Example1: x = 123, return 321
*			Example2: x = -123, return -321
*			翻转指定的数字
* 输入描述：请输入一个整数：
*			-123456789
* 程序输出： 算法1翻转后的结果是：
*			-987654321
*			算法2翻转后的结果是：
*			-987654321
*			算法3翻转后的结果是：
*			-987654321
* 问题分析： 1.替换字符串中的指定字符：String tmpstring = str.replaceAll("-", "");            //通过replaceAll("-", "")来替换负号
*		    2.调用reverse()函数来翻转字符串：str = stringbuf.reverse().toString();                //翻转字符串
*			3.将字符串转化为整数：res = Long.parseLong(str)*(-1);
*			4.判断数字是否越界：if(res > Integer.MAX_VALUE || res < Integer.MIN_VALUE){        //判断是否越界
*			5.将字符数组转化为字符串：String tmp = String.valueOf(newarr);                            //将字符数组转化为字符串
* 			
* 算法描述：算法1：将整数转化为字符串，通过翻转字符串来实现数字的翻转。
* 		       算法2：将整数放入字符数组中，通过从尾到头复制数组，来实现字符串的翻转。
* 		       算法3：时间复杂度O(logn),空间复杂度O(1)。考虑：1.负数的情况；2.溢出的情况（正溢出&&负溢出）
* 					通过for(; t > 0; t /= 10)
*						r = r*10 + t%10;		来实现数字的翻转，巧妙！
* 完成时间：2016-11-15
***************************************************************/ 
package org.GuoGuoFighting.LeetCode07;
import java.util.Scanner;
/*算法1：
将整数转化为字符串，通过翻转字符串来实现数字的翻转。
要注意数字溢出情况*/
class SolutionMethod1{
	public int reverse(int x){
		String str = x + "";						//通过在数字后加""来实现将整数转化为字符串
		long res;
		
		if(x < 0){								 //负数情况，考虑负号
			String tmpstring = str.replaceAll("-", "");			//通过replaceAll("-", "")来替换负号
			StringBuffer stringbuf = new StringBuffer(tmpstring);
			str = stringbuf.reverse().toString();				//翻转字符串
			//res = Integer.parseInt(str)*(-1);
			res = Long.parseLong(str)*(-1);						//将字符串转化为长整型整数
		}
		else{
			StringBuffer stringbuf = new StringBuffer(str);
			str = stringbuf.reverse().toString();
		//	res = Integer.parseInt(str);
			res = Long.parseLong(str);
		}
		
		if(res > Integer.MAX_VALUE || res < Integer.MIN_VALUE){		//判断是否越界
			return 0;
		}
		return (int)res;
	}
}
/*
算法2.
将整数放入字符数组中，通过从尾到头复制数组，来实现字符串的翻转。
要考虑数字溢出的情况
*/
class SolutionMethod2{
	public int reverse(int x){
		String str = x + "";							//通过在数字后加""来实现将整数转化为字符串
		long result;
		char[] arr = new char[str.length()];			//原字符数组
		char[] newarr = new char[str.length()];			//用于存放翻转后的字符
		arr = str.toCharArray();
		if(x < 0){
			for(int j = str.length() - 1,i = 0; j > 0; j--){
				newarr[i] = arr[j];						//将原字符数组中的字符从尾到头输出到新字符数组中
				i++;
			}
			String tmp = String.valueOf(newarr);							//将字符数组转化为字符串
			String tmpstring = tmp.substring(0, tmp.length()-1); 			//删除末尾字符
		//	System.out.println("tmpstring=" + tmpstring + "length=" + tmpstring.length());
			result = Long.parseLong(tmpstring)*(-1);						//将字符串转化为长整型整数
		}
		else{
			for(int i = 0; i < str.length(); i++){
				newarr[i] = arr[i]; 
			}
			String tmp = String.valueOf(newarr);		//将字符数组转化为字符串
			System.out.println("tmp=" + tmp);
			result = Long.parseLong(tmp);
		}
		
		return (int)result;
	}
}
/*
算法3.时间复杂度O(logn),空间复杂度O(1)
	 考虑：1.负数的情况；2.溢出的情况（正溢出&&负溢出）*/
class SolutionMethod3{
	public int reverse(int x){
		long r = 0;
		long t = x;
		t = t > 0 ? t : -t;   		//先将负数也转化为正数
		for(; t > 0; t /= 10)
			r = r*10 + t%10;		//翻转，
		
		boolean sign = x > 0? false:true;
		if(r > 2147483647 || (sign && r > Integer.MAX_VALUE)){  	//一句话判断了最大值和最小值情况
			return 0;
		}
		else{
			if(sign){
				return (int)-r; 		//将long型强制转化为int并返回，因为函数要求返回int
			}
			else{
				return (int)r;			//将long型强制转化为int并返回，因为函数要求返回int
			}
		}
	}
}
public class ReverseInteger {
	public static void main(String[] args){
		System.out.println("请输入一个整数：");
		Scanner scanner = new Scanner(System.in);
		int num = scanner.nextInt();
		scanner.close();
		
		SolutionMethod1 solution1 = new SolutionMethod1();
		System.out.println("算法1翻转后的结果是：");
		System.out.println(solution1.reverse(num));
		
		
		SolutionMethod2 solution2 = new SolutionMethod2();
		System.out.println("算法2翻转后的结果是：");
		System.out.println(solution2.reverse(num));
		
		SolutionMethod3 solution3 = new SolutionMethod3();
		System.out.println("算法3翻转后的结果是：");
		System.out.println(solution3.reverse(num));
	}
}

程序运行结果：