Leetcode Push-001

1. 两数之和 ：

题目 ： https://leetcode-cn.com/problems/two-sum/

两数之和的O(n)算法

O(n)算法实现：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] ans = new int[2] ; 
        Map bt = new HashMap<>() ; 
        for (int i= 0 ;i 

2. 两数相加 ：

题目 ： https://leetcode-cn.com/problems/two-sum/

两数相加

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode ans = new ListNode() ;
        //边界情况处理
        if(l1 == null && l2 == null) return ans; 
        if(l1 == null) return l2; 
        if(l2 == null) return l1; 

        //开始构建ans指向的链表，ans是头节点
        ListNode current = ans ;
        //记录进位数
        int carry = 0 ;
        //两个链表都还有值
        while(l1 != null && l2 != null){
            int v1 = l1.val ;
            int v2 = l2.val ;
            ListNode thisNode = new ListNode( (v1 + v2 + carry)%10 ) ; 
            current.next = thisNode ; 
            current = current.next;
            l1 = l1.next;
            l2 = l2.next;
            carry = (v1 + v2 + carry)/10 ;  
        }
        //链表2有值
        while(l2 != null){
            int v2 = l2.val; 
            ListNode thisNode = new ListNode( (v2 + carry)%10 ) ; 
            current.next = thisNode ; 
            current = current.next;
            l2 = l2.next;
            carry = (v2 + carry)/10 ; 
        }
        //链表1有值
        while(l1 != null){
            int v1 = l1.val; 
            ListNode thisNode = new ListNode( (v1 + carry)%10 ) ; 
            current.next = thisNode ; 
            current = current.next;
            l1 = l1.next;      
            carry = (v1 + carry)/10 ;      
        }
        if(carry > 0) {
            ListNode thisNode = new ListNode( carry ) ; 
            current.next = thisNode ; 
            current = current.next;
        }
        ans = ans.next ;     //注意这一步
        return ans; 
    }
}

3.整数反转 ：

整数反转思路

class Solution {
    public int reverse(int x) {
        int ans = 0 ; 
        while(x != 0){
            //如果已经达到了Integer.MAX_VALUE/10的级别，那么下个迭代肯定越界了
            if(ans > Integer.MAX_VALUE/10 || ans < -1 * Integer.MAX_VALUE/10)
            {
                return 0 ;
            }
            int dig = x % 10 ; 
            x = x/10 ;
            ans = ans * 10 + dig ;
        }
        return ans ; 
    }
}

4. 字符串转换整数 (atoi)

题目地址 ： https://leetcode-cn.com/problems/string-to-integer-atoi/
该题是中等难度，我写出了思路，但是因为溢出条件测试了很久都没有通过，这里溢出时，需要注意，必须测试ans 和 Integer.MAX_VALUE/10的大小关系，不能判断相加结果与Integer.MAX_VALUE的关系，因为相加溢出后，直接值就变了。该题还有个难点，就是int的最大值是2147483647，如果加完之后等于 2147483646 那就不溢出了，所以这里判断溢出的条件是：ans > Integer.MAX_VALUE/10 || (ans == Integer.MAX_VALUE/10 && lg > 7)
下边是完整的代码 ：

class Solution {
    public int myAtoi(String s) {
        //去除空格
        String clearStr = s.trim() ;
        if(clearStr.length() == 0) return 0 ;
        //ans保存最终的数字和，flag表示输出正数还是负数
        int ans = 0 , flag = 1 , lg =0 ;
        //处理第一位为 + 或者 - 的情况
        if(clearStr.charAt(0) == '+' || clearStr.charAt(0) == '-'){
            flag = clearStr.charAt(0) == '+' ? 1:-1;
            clearStr = clearStr.substring(1) ;
        }
        char[] chList = clearStr.toCharArray() ;
        for(char p : chList){ 
            //这里的判断char是数字的字符的方法，值得记下来
            if (p >= '0' && p <= '9'){
                lg = p - 48;
                //这里的越界判断，测试了很久，需要注意
                if(ans > Integer.MAX_VALUE/10 || (ans == Integer.MAX_VALUE/10 && lg > 7)){
                    ans = flag == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE ;
                    return ans;
                }
                else{
                    ans = ans*10 + lg ;
                }
            }
            else{
                //非数字字符'0'~'9'直接退出了
                return ans * flag ;
            }
        }
        return ans*flag ;
    }
}

5. 回文数

题目地址： https://leetcode-cn.com/problems/palindrome-number/
这个题目非常简单，做了一次通过。核心是判断回文字符串的一个方法，我的方法是将String转化为Char Array，从第一个元素迭代到中间，分别比对 i 和 length-i 如果不一样就不是回文，否则是回文。

class Solution {
    public boolean isPalindrome(int x) {
        if (x < 0) return false ;
        char[] cx = String.valueOf(x).toCharArray() ;
        if (cx.length == 1) return true ;
        /**
         *  4444
         */
        int len = cx.length;
        int mid = cx.length/2;
        boolean flag = true;
        for (int i =0;i