1. 两数之和

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

  1. 给定 nums = [2, 7, 11, 15], target = 9
  2.  
  3. 因为 nums[0] + nums[1] = 2 + 7 = 9
  4. 所以返回 [0, 1]
  1.  
  1. /**
  1.      * 暴力枚举法
  1.      * @param nums
  1.      * @param target
  1.      * @return
  1.      */
  1.     public static int[] twoSum(int[] nums, int target) {
  1.         int lgn = nums.length;
  1.         for(int i = 0; i < lgn; i++){
  1.             for(int j = i + 1; j < lgn; j++){
  1.                 if(nums[i] + nums[j] == target){
  1.                     return new int[]{i, j};
  1.                 }
  1.             }
  1.         }
  1.         return new int[0];
  1.     }
  1.  
  1.     /**
  1.      * MAP 处理
  1.      * @param nums
  1.      * @param target
  1.      * @return
  1.      */
  1.     public static int[] twoSum1(int[] nums, int target) {
  1.         Map<Integer, Integer> map = new HashMap<>();
  1.         for (int i = 0; i < nums.length; i++) {
  1.             int complement = target - nums[i];
  1.             if (map.containsKey(complement)) {
  1.                 return new int[] { complement, nums[i] };
  1.             }
  1.             map.put(nums[i], i);
  1.         }
  1.         return new int[0];
  1.     }

2. 两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

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

示例：

  1. 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
  2. 输出：7 -> 0 -> 8
  3. 原因：342 + 465 = 807
  1.  
  1. /**
  1.      * 链表相应位置依次相加，最后处理进位
  1.      * @param l1
  1.      * @param l2
  1.      * @return
  1.      */
  1.     public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
  1.         ListNode head = null;
  1.         ListNode curr = null;
  1.         while (l1 != null || l2 != null){
  1.             if(l1 != null && l2 != null){
  1.                 ListNode node = new ListNode(l1.val + l2.val);
  1.                 if(curr == null && head == null) head = node;
  1.                 curr = initNode(curr, node);
  1.             }else{
  1.                 curr = initNode(curr, new ListNode(l1 != null?l1.val:l2.val));
  1.             }
  1.             l1 = l1 != null?l1.next:null;
  1.             l2 = l2 != null?l2.next:null;
  1.         }
  1.         curr = head;
  1.         while (curr != null){
  1.             if(curr.val >= 10){
  1.                 curr.val -= 10;
  1.                 if(curr.next == null){
  1.                     curr.next = new ListNode(1);
  1.                 }else {
  1.                     curr.next.val += 1;
  1.                 }
  1.             }
  1.             curr = curr.next;
  1.  
  1.         }
  1.         curr = null;
  1.         return head;
  1.     }
  1.  
  1.     public ListNode initNode(ListNode curr, ListNode newNode){
  1.         if(curr != null){
  1.             curr.next = newNode;
  1.         }
  1.         curr = newNode;
  1.         return curr;
  1.     }

3. 寻找两个有序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

  1. nums1 = [1, 3]
  2. nums2 = [2]
  3.  
  4. 则中位数是 2.0

示例 2:

  1. nums1 = [1, 2]
  2. nums2 = [3, 4]
  3.  
  4. 则中位数是 (2 + 3)/2 = 2.5
  1.  
  1. /**
  1.      * 使用两个排序数据组的归并过程
  1.      * 分别定义两个数组的遍历索引，每次对比提取相应数组的元素
  1.      * 不实际存储归并后的数据，
  1.      * 处理前半数元素即可
  1.      * @param nums1
  1.      * @param nums2
  1.      * @return
  1.      */
  1.     public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
  1.         int lgn1 = nums1.length;
  1.         int lgn2 = nums2.length;
  1.         int allLgn = lgn1 + lgn2;
  1.         int middleIndex = allLgn/2;
  1.  
  1.         int middleLeft = 0,middleRight = 0;
  1.  
  1.         int index1 = 0;
  1.         int index2 = 0;
  1.         int curr = 0;
  1.         for (int i = 0; i < middleIndex + 1; i++) {
  1.             if(index1 < lgn1 && index2 < lgn2) {
  1.                 if (nums1[index1] > nums2[index2]) {
  1.                     curr = nums2[index2];
  1.                     index2++;
  1.                 } else {
  1.                     curr = nums1[index1];
  1.                     index1++;
  1.                 }
  1.             }else if(index1 < lgn1){
  1.                 curr = nums1[index1];
  1.                 index1++;
  1.             }else if(index2 < lgn2){
  1.                 curr = nums2[index2];
  1.                 index2++;
  1.             }
  1.             if(i == middleIndex - 1){
  1.                 middleLeft = curr;
  1.             }
  1.             if(i == middleIndex){
  1.                 middleRight = curr;
  1.             }
  1.         }
  1.         if(allLgn%2 == 0){
  1.             return (middleLeft + middleRight)/2.0;
  1.         }else {
  1.             return middleRight;
  1.         }
  1.     }

4. Z 字形变换

将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 "LEETCODEISHIRING" 行数为 3 时，排列如下：

  1. L   C   I   R
  2. E T O E S I I G
  3. E   D   H   N

之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："LCIRETOESIIGEDHN"。

请你实现这个将字符串进行指定行数变换的函数：

  1. string convert(string s, int numRows);

示例 1:

  1. 输入: s = "LEETCODEISHIRING", numRows = 3
  2. 输出: "LCIRETOESIIGEDHN"

示例 2:

  1. 输入: s = "LEETCODEISHIRING", numRows = 4
  2. 输出: "LDREOEIIECIHNTSG"
  3. 解释:
  4.  
  5. L     D     R
  6. E   O E   I I
  7. E C   I H   N
  8. T     S     G
  1.  
  1. /**
  1.      * 定义目标行数个链表，如示例，每次中间间隔的 numRows - 2 个列表逐个填充一个值
  1.      * 便利给定的字符串，依次处理，直到末尾
  1.      * @param s
  1.      * @param numRows
  1.      * @return
  1.      */
  1.     public static String convert(String s, int numRows) {
  1.         if(numRows == 1){
  1.             return s;
  1.         }
  1.         String result = "";
  1.         if(numRows == 2){
  1.             result = "";
  1.             for (int i = 0; i < s.length(); i = i + 2) {
  1.                 result += s.charAt(i);
  1.             }
  1.             for (int i = 1; i < s.length(); i = i + 2) {
  1.                 result += s.charAt(i);
  1.             }
  1.             return result;
  1.         }
  1.         int middleCount = numRows - 2;
  1.         List[] all = new LinkedList[numRows];
  1.         for (int i = 0; i < numRows; i++) {
  1.             all[i] = new LinkedList<>();
  1.         }
  1.         int sIndex = 0;
  1.         int step = 0;
  1.         while (sIndex < s.length()){
  1.             for (int i = 0; i < numRows; i++) {
  1.                 if(sIndex == s.length()) break;
  1.                 all[i].add(s.charAt(sIndex));
  1.                 sIndex++;
  1.             }
  1.             for (int j = numRows - 2; j > 0 ; j--) {
  1.                 if(sIndex == s.length()) break;
  1.                 all[j].add(s.charAt(sIndex));
  1.                 sIndex++;
  1.             }
  1.             step = step + middleCount;
  1.         }
  1.         for (int i = 0; i < numRows; i++) {
  1.             for (int j = 0; j < all[i].size(); j++) {
  1.                 result += all[i].get(j);
  1.             }
  1.         }
  1.         return result;
  1.     }

