LeetCode07：Reverse Integer

最新推荐文章于 2021-03-30 17:34:46 发布

原创最新推荐文章于 2021-03-30 17:34:46 发布 · 546 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode #面试题

LeetCode 专栏收录该内容

14 篇文章

订阅专栏

本文介绍了一种将整数进行翻转的算法实现，并详细解释了三种不同的方法：字符串翻转、字符数组翻转和数学操作。同时，讨论了如何处理负数和溢出的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

原题目：

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));
	}
}

程序运行结果：