# Leetcode

**Repository Path**: shine_rainbow/leetcode

## Basic Information

- **Project Name**: Leetcode
- **Description**: Leetcode 刷题笔记.
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2021-06-15
- **Last Updated**: 2021-11-03

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# LeetCode刷题目录
### 1. 两数之和
>给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 
 //
 // 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 

>// 示例 1： <br/>
 //输入：nums = [2,7,11,15], target = 9 <br/>
 //输出：[0,1] <br/>
 //解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。



> // 示例 2： <br/>
 //输入：nums = [3,2,4], target = 6 <br/>
 //输出：[1,2]<br/>
> // 示例 3： <br/>
 //输入：nums = [3,3], target = 6 <br/>
 //输出：[0,1] <br/>

#### 解题思路 
- 暴力法,在数组中遍历各个元素,判断数组中的两个元素匹配之和是否与target相同
``` java
public static int[]  twoSum(int[] nums, int target) {
        for(int i=0;i<nums.length-1;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]+nums[j] == target){
                    return new int[]{i,j};
                }
            }
        }
        return null;
    }
```
- HashMap暂存法.可以将target-nums[i]作为判断依据,如果在map中发现了结果值,将结果值返回.

``` java
public static int[] twoSum(int[] nums,int target){
        Map<Integer, Integer> map = new HashMap<>();
        for(int i=0;i<nums.length;i++){
            int temp = target - nums[i];
            if(map.containsKey(temp)){
                return new int[]{map.get(temp),i};
            }
            map.put(nums[i],i);
        }
        return null;
    }
```
### 7.整数反转
>给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。 如果反转后整数超过 32 位的有符号整数的范围 [−2^31, 2^31 − 1] ，就返回 0。 
假设环境不允许存储 64 位整数（有符号或无符号）。

#### 解题思路
- 暴力法,使用StringBuilder将输入的数字转换为String,倒序获取每一个元素。
  - 注意：溢出情况及负数.

```java
   class Solution {
       public static int reverse(int x) {
           if(x == 0){
               return 0;
           }
           StringBuilder stringBuilder = new StringBuilder();
           if(x>0){
               char[] chars = String.valueOf(x).toCharArray();
               for(int i= chars.length-1;i>=0;i--){
                   stringBuilder.append(chars[i]).toString();
               }
               Long value = Long.valueOf(stringBuilder.toString());
               Integer maxValue = Integer.MAX_VALUE;
               if(value.compareTo(maxValue.longValue())>=0){
                   return 0;
               }else {
                   return value.intValue();
               }
   
   
           }else{
               char[] chars = String.valueOf(x).substring(1).toCharArray();
               for(int i= chars.length-1;i>=0;i--){
                   stringBuilder.append(chars[i]);
               }
               Long value = Long.valueOf(stringBuilder.toString());
               Integer maxValue = Integer.MAX_VALUE;
               if(value.compareTo(maxValue.longValue())>=0){
                   return 0;
               }else {
                   return Integer.valueOf(new StringBuilder("-").append(value).toString());
               }
           }
       }
   }
   
   //runtime:4 ms
   //memory:35.9 MB     
``` 
- 使用取余,逐个获取每一位的元素.注意溢出.
  对于负数的情况,-reverse(-num).
```java
class Solution {
  public static int reverse(int x){
        //防止-reverse(-x)出错
        if(x == Integer.MIN_VALUE){
            return 0;
        }
        if(x<0){
            return -reverse(-x);
        }
        int res = 0;
        while (x!=0){
            if(res > 214748364){
                return 0;
            }
            int temp = x % 10;
            res = res * 10 + temp;
            x = x/10;
        }
        return res ;
    }
}
//runtime:1 ms
//memory:35.6 MB
```
### 9.回文数
>给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
#### 解题思路
- 直接判断法.<br/>
对回文数使用双端指针的方式,同时进行取值对比.
```java
class Solution {
    public static boolean isPalindrome(int x) {
        String numStr = String.valueOf(x);
        //如果负数,直接输出false
        if("-".equals(numStr.substring(0,1))){
            return false;
        }
        char[] chars = numStr.toCharArray();
        int leftIndex = 0;
        int rightIndex = chars.length-1;
        while (leftIndex<rightIndex){
            if(chars[leftIndex] == chars[rightIndex]){
                System.out.println(chars[leftIndex] +" compare"+chars[rightIndex]);
                leftIndex ++;
                rightIndex --;
            }else {
                return false;
            }
        }
        return true;

    }
}

//runtime:131 ms
//memory:38.6 MB

```
- 反转法 
转换为整数反转,如果是回文数,反转后的数字与原数字相等
```java
class Solution {
    public static boolean isPalindrome(int x) {
        //排除负数
        if(x <0){
            return false;
        }
        //记录x原始值
        int temp = x ;

        long y = 0L;
        while (x!=0){
            y = y*10 + x%10;
            x = x/10;
        }
        return temp == y;
    }
}

//runtime:12 ms
//memory:37.7 MB
```