5. 整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

  1. 输入: 123
  2. 输出: 321

示例 2:

  1. 输入: -123
  2. 输出: -321

示例 3:

  1. 输入: 120
  2. 输出: 21

注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231,  231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

  1.  
  1. /**
  1.      * 数据范围判断
  1.      * @param x
  1.      * @return
  1.      */
  1.     public static int reverse(int x) {
  1.         double result = 0;
  1.         while (x != 0){
  1.             result = result * 10 + x%10;
  1.             if (result > Integer.MAX_VALUE) return 0;
  1.             if (result < Integer.MIN_VALUE) return 0;
  1.  
  1.             x = x/10;
  1.         }
  1.         return (int) result;
  1.     }

6. 回文数

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

  1. /**
  1.      * 转化为字符串，一次便利，首末对称位置对比
  1.      * @param x
  1.      * @return
  1.      */
  1.     public static boolean isPalindrome(int x) {
  1.         String s = String.valueOf(x);
  1.         int lgn = s.length();
  1.         for (int i = 0,j = lgn -1; i <= j; i++,j--){
  1.             if(s.charAt(i) == s.charAt(j)){
  1.                 continue;
  1.             }else {
  1.                 return false;
  1.             }
  1.         }
  1.         return true;
  1.     }

7. 盛最多水的容器

给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2。

  1. /**
  1.      * 枚举
  1.      * @param height
  1.      * @return
  1.      */
  1.     public static int maxArea(int[] height) {
  1.         int area = 0, lgn = height.length;
  1.         if(lgn < 2) return 0;
  1.  
  1.         for (int i = 0; i < lgn; i++) {
  1.             for (int i1 = i + 1; i1 < lgn; i1++) {
  1.                 int tmpArea = (height[i]>height[i1]?height[i1]:height[i]) * (i1 - i);
  1.                 if(tmpArea > area){
  1.                     area = tmpArea;
  1.                 }
  1.             }
  1.         }
  1.         return area;
  1.     }
  1.  
  1.     /**
  1.      * 双指针
  1.      * @param height
  1.      * @return
  1.      */
  1.     public static int maxArea2(int[] height) {
  1.         int area = 0, lgn = height.length;
  1.         if(lgn < 2) return 0;
  1.  
  1.         for (int i = 0, j = lgn - 1; i < j; ) {
  1.             int tmpArea = (height[i]>height[j]?height[j]:height[i]) * Math.abs(j - i);
  1.             if(tmpArea > area){
  1.                 area = tmpArea;
  1.                 i++;//正方向前进一步，避免反方向遍历时，重复比较
  1.             }else {
  1.                 j--;//反方向前进一步，避免正方向遍历时，重复比较
  1.             }
  1.         }
  1.         return area;
  1.     }

8. 整数转罗马数字

罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

  1. 字符          数值
  2. I             1
  3. V             5
  4. X             10
  5. L             50
  6. C             100
  7. D             500
  8. M             1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

  • I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
  • X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
  • C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。

给定一个整数，将其转为罗马数字。输入确保在 1 到 3999 的范围内。

  1. public static String intToRoman(int num) {
  1.         if(num > 3999) return "";
  1.         if(num/1000 > 0){
  1.             return dealQianWei(num);
  1.         }else if(num/100 > 0){
  1.             return dealBaiWei(num);
  1.         }else if(num/10 > 0){
  1.             return dealShiWei(num);
  1.         }else {
  1.             return dealGeWei(num);
  1.         }
  1.     }
  1.  
  1.     /**
  1.      * 千位
  1.      * @param num
  1.      * @return
  1.      */
  1.     public static String dealQianWei(int num){
  1.         return countStr(num/1000, "M") + dealBaiWei(num%1000);
  1.     }
  1.  
  1.     /**
  1.      * 百位
  1.      * @param num
  1.      * @return
  1.      */
  1.     public static String dealBaiWei(int num){
  1.         int bc = num/100;
  1.         if(bc == 9) return "CM" + dealShiWei(num % 100);
  1.         if(bc == 4) return "CD" + dealShiWei(num % 100);
  1.         int fbc = num/500;
  1.         num = num%500;
  1.         return countStr(fbc, "D") + countStr(num/100, "C") + dealShiWei(num%100);
  1.     }
  1.  
  1.     /**
  1.      * 十位
  1.      * @param num
  1.      * @return
  1.      */
  1.     public static String dealShiWei(int num){
  1.         int tens = num/10;
  1.         if(tens == 9) return "XC" + dealGeWei(num % 10);
  1.         if(tens == 4) return "XL" + dealGeWei(num % 10);
  1.         int ftens = num/50;
  1.         num = num%50;
  1.         return countStr(ftens, "L") + countStr(num/10, "X") + dealGeWei(num%10);
  1.     }
  1.  
  1.     /**
  1.      * 个位
  1.      * @param num
  1.      * @return
  1.      */
  1.     public static String dealGeWei(int num){
  1.         if(num == 9) return "IX";
  1.         if(num == 4) return "IV";
  1.         if(num >= 5) return "V" + dealGeWei(num % 5);
  1.         return countStr(num, "I");
  1.     }
  1.  
  1.     public static String countStr(int count, String num){
  1.         if(count == 0) return "";
  1.  
  1.         String result = "";
  1.         for (int i = 0; i < count; i++) {
  1.             result += num;
  1.         }
  1.         return result;
  1.     }

9. 三数之和

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

注意：利用上面的两数值和

  1. public static List<List<Integer>> threeSum(int[] nums) {
  1.         if(nums == null || nums.length < 3) return new ArrayList();
  1.         Set<List<Integer>> result = new HashSet<>();
  1.         List<Integer> numList = new ArrayList();
  1.         for (int num : nums) {
  1.             numList.add(num);
  1.         }
  1.  
  1.         for (Integer num : numList) {
  1.             List<Integer> copy = new ArrayList();
  1.             copy.addAll(numList);
  1.             copy.remove(num);
  1.             List<int[]> tmp = twoSum(copy, -num);
  1.             if(tmp.size()>0){
  1.                 for (int[] ints : tmp) {
  1.                     List<Integer> list = new ArrayList(){{add(num);add(ints[0]);add(ints[1]);}};
  1.                     Collections.sort(list);
  1.                     result.add(list);
  1.                 }
  1.             }
  1.         }
  1.  
  1.         return new ArrayList(result);
  1.     }
  1.  
  1.     public static List<int[]> twoSum(List<Integer> nums, int target) {
  1.         List<int[]> result = new ArrayList();
  1.         Map<Integer, Integer> map = new HashMap<>();
  1.         for (int i = 0; i < nums.size(); i++) {
  1.             int complement = target - nums.get(i);
  1.             if (map.containsKey(complement)) {
  1.                 result.add(new int[] { complement, nums.get(i) });
  1.             }
  1.             map.put(nums.get(i), i);
  1.         }
  1.         return result;
  1.     }

10. 最接近的三数之和

