原题目:
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));
}
}
程序运行结果: