力扣题目练习

目录

两数之和

 两数相加

无重复字符的最长子串

回文数

---

两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

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

class Solution {
    public int[] twoSum(int[] nums, int target) {
      Map<Integer,Integer> hashtable= new HashMap<Integer,Integer>();
      for(int i=0;i<nums.length;i++){
          if(hashtable.containsKey(target-nums[i])){
              return new int[] {hashtable.get(target-nums[i]),i};
          }
          hashtable.put(nums[i],i);
      }
      return new int[0];
    }
}

 两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

/**
 * 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 head = new ListNode(0);
        int carry = 0;
        //一个可移动的指针，用来指向存储两个数之和的位置
        ListNode move = head;
        while(l1!=null || l2 !=null){
            int x = l1 != null ? l1.val : 0;
            int y = l2 != null ? l2.val : 0;
            int sum = x+y+carry;
            carry = sum/10;
         //计算两个数的和，此时排除超过10的请况（大于10，取余数）
         sum = sum%10;  
         //将求和数赋值给新链表的节点，
         //所以这个时候要创一个新的节点，将值赋予节点
         move.next = new ListNode (sum);   
         //将新链表的节点后移
         move = move.next;   
         //当链表l1不等于null的时候，将l1 的节点后移
         if(l1 != null){
             l1 = l1.next;}   
         //当链表l2 不等于null的时候，将l2的节点后移
         if(l2 != null){
             l2 = l2.next;
         }  
    }
         //如果最后两个数，相加的时候有进位数的时候，就将进位数，赋予链表的新节点。
        //两数相加最多小于20，所以的的值最大只能时1
        if(carry>0){
            move.next = new ListNode(carry);
        }
        //返回链表的头节点
        return head.next;
        /*
        ListNode head = new ListNode(0); 实例化pre,开辟了一个内存空间，head指向这个内存空间。
         ListNode move = head; 实例化cur，指向与pre向同的地址， 所以在move.next = new ListNode(sum); 
         这一步，操作的实际上是同一个地址的变量，每次循环这个变量都发生了改变，而pre始终指向的是这个地址
        */ 
    }
}

无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

 

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

class Solution {
    public int lengthOfLongestSubstring(String s) {
 int ans = 0;
    Map<Character,Integer> hashtable = new HashMap<>();
    for(int end = 0,start=0;end<s.length();end++){
        char m = s.charAt(end);
        if(hashtable.containsKey(m)){         start=Math.max(hashtable.get(m),start);
        }
        ans=Math.max(ans,end-start+1);
    hashtable.put(s.charAt(end),end+1);
    }
        return ans;
    }
}

回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

例如，121 是回文，而 123 不是。
 

示例 1：

输入：x = 121
输出：true

class Solution {
    public boolean isPalindrome(int x) {
        if(x<0 || (x%10==0 && x!=0)){
            return false;
        }
        int m = 0;
        while(x>m){
            m = m*10 + x%10;
            x = x/10;
        }
        return x==m || x==m/10;  
    }
}