给定一个包括 n 个整数的数组 nums和 一个目标值 target。找出 nums中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

  1. 例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.
  2.  
  3. 与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).
  1.  
  1. public static int threeSumClosest(int[] nums, int target) {
  1.         int min = Integer.MAX_VALUE;
  1.         int ele1 = 0, ele2 = 0, ele3 = 0;
  1.         for (int i = 0; i < nums.length; i++) {
  1.             for (int i1 = 0; i1 < nums.length; i1++) {
  1.                 if (i1 == i) continue;
  1.                 for (int i2 = 0; i2 < nums.length; i2++) {
  1.                     if (i2 == i1 || i2 == i) continue;
  1.                     int sum = Math.abs(nums[i] + nums[i1] + nums[i2] - target);
  1.                     if (sum < min) {
  1.                         min = sum;
  1.                         ele1 = nums[i];
  1.                         ele2 = nums[i1];
  1.                         ele3 = nums[i2];
  1.                     }
  1.                 }
  1.             }
  1.         }
  1.         return ele1 + ele2 + ele3;
  1.     }

11. 缺失的第一个正数

给定一个未排序的整数数组，找出其中没有出现的最小的正整数。

示例 1:

  1. 输入: [1,2,0]
  2. 输出: 3

示例 2:

  1. 输入: [3,4,-1,1]
  2. 输出: 2

示例 3:

  1. 输入: [7,8,9,11,12]
  2. 输出: 1
  1.  
  1. /**
  1.      * 数组操作
  1.      * @param nums
  1.      * @return
  1.      */
  1.     public static int firstMissingPositive(int[] nums) {
  1.         int max = 0;
  1.         for (int i = 0; i < nums.length; i++) {
  1.             if(nums[i] < 0) continue;
  1.             if(nums[i] > max){
  1.                 max = nums[i];
  1.             }
  1.         }
  1.  
  1.         max = max == Integer.MAX_VALUE?max:max + 2;
  1.         for (int i = 1; i < max; i++) {
  1.             if(contains(nums, i)) continue;
  1.             return i;
  1.         }
  1.         return max + 1;
  1.     }
  1.  
  1.     public static boolean contains(int[] nums, int ele){
  1.         for (int i = 0; i < nums.length; i++) {
  1.             if(nums[i] == ele) return true;
  1.         }
  1.         return false;
  1.     }
  1.  
  1.     /**
  1.      * map操作
  1.      * @param nums
  1.      * @return
  1.      */
  1.     public static int firstMissingPositive1(int[] nums) {
  1.         Map<Integer, Integer> vs = new HashMap<>();
  1.         int max = 0;
  1.         for (int i = 0; i < nums.length; i++) {
  1.             if(nums[i] < 0) continue;
  1.             if(nums[i] > max){
  1.                 max = nums[i];
  1.             }
  1.             vs.put(nums[i], i);
  1.         }
  1.  
  1.         max = max == Integer.MAX_VALUE?max:max + 2;
  1.         for (int i = 1; i < max; i++) {
  1.             if(vs.get(i) != null) continue;
  1.             return i;
  1.         }
  1.         return max + 1;
  1.     }

12. 接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 感谢 Marcos 贡献此图。

示例:

  1. 输入: [0,1,0,2,1,0,1,3,2,1,2,1]
  2. 输出: 6
  1.  
  1. /**
  1.      * 分割
  1.      * @param height
  1.      * @return
  1.      */
  1.     public static int trap(int[] height) {
  1.         //最大索引位置
  1.         int maxIndex = findMax(height);
  1.  
  1.         int lsubMaxindex = maxIndex, rsubMaxIndex = maxIndex;
  1.         int area = 0;
  1.  
  1.         //左边处理
  1.         while (lsubMaxindex > 0){
  1.             int tmpMax = lsubMaxindex;
  1.             lsubMaxindex = findMax(Arrays.copyOfRange(height, 0, tmpMax));
  1.             area += height[lsubMaxindex] * (tmpMax - lsubMaxindex - 1);
  1.             for (int i = lsubMaxindex + 1; i < tmpMax; i++) {
  1.                 area -= height[i] * 1;
  1.             }
  1.         }
  1.  
  1.         //右边处理
  1.         while (rsubMaxIndex < height.length - 1){
  1.             int tmpMax = rsubMaxIndex;
  1.             rsubMaxIndex = tmpMax + findMax(Arrays.copyOfRange(height, tmpMax + 1, height.length)) + 1;
  1.             area += height[rsubMaxIndex] * (rsubMaxIndex - tmpMax - 1);
  1.             for (int i = tmpMax + 1; i < rsubMaxIndex; i++) {
  1.                 area -= height[i] * 1;
  1.             }
  1.         }
  1.  
  1.         return area;
  1.     }
  1.  
  1.     public static int findMax(int[] nums){
  1.         int max = 0, maxIndex = 0;
  1.         for (int i = 0; i < nums.length; i++) {
  1.             if(nums[i] > max){
  1.                 max = nums[i];
  1.                 maxIndex = i;
  1.             }
  1.         }
  1.         return maxIndex;
  1.     }

13. 字符串相乘

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

示例 1:

  1. 输入: num1 = "2", num2 = "3"
  2. 输出: "6"

示例 2:

  1. 输入: num1 = "123", num2 = "456"
  2. 输出: "56088"

说明：

  1. num1 和 num2 的长度小于110。
  2. num1 和 num2 只包含数字 0-9。
  3. num1 和 num2 均不以零开头，除非是数字 0 本身。
  4. 不能使用任何标准库的大数类型（比如 BigInteger）或直接将输入转换为整数来处理。
  1. public static String multiply(String num1, String num2) {
  1.         if(num1 == null || num2 == null || "".equals(num1) || "".equals(num2) || "".equals(num1) || "".equals(num2)) return String.valueOf(0);
  1.         int lgn1 = num1.length(), lgn2 = num2.length();
  1.         int[] result = new int[lgn1 + lgn2];
  1.  
  1.         int resultIndex = result.length - 1;
  1.         for (int i = lgn1 - 1; i > -1 ; i--) {
  1.             int first = Integer.parseInt(String.valueOf(num1.charAt(i)));
  1.             int innerIndex = 0;
  1.             for (int j = lgn2 - 1; j > -1 ; j--) {
  1.                 int second = Integer.parseInt(String.valueOf(num2.charAt(j)));
  1.                 int plus = first * second;
  1.                 result[resultIndex - innerIndex] += plus%10;
  1.                 if(plus >= 10) {
  1.                     result[resultIndex - innerIndex - 1] += plus / 10;
  1.                 }
  1.                 innerIndex++;
  1.             }
  1.             resultIndex--;
  1.         }
  1.  
  1.         //处理进位
  1.         StringBuilder sb = new StringBuilder();
  1.         for (int i = result.length - 1; i >= 0; i--) {
  1.             if(result[i]>=10) {
  1.                 result[i - 1] += result[i]/10;
  1.                 result[i] %= 10;
  1.             }
  1.         }
  1.         //提取有效位
  1.         boolean start = false;
  1.         for (int i = 0; i < lgn1 + lgn2 ; i++) {
  1.             if(!start && result[i] != 0){
  1.                 start = true;
  1.             }
  1.             if(start){
  1.                 sb.append(result[i]);
  1.             }
  1.         }
  1.         return sb.toString();
  1.     }

14. 跳跃游戏 II

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

示例:

  1. 输入: [2,3,1,1,4]
  2. 输出: 2
  3. 解释: 跳到最后一个位置的最小跳跃数是 2。   从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

说明:

假设你总是可以到达数组的最后一个位置。

  1. /**
  1.      * 枚举遍历
  1.      * @param nums
  1.      * @return
  1.      */
  1.     public static int jump(int[] nums) {
  1.         if(nums == null || nums.length == 1) return 0;
  1.         if(nums.length == 2) return 1;
  1.  
  1.         int steps = Integer.MAX_VALUE/2;
  1.         int initStep = 1;
  1.         if(nums[0] >= nums.length - 1) return 1;
  1.         if(nums[0] == 0) return steps;
  1.  
  1.         while (initStep <= nums[0]){
  1.             int subNeedStep = jump(Arrays.copyOfRange(nums, initStep, nums.length));
  1.             if(subNeedStep + 1 < steps){
  1.                 steps = subNeedStep + 1;
  1.             }
  1.             initStep++;
  1.         }
  1.         return steps;
  1.     }
  1.  
  1.     /**
  1.      * 每次选择 和下一跳（最大跳值）之和最远的=》递归处理
  1.      * @param nums
  1.      * @return
  1.      */
  1.     public static int jump2(int[] nums) {
  1.         if(nums == null || nums.length == 1) return 0;
  1.         if(nums.length == 2) return 1;
  1.  
  1.         int steps = Integer.MAX_VALUE/2;
  1.         int initStep = nums[0];
  1.         if(nums[0] >= nums.length - 1) return 1;
  1.         if(nums[0] == 0) return steps;
  1.  
  1.         int maxSum = 0;
  1.         int fromStep = 1;
  1.         while (initStep > 0){
  1.             if(initStep + nums[initStep] > maxSum){
  1.                 fromStep = initStep;
  1.                 maxSum = initStep + nums[initStep];
  1.             }
  1.             initStep--;
  1.         }
  1.         steps = 1 + jump2(Arrays.copyOfRange(nums, fromStep, nums.length));
  1.         return steps;
  1.     }

15. 全排列

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

  1. 输入: [1,2,3]
  2. 输出:
  3. [
  4.   [1,2,3],
  5.   [1,3,2],
  6.   [2,1,3],
  7.   [2,3,1],
  8.   [3,1,2],
  9.   [3,2,1]
  10. ]
  1.  
  1. /**
  1.      * 递归处理
  1.      * @param nums
  1.      * @return
  1.      */
  1.     public static List<List<Integer>> permute(int[] nums) {
  1.         List<List<Integer>> result = new ArrayList();
  1.         if(nums.length == 1) {
  1.             result.add(new ArrayList(){{add(nums[0]);}});
  1.             return result;
  1.         }
  1.         for (int num : nums) {
  1.             int[] tmp = new int[nums.length - 1];
  1.             int index = 0;
  1.             for (int i = 0; i < nums.length; i++) {
  1.                 if(num == nums[i]) continue;
  1.                 tmp[index] = nums[i];
  1.                 index++;
  1.             }
  1.             List<List<Integer>> sub = permute(tmp);
  1.             sub.stream().forEach(item->item.add(num));
  1.             result.addAll(sub);
  1.         }
  1.         return result;
  1.     }

给定一个可包含重复数字的序列，返回所有不重复的全排列。

示例:

  1. 输入: [1,1,2]
  2. 输出:
  3. [
  4.   [1,1,2],
  5.   [1,2,1],
  6.   [2,1,1]
  7. ]
  1.  
  1. /**
  1.      * 递归处理
  1.      * Set 处理重复
  1.      * @param nums
  1.      * @return
  1.      */
  1.     public static List<List<Integer>> permuteUnique(int[] nums) {
  1.         List<List<Integer>> result = new ArrayList();
  1.         if(nums.length == 1) {
  1.             result.add(new ArrayList(){{add(nums[0]);}});
  1.             return result;
  1.         }
  1.         for (int num : nums) {
  1.             int[] tmp = new int[nums.length - 1];
  1.             int index = 0;
  1.             for (int i = 0; i < nums.length; i++) {
  1.                 if(num == nums[i] && index == i) continue;
  1.                 tmp[index] = nums[i];
  1.                 index++;
  1.             }
  1.             List<List<Integer>> sub = permuteUnique(tmp);
  1.             sub.stream().forEach(item->item.add(num));
  1.             result.addAll(sub);
  1.         }
  1.         Set<List<Integer>> sets = new HashSet();
  1.         result.stream().forEach(item->sets.add(item));
  1.         return new ArrayList(sets);
  1.     }

16. 旋转图像

给定一个 n × n 的二维矩阵表示一个图像。

将图像顺时针旋转 90 度。

说明：

你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。

示例 1:

  1. 给定 matrix =
  2. [
  3.   [1,2,3],
  4.   [4,5,6],
  5.   [7,8,9]
  6. ],
  7.  
  8. 原地旋转输入矩阵，使其变为:
  9. [
  10.   [7,4,1],
  11.   [8,5,2],
  12.   [9,6,3]
  13. ]
  1.  
  1. public static void rotate(int[][] matrix) {
  1.         int step = matrix.length;
  1.         int[][] tmp = new int[step][step];
  1.         for (int i = 0; i < step; i++) {
  1.             for (int j = 0; j < step; j++) {
  1.                 tmp[i][j] = matrix[step - j - 1][i];
  1.             }
  1.         }
  1.         for (int i = 0; i < step; i++) {
  1.             for (int j = 0; j < step; j++) {
  1.                 matrix[i][j] = tmp[i][j];
  1.             }
  1.         }
  1.     }

17. 字母异位词分组

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

  1. 输入: ["eat", "tea", "tan", "ate", "nat", "bat"],
  2. 输出:
  3. [
  4.   ["ate","eat","tea"],
  5.   ["nat","tan"],
  6.   ["bat"]
  7. ]

说明：

  • 所有输入均为小写字母。
  • 不考虑答案输出的顺序。
  1. public static List<List<String>> groupAnagrams(String[] strs) {
  1.         List<List<String>> result = new ArrayList();
  1.         if(strs == null ||strs.length == 0) return result;
  1.         if(strs.length == 1){
  1.             result.add(Arrays.asList(strs[0]));
  1.             return result;
  1.         }
  1.  
  1.         Map<String, List<String>> maps = new HashMap();
  1.         for (String str : strs) {
  1.             char[] arr = str.toCharArray();
  1.             Arrays.sort(arr);
  1.             String sorted = Arrays.toString(arr);
  1.             if(maps.get(sorted) != null){
  1.                 maps.get(sorted).add(str);
  1.             }else {
  1.                 maps.put(sorted, new ArrayList(){{add(str);}});
  1.             }
  1.         }
  1.         maps.remove(null);
  1.         return maps.values().stream().collect(Collectors.toList());
  1.     }

18. Pow(x, n)

实现 pow(x, n) ，即计算 x 的 n 次幂函数。

示例 1:

  1. 输入: 2.00000, 10
  2. 输出: 1024.00000

示例 2:

  1. 输入: 2.10000, 3
  2. 输出: 9.26100

示例 3:

  1. 输入: 2.00000, -2
  2. 输出: 0.25000
  3. 解释: 2

-2

  1.  = 1/2

2

  1.  = 1/4 = 0.25

说明:

  • -100.0 < x < 100.0
  • n 是 32 位有符号整数，其数值范围是 [−231, 231 − 1] 。
  1. /**
  1.      * 快速降幂 避免递归过深造成栈溢出
  1.      * @param x
  1.      * @param n
  1.      * @return
  1.      */
  1.     public static double power(double x, int n) {
  1.         if(!(x > -100 && x < 100)) return 0;
  1.         if(!(n <= Integer.MAX_VALUE && n >= Integer.MIN_VALUE)) return 0;
  1.  
  1.         if(x == 0) return 0;
  1.         if(x == 1) return 1;
  1.         if(n == 0) return 1;
  1.         if(n == 1) return x;
  1.         if(n == -1) return 1/x;
  1.  
  1.         if(n > 1 || n < -1){
  1.             double nextValue = power(x, n / 2);
  1.             return (n % 2 == 0 ? 1 : (n > 0 ? x : 1/x)) * nextValue * nextValue;
  1.         }
  1.         return x;
  1.     }

19. 进制转换

  1. 进制转换 十进制 =》 62进制
    这里所谓62进制是指采用0~9A~Za~z等62个字符进行编码（按ASCII顺序由小到大）。
  1.  
  1. public static String BASE = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  1.     public static String transfer(int num) {
  1.         int scale = 62;
  1.         StringBuilder sb = new StringBuilder();
  1.  
  1.         while (num > 0) {
  1.             //余数对照进制基本位 BASE 放到相应位置
  1.             sb.append(BASE.charAt(num % scale));
  1.             //除处理下一进位
  1.             num = num / scale;
  1.         }
  1.  
  1.         sb.reverse();
  1.  
  1.         return sb.toString();
  1.     }

20. 报数

报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：

  1. 1.     1
  2. 2.     11
  3. 3.     21
  4. 4.     1211
  5. 5.     111221

1 被读作  "one 1"  ("一个一") , 即 11。
11 被读作 "two 1s" ("两个一"）, 即 21。
21 被读作 "one 2",  "one 1" （"一个二" ,  "一个一") , 即 1211。

给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。

注意：整数顺序将表示为一个字符串。

  1. public static String countAndSay(int n) {
  1.         if(n < 1 || n > 30) return "";
  1.         int start = 1;
  1.         String report = "";
  1.         String result = "";
  1.         while (start < n ){
  1.             result = "";
  1.             for (int i = 0; i < report.length();) {
  1.                 int c = i;
  1.                 int count = 1;
  1.                 while (c + 1 < report.length()){
  1.                     if(report.charAt(c) != report.charAt(c + 1)){
  1.                         break;
  1.                     }
  1.                     count++;
  1.                     c++;
  1.                 }
  1.                 result += String.valueOf(count) + String.valueOf(report.charAt(i));
  1.                 i = i + count;
  1.             }
  1.             report = result;
  1.             start++;
  1.         }
  1.  
  1.         return report;
  1.     }

21. 最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

  1. 输入: "babad"
  2. 输出: "bab"
  3. 注意: "aba" 也是一个有效答案。

示例 2：

  1. 输入: "cbbd"
  2. 输出: "bb"
  1.  
  1. public static String longestPalindrome(String s) {
  1.         if(s == null || s.length() == 1 || s.length() == 0) return s;
  1.         if(s.length() == 2) return s.charAt(0) == s.charAt(1)?s:String.valueOf(s.charAt(0));
  1.  
  1.         String maxP = "";
  1.  
  1.         //中间索引
  1.         int middle = (s.length()-1)/2;
  1.         //字符串长度奇偶 判别
  1.         boolean dmiddle = s.length()%2 == 0 && s.charAt(middle) == s.charAt(middle + 1);
  1.  
  1.         //遍历使用临时中间字符索引
  1.         int tmpMiddle = middle;
  1.         //紧邻元素接次判断
  1.         int initJudge = 1;
  1.         //每次判断中间最长回文字符
  1.         String tp = "";
  1.         //最开始 判断是否偶长度
  1.         boolean first = true;
  1.         //中间字符逐次左移判断
  1.         while (tmpMiddle > 0) {
  1.             initJudge = 1;
  1.             //左右指针
  1.             int lindex = tmpMiddle - 1, rindex = tmpMiddle + (first && dmiddle?2:1);
  1.             while (lindex > -1 && rindex < s.length()) {
  1.                 if(initJudge == 1) {
  1.                     //左边紧邻接次判断
  1.                     if (s.charAt(lindex) == s.charAt(tmpMiddle)) {
  1.                         lindex--;
  1.                         initJudge++;
  1.                     }
  1.                     //右边紧邻接次判断
  1.                     if (s.charAt(rindex) == s.charAt(tmpMiddle + (first && dmiddle?1:0))) {
  1.                         rindex++;
  1.                         initJudge++;
  1.                     }
  1.                     initJudge = initJudge>1?1:0;
  1.                     first = false;
  1.                     tp = s.substring(lindex + 1, rindex);
  1.                     continue;
  1.                 }
  1.                 //对称位置判断
  1.                 if (s.charAt(lindex) == s.charAt(rindex)) {
  1.                     lindex--;
  1.                     rindex++;
  1.                     tp = s.substring(lindex + 1, rindex);
  1.                     continue;
  1.                 }
  1.                 tp = s.substring(lindex + 1, rindex);
  1.                 break;
  1.             }
  1.  
  1.             if(tp.length() > maxP.length()){
  1.                 maxP = tp;
  1.             }
  1.             tmpMiddle--;
  1.         }
  1.  
  1.         tmpMiddle = middle;
  1.         tp = "";
  1.         first = false;
  1.         //中间字符逐次右移判断
  1.         while (tmpMiddle < s.length()) {
  1.             initJudge = 1;
  1.             //左右指针
  1.             int lindex = tmpMiddle - 1, rindex = tmpMiddle + (first && dmiddle?2:1);
  1.             while (lindex > -1 && rindex < s.length()) {
  1.                 if(initJudge == 1) {
  1.                     //左边紧邻接次判断
  1.                     if (s.charAt(lindex) == s.charAt(tmpMiddle)) {
  1.                         lindex--;
  1.                         initJudge++;
  1.                     }
  1.                     //右边紧邻接次判断
  1.                     if (s.charAt(rindex) == s.charAt(tmpMiddle + (first && dmiddle?1:0))) {
  1.                         rindex++;
  1.                         initJudge++;
  1.                     }
  1.                     initJudge = initJudge>1?1:0;
  1.                     tp = s.substring(lindex + 1, rindex);
  1.                     continue;
  1.                 }
  1.                 //对称位置判断
  1.                 if (s.charAt(lindex) == s.charAt(rindex)) {
  1.                     lindex--;
  1.                     rindex++;
  1.                     tp = s.substring(lindex + 1, rindex);
  1.                     continue;
  1.                 }
  1.                 tp = s.substring(lindex + 1, rindex);
  1.                 break;
  1.             }
  1.             if(tp.length() > maxP.length()){
  1.                 maxP = tp;
  1.             }
  1.             tmpMiddle++;
  1.         }
  1.         return maxP;
  1.     }

22. 电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例:

  1. 输入："23"
  2. 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

输入："234"

输出：

[aeg, ceg, beh, aei, beg, aeh, cei, ceh, bei, bfg, afh, afg, cfh, bdg, bfi, adh, cfg, bfh, adg, afi, cdh, bdi, cdg, cfi, bdh, adi, cdi].

说明:
尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

  1. public static Map<Integer, String> maps = new HashMap(){{
  1.         put(2, "abc"); put(3, "def"); put(4, "ghi"); put(5, "jkl"); put(6, "mno"); put(7, "pqrs"); put(8, "tuv"); put(9, "wxyz");
  1.     }};
  1.     public static List<String> letterCombinations(String digits) {
  1.         int size = digits.length();
  1.         if(digits == null || digits.length() == 0) return new ArrayList<>();
  1.  
  1.         Set<String> coms = new HashSet();
  1.  
  1.         if(size == 1){
  1.             String ele = maps.get(Integer.parseInt(digits));
  1.             for (int i = 0; i < ele.length(); i++) {
  1.                 coms.add(String.valueOf(ele.charAt(i)));
  1.             }
  1.         }else if(size == 2){
  1.             String left = maps.get(Integer.parseInt(String.valueOf(digits.charAt(0))));
  1.             String right = maps.get(Integer.parseInt(String.valueOf(digits.charAt(1))));
  1.             for (int k = 0; k < left.length(); k++) {
  1.                 for (int l = 0; l < right.length(); l++) {
  1.                     coms.add(String.valueOf(left.charAt(k) + String.valueOf(right.charAt(l))));
  1.                 }
  1.             }
  1.         }else {
  1.             String left = maps.get(Integer.parseInt(String.valueOf(digits.charAt(0))));
  1.             List<String> subs = letterCombinations(digits.substring(1, digits.length()));
  1.             subs.stream().forEach(item->{
  1.                 for (int l = 0; l < left.length(); l++) {
  1.                     coms.add(String.valueOf(left.charAt(l)) + item);
  1.                 }
  1.             });
  1.         }
  1.  
  1.         return new ArrayList<>(coms);
  1.     }

23. 删除链表的倒数第N个节点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

  1. 给定一个链表: 1->2->3->4->5, 和 n = 2.
  2.  
  3. 当删除了倒数第二个节点后，链表变为 1->2->3->5.

说明：

给定的 n 保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

  1. public static ListNode removeNthFromEnd(ListNode head, int n) {
  1.         ListNode first = head;
  1.         //subIndex 第n个元素的索引
  1.         int index = 0, subIndex = 0;
  1.  
  1.         List<ListNode> list = new ArrayList();
  1.  
  1.         while (first != null){
  1.             list.add(first);
  1.  
  1.             if(index - subIndex > n){
  1.                 subIndex++;
  1.             }
  1.             index++;
  1.             first = first.next;
  1.         }
  1.  
  1.         if(list.size() < n) return null;
  1.         if(list.size() == 1) return null;
  1.         if(list.size() == n) return list.get(1);
  1.  
  1.         //处理移除
  1.         list.get(subIndex).next = list.get(subIndex).next.next;
  1.         return list.get(0);
  1.     }

24. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

  1. //括号映射
  1.     public static Map<String, String> maps = new HashMap(){{
  1.         put("}", "{");
  1.         put("]", "[");
  1.         put(")", "(");
  1.         put("{", "}");
  1.         put("[", "]");
  1.         put("(", ")");
  1.     }};
  1.     public static boolean isValid(String s) {
  1.         if(s == null || s.length() == 1) return false;
  1.         if(s.length() == 0 ) return true;
  1.         int index = 1;
  1.         //当前字符
  1.         char focus = s.charAt(0);
  1.         //存储非相邻匹配的符号
  1.         List<String> unmap = new LinkedList();
  1.         while (index < s.length())
  1.             //相邻对比
  1.             if(String.valueOf(s.charAt(index)).equals(maps.get(String.valueOf(focus)))){
  1.                 //处理存储的非相邻匹配的符号匹配
  1.                 int lIndex = unmap.size() - 1;
  1.                 if(lIndex > 0) {
  1.                     unmap.remove(lIndex);
  1.                 }
  1.                 while (lIndex > 0){
  1.                     index++;
  1.                     lIndex--;
  1.                     //倒序遍历匹配
  1.                     if(unmap.get(lIndex).equals(maps.get(String.valueOf(s.charAt(index))))){
  1.                         //匹配上则删除list中元素
  1.                         unmap.remove(lIndex);
  1.                         continue;
  1.                     }else {
  1.                         //匹配不上则加入到list中
  1.                         unmap.add(String.valueOf(s.charAt(index)));
  1.                         index--;
  1.                         break;
  1.                     }
  1.                 }
  1.                 index++;
  1.                 if(index >= s.length()) return true;
  1.                 focus = s.charAt(index);
  1.                 index++;
  1.             }else {
  1.                 //相邻不匹配则加入到 list中以供后续使用
  1.                 if(s.substring(index).contains(String.valueOf(maps.get(String.valueOf(focus)))) && (index + 1 < s.length()) &&s.substring(index + 1).contains(String.valueOf(maps.get(String.valueOf(s.charAt(index)))))){
  1.                     //第一次非相邻的时候添加头一个元素
  1.                     if(unmap.size() == 0) {
  1.                         unmap.add(String.valueOf(focus));
  1.                     }
  1.                     unmap.add(String.valueOf(s.charAt(index)));
  1.                     focus = s.charAt(index);
  1.                     index++;
  1.  
  1.                 }else{
  1.                     return false;
  1.                 }
  1.             }
  1.  
  1.         return false;
  1.     }

25. 四数之和

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例：

  1. 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
  2.  
  3. 满足要求的四元组集合为：
  4. [
  5.   [-1,  0, 0, 1],
  6.   [-2, -1, 1, 2],
  7.   [-2,  0, 0, 2]
  8. ]
  1.  
  1. /**
  1.      * 四数之和
  1.      * @param nums
  1.      * @param target
  1.      * @return
  1.      */
  1.     public static List<List<Integer>> fourSum(int[] nums, int target) {
  1.         Set<List<Integer>> sets = new HashSet();
  1.         List<Integer> numList = new ArrayList();
  1.         for (int num : nums) {
  1.             numList.add(num);
  1.         }
  1.         for (int i = 0; i < numList.size(); i++) {
  1.             List<Integer> copy = new ArrayList();
  1.             copy.addAll(numList);
  1.             copy.remove(numList.get(i));
  1.             List<List<Integer>> threes = threeSum(copy, target - numList.get(i));
  1.             final int finalI = i;
  1.             threes.forEach(item -> {
  1.                 item.add(nums[finalI]);
  1.                 Collections.sort(item);
  1.                 sets.add(item);
  1.             });
  1.         }
  1.         return new ArrayList(sets);
  1.     }
  1.  
  1.     /**
  1.      * 三数之和
  1.      * @param nums
  1.      * @param target
  1.      * @return
  1.      */
  1.     public static List<List<Integer>> threeSum(List<Integer> nums, int target) {
  1.         if(nums == null || nums.size() < 3) return new ArrayList();
  1.         Set<List<Integer>> result = new HashSet<>();
  1.         List<Integer> numList = new ArrayList();
  1.         for (int num : nums) {
  1.             numList.add(num);
  1.         }
  1.  
  1.         for (Integer num : numList) {
  1.             List<Integer> copy = new ArrayList();
  1.             copy.addAll(numList);
  1.             copy.remove(num);
  1.             List<int[]> tmp = twoSum(copy, target - num);
  1.             if(tmp.size()>0){
  1.                 for (int[] ints : tmp) {
  1.                     List<Integer> list = new ArrayList(){{add(num);add(ints[0]);add(ints[1]);}};
  1.                     Collections.sort(list);
  1.                     result.add(list);
  1.                 }
  1.             }
  1.         }
  1.  
  1.         return new ArrayList(result);
  1.     }
  1.  
  1.     /**
  1.      * 两数之和
  1.      * @param nums
  1.      * @param target
  1.      * @return
  1.      */
  1.     public static List<int[]> twoSum(List<Integer> nums, int target) {
  1.         List<int[]> result = new ArrayList();
  1.         Map<Integer, Integer> map = new HashMap<>();
  1.         for (int i = 0; i < nums.size(); i++) {
  1.             int complement = target - nums.get(i);
  1.             if (map.containsKey(complement)) {
  1.                 result.add(new int[] { complement, nums.get(i) });
  1.             }
  1.             map.put(nums.get(i), i);
  1.         }
  1.         return result;
  1.     }

26. 合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

  1. 输入：1->2->4, 1->3->4
  2. 输出：1->1->2->3->4->4
  1.  
  1. /**
  1.      * 合并两个有序链表
  1.      * @param l1
  1.      * @param l2
  1.      * @return
  1.      */
  1.     public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
  1.         if(l1 == null && l2 == null) return null;
  1.  
  1.         List<ListNode> list1 = new ArrayList();
  1.         while (l1!= null){
  1.             list1.add(l1);
  1.             l1 = l1.next;
  1.         }
  1.  
  1.         List<ListNode> list2 = new ArrayList();
  1.         while (l2!= null){
  1.             list2.add(l2);
  1.             l2 = l2.next;
  1.         }
  1.         List<ListNode> result = mergeArrays(list1, list2);
  1.         for (int i = 0; i < result.size() - 1; i++) {
  1.             result.get(i).next = result.get(i + 1);
  1.         }
  1.  
  1.         return result.get(0);
  1.     }
  1.  
  1.     public static List<ListNode> mergeArrays(List<ListNode> nums1, List<ListNode> nums2) {
  1.         List<ListNode> indexes = new LinkedList();
  1.         int lgn1 = nums1.size();
  1.         int lgn2 = nums2.size();
  1.         int allLgn = lgn1 + lgn2;
  1.  
  1.  
  1.         int index1 = 0;
  1.         int index2 = 0;
  1.         for (int i = 0; i < allLgn; i++) {
  1.             if(index1 < lgn1 && index2 < lgn2) {
  1.                 if (nums1.get(index1).val > nums2.get(index2).val) {
  1.                     indexes.add(nums2.get(index2));
  1.                     index2++;
  1.                 } else {
  1.                     indexes.add(nums1.get(index1));
  1.                     index1++;
  1.                 }
  1.             }else if(index1 < lgn1){
  1.                 indexes.add(nums1.get(index1));
  1.                 index1++;
  1.             }else if(index2 < lgn2){
  1.                 indexes.add(nums2.get(index2));
  1.                 index2++;
  1.             }
  1.         }
  1.        return indexes;
  1.     }

27. 合并K个排序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

  1. 输入:
  2. [   1->4->5,   1->3->4,   2->6
  3. ]
  4. 输出: 1->1->2->3->4->4->5->6
  1. /**
  1.      * 合并k个有序链表
  1.      * @param lists
  1.      * @return
  1.      */
  1.     public static ListNode mergeKLists(ListNode[] lists) {
  1.         if(lists == null || lists.length == 0) return null;
  1.         if(lists.length == 1) return lists[0];
  1.         int middle = (lists.length + 1)/2;
  1.         ListNode left = mergeKLists(Arrays.copyOfRange(lists, 0, middle));
  1.         ListNode right = mergeKLists(Arrays.copyOfRange(lists, middle, lists.length));
  1.         List<ListNode> list1 = new ArrayList();
  1.         while (left!= null){
  1.             list1.add(left);
  1.             left = left.next;
  1.         }
  1.         List<ListNode> list2 = new ArrayList();
  1.         while (right!= null){
  1.             list2.add(right);
  1.             right = right.next;
  1.         }
  1.         List<ListNode> result = mergeArrays(list1, list2);
  1.         for (int i = 0; i < result.size() - 1; i++) {
  1.             result.get(i).next = result.get(i + 1);
  1.         }
  1.  
  1.         return result.size() > 0?result.get(0):null;
  1.     }
  1.  
  1. public static List<ListNode> mergeArrays(List<ListNode> nums1, List<ListNode> nums2) {
  1.         List<ListNode> indexes = new LinkedList();
  1.         int lgn1 = nums1.size();
  1.         int lgn2 = nums2.size();
  1.         int allLgn = lgn1 + lgn2;
  1.  
  1.  
  1.         int index1 = 0;
  1.         int index2 = 0;
  1.         for (int i = 0; i < allLgn; i++) {
  1.             if(index1 < lgn1 && index2 < lgn2) {
  1.                 if (nums1.get(index1).val > nums2.get(index2).val) {
  1.                     indexes.add(nums2.get(index2));
  1.                     index2++;
  1.                 } else {
  1.                     indexes.add(nums1.get(index1));
  1.                     index1++;
  1.                 }
  1.             }else if(index1 < lgn1){
  1.                 indexes.add(nums1.get(index1));
  1.                 index1++;
  1.             }else if(index2 < lgn2){
  1.                 indexes.add(nums2.get(index2));
  1.                 index2++;
  1.             }
  1.         }
  1.        return indexes;
  1.     }

28. 两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例:

  1. 给定 1->2->3->4, 你应该返回 2->1->4->3.
  1. public static ListNode swapPairs(ListNode head) {
  1.         if(head == null) return null;
  1.         ListNode first = head.next == null?head:head.next;
  1.         ListNode curr = head;
  1.         ListNode pre = null;
  1.         while (head != null){
  1.             if(head.next != null){
  1.                 //保存需要交换位置的节点之后的节点
  1.                 curr = head.next.next;
  1.                 //将上一个节点和交换后的节点相连
  1.                 if(pre != null){
  1.                     pre.next = head.next;
  1.                 }
  1.  
  1.                 //保存下一次需要交换位置节点的上一个节点
  1.                 pre = head;
  1.                 //交换节点
  1.                 head.next.next = head;
  1.                 //将交换位置后的第二个节点和后面的节点相连
  1.                 head.next = curr;
  1.             }
  1.             //继续遍历
  1.             head = head.next;
  1.         }
  1.         return first;
  1.     }

29. k个一组翻转链表

给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明 :

  • 你的算法只能使用常数的额外空间。
  • 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
  1. /**
  1.      * k个一组翻转链表
  1.      * @param head
  1.      * @param k
  1.      * @return
  1.      */
  1.     public static ListNode reverseKGroup(ListNode head, int k) {
  1.         if(head == null) return null;
  1.         if(k == 1) return head;
  1.         if(head.next == null) return head;
  1.         List<ListNode> list = new LinkedList();
  1.         List<ListNode> listCopy = new LinkedList();
  1.         List<ListNode> tmpList = new LinkedList();
  1.  
  1.         int index = 0;
  1.         while (head != null){
  1.             list.add(head);
  1.             head = head.next;
  1.             index++;
  1.             if(index%k == 0){
  1.                 tmpList = list.subList(index - k, index);
  1.                 Collections.reverse(tmpList);
  1.                 listCopy.addAll(tmpList);
  1.             }
  1.         }
  1.         if(index%k != 0){
  1.             tmpList = list.subList(index > k?(index - index%k):0, index);
  1.             listCopy.addAll(tmpList);
  1.         }
  1.  
  1.         for (int i = 0; i < listCopy.size() - 1; i++) {
  1.             listCopy.get(i).next = listCopy.get(i + 1);
  1.         }
  1.         listCopy.get(listCopy.size() - 1).next = null;
  1.         return listCopy.get(0);
  1.     }

30. 删除排序数组中的重复项

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

  1. 给定数组 nums = [1,1,2], 
  2.  
  3. 函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 
  4.  
  5. 你不需要考虑数组中超出新长度后面的元素。
  1. public static int removeDuplicates(int[] nums) {
  1.         if(nums == null || nums.length == 0) return 0;
  1.         if(nums.length == 1) return 1;
  1.  
  1.         int index = 0;
  1.         int lgn = nums.length;
  1.         while (index < lgn){
  1.             if(Arrays.binarySearch(nums, index + 1, lgn, nums[index]) > -1){
  1.                 for (int i = index; i < lgn - 1 ; i++) {
  1.                     nums[i] = nums[i + 1];
  1.                 }
  1.                 nums[lgn - 1] = Integer.MIN_VALUE;
  1.                 lgn--;
  1.             }else {
  1.                 index++;
  1.             }
  1.         }
  1.         return lgn;
  1.     }

31. 移除元素

给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:

  1. 给定 nums = [3,2,2,3], val = 3,
  2.  
  3. 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
  4.  
  5. 你不需要考虑数组中超出新长度后面的元素。
  1. public static int removeElement(int[] nums, int val) {
  1.         if(nums == null || nums.length == 0) return 0;
  1.  
  1.         int index = 0;
  1.         int lgn = nums.length;
  1.         while (index < lgn){
  1.             if(nums[index] == val){
  1.                 for (int i = index; i < lgn - 1 ; i++) {
  1.                     nums[i] = nums[i + 1];
  1.                 }
  1.                 nums[lgn - 1] = Integer.MIN_VALUE;
  1.                 lgn--;
  1.             }else {
  1.                 index++;
  1.             }
  1.         }
  1.         return lgn;
  1.     }

32. 实现strStr()

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回  -1。

示例 1:

  1. 输入: haystack = "hello", needle = "ll"
  2. 输出: 2
  1. public static int strStr(String haystack, String needle) {
  1.         if(haystack == null || needle == null) return -1;
  1.         if(haystack.equals(needle) || "".equals(needle)) return 0;
  1.         int findex = 0;
  1.         int flgn = haystack.length(), slgn = needle.length();
  1.         while (findex + slgn <= flgn){
  1.             if(haystack.charAt(findex) == needle.charAt(0)) {
  1.                 int sindex = 0;
  1.                 for (; sindex < slgn; sindex++) {
  1.                     if (needle.charAt(sindex) != haystack.charAt(findex + sindex)){
  1.                         findex = findex + sindex - 1;
  1.                         break;
  1.                     }
  1.                 }
  1.                 if(sindex == slgn){
  1.                     return findex;
  1.                 }else {
  1.                     findex = findex - sindex + 1;
  1.                     findex++;
  1.                     continue;
  1.                 }
  1.             }else {
  1.                 findex++;
  1.             }
  1.         }
  1.         return -1;
  1.     }

待续 。。。 。。。

项目地址：https://github.com/windwant/windwant-service/tree/master/algorithm

leetcode 一些算法题及答案的更多相关文章

  1. 【算法】数据结构与算法基础总览（中）——刷Leetcode等算法题时一些很实用的jdk辅助方法锦集

    最近重新学习数据结构与算法以及刷leetcode算法题时,发现不少jdk自带的方法可以提升刷题的效率.这些小技巧不仅仅对刷算法题带来便利,对我们平时开发也是很有帮助的.本文以java语言为基础,记录了 ...

  2. 【leetcode】 算法题 两数之和

      问题       给定一个整数数组和一个目标值,找出数组中和为目标值的两个数. 你可以假设每个输入只对应一种答案,且同样的元素不能被重复利用. 示例: 给定 nums = [2, 7, 11, 1 ...

  3. LeetCode | HouseCode 算法题

    题目: You are a professional robber planning to rob houses along a street. Each house has a certain am ...

  4. 【leetcode】 算法题3 无重复字符的最长子串

      问题      给定一个字符串,找出不含有重复字符的最长子串的长度. 示例: 给定 "abcabcbb" ,没有重复字符的最长子串是 "abc" ,那么长度 ...

  5. [leetcode]经典算法题- String to Integer (atoi)

    题目描述: 把字符串转化为整数值 原文描述: Implement atoi to convert a string to an integer. Hint: Carefully consider al ...

  6. 【leetcode】 算法题2 两数相加

      问题      给定两个非空链表来表示两个非负整数.位数按照逆序方式存储,它们的每个节点只存储单个数字.将两数相加返回一个新的链表. 你可以假设除了数字 0 之外,这两个数字都不会以零开头. 示例 ...

  7. 解决一道leetcode算法题的曲折过程及引发的思考

    写在前面 本题实际解题过程是 从 40秒 --> 24秒 -->1.5秒 --> 715ms --> 320ms --> 48ms --> 36ms --> ...

  8. leetcode算法题（JavaScript实现）

    题外话 刷了一段时间的codewars的JavaScript题目之后,它给我最大的感受就是,会帮助你迅速的提升你希望练习的语言的API的熟悉程度,Array对象.String对象等原生方法,构造函数. ...

  9. Kotlin实现LeetCode算法题之Two Sum

    LeetCode介绍 LeetCode是算法练习.交流等多功能网站,感兴趣的同学可以关注下(老司机请超车).页面顶部的Problems菜单对应算法题库,附带历史通过滤.难易程度等信息. 未来计划 打算 ...

随机推荐

  1. pytest_skip跳过用例

    前言 pytest.mark.skip可以标记无法在某些平台上运行的测试功能,或者您希望失败的测试功能 skip意味着只有在满足某些条件时才希望测试通过,否则pytest应该跳过运行测试. 常见示例是 ...

  2. server.port 在单元测试中，调用的类或者方法这个地方获取到的端口号就会变成-1

    @Value("${server.port}") 本文链接:https://blog.csdn.net/weixin_38342534/article/details/886985 ...

  3. C# vb .net实现胶片效果滤镜

    在.net中,如何简单快捷地实现Photoshop滤镜组中的胶片效果呢?答案是调用SharpImage!专业图像特效滤镜和合成类库.下面开始演示关键代码,您也可以在文末下载全部源码: 设置授权 第一步 ...

  4. python抓取贝壳房源信息

    分析了贝壳的房源信息数据,发现地址链接的参数传递是有规律的 https://tj.ke.com/chengjiao/a3l4/ a3 实际表示的 l4 表示的是 然后 将复合条件拼成一个字符串,带过去 ...

  5. Mysql把一个表的数据写入另一个表中

    一.表结构一样 insert into 表1 select * from 表2 二. 表结构不一样或者取部分列 insert into 表1 (列名1,列名2,列名3) select 列1,列2,列3 ...

  6. 一 python并发编程之多进程

    一 进程与程序 二 并发与并行 三 同步\异步和阻塞\非阻塞 四 进程的创建 五 进程的终止 六 进程的层次结构 七 进程的状态 八 进程并发的实现 一 进程与程序 什么是进程: 进程的概念:我们知道 ...

  7. webpack4引入JQuery的两种方法

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明.本文链接:https://blog.csdn.net/weixin_36185028/artic ...

  8. 判断RecyclerView到达底部的几种方法

    参考文章:https://www.jianshu.com/p/c138055af5d2 1.比较lastItem的pos 通过比较当前屏幕可见最后一个item的position和整个RV的最后一个it ...

  9. python测量函数运行时间长度

    python测试函数运行时间长度的方法如下 import time def measure_time(): def wraps(func): def mesure(*args,**kwargs): s ...

  10. maven 修改镜像为阿里淘宝源

    修改maven根目录下的conf文件夹中的setting.xml文件,(或者当前用户目录 的 .m2 目录下的 setting.xml 文件) 内容如下: <mirrors> <mi ...