- 博客(32)
- 收藏
- 关注
RSS订阅原创 Leetcode 165. Compare Version Numbers
方法1: 将两个string以点号为单位分割，运用string.split()方法，括号里的参数是正则表达式，这边我们用"\\."表示以点号分割，这个是需要记住的。分割好了之后得到两个数组，然后按顺序比较大小就可以了。时间复杂m+n+max（m，n），空间复杂m+n。m，n为两个string的长度。class Solution { public int compareVersion(String version1, String version2) { String[] arr1.
2020-12-31 23:56:44
67
原创 Leetcode 43. Multiply Strings
方法1: 这题就是考验怎么做乘法，你对乘法究竟掌握的怎样。然后我掌握的不好。我发现math题，有些题目看着简单，但是实现起来不是那么容易。这边我推荐看lc discussion vote最高的解释。非常的巧妙。时间复杂n的平方，空间复杂1。这边我直接给出他的代码：public String multiply(String num1, String num2) { int m = num1.length(), n = num2.length(); int[] pos = new int[m.
2020-12-31 13:03:52
60
原创 Leetcode 258. Add Digits
方法1: 找规律，你把1-40所有的output自己算一遍你就明白了。时间复杂1，空间复杂1.class Solution { public int addDigits(int num) { if(num == 0) return 0; int flag = num % 9; if(flag == 0) return 9; return flag; }}总结：无...
2020-12-31 09:06:53
63
原创 Leetcode 231. Power of Two
方法1: 最简单想到的logn算法。把n不停的除以2，最后得到1就是true，不是1就是false。时间复杂logn，空间1.class Solution { public boolean isPowerOfTwo(int n) { long N = n; return helper(N); } private boolean helper(long n){ if(n < 0) return false; .
2020-12-31 08:39:18
90
原创 Leetcode 69. Sqrt(x)
方法1: binary search。因为答案只可能在0-x/2之间产生，而这个区间又是sorted的，所以可以用binary search来搜索答案。时间复杂logx，空间复杂1.class Solution { public int mySqrt(int x) { if(x < 2) return x; int left = 2; int right = x / 2; int mid; long num;.
2020-12-31 08:06:01
71
原创 Leetcode 50. Pow(x, n)
方法1: brute force。会tle。时间复杂n，空间复杂1.class Solution { public double myPow(double x, int n) { if(n == 0) return (double)1; if(n < 0) return (double)1/myPow(x,n*(-1)); double res = 1; while(n > 0){ res *= .
2020-12-31 06:56:41
56
原创 Leetcode 13. Roman to Integer
方法1 ：第12题的变种。从左往右遍历string，check当前char符合哪个罗马数字，check后叠加进最后的结果中。这题主要还是edge cases的处理，就比谁更细心了。时间复杂1，空间复杂1.class Solution { public int romanToInt(String s) { int res = 0; int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1.
2020-12-30 06:02:05
343
原创 Leetcode 12. Integer to Roman
方法1: 这题我们可以枚举出所有罗马数字的组合，然后遍历num。时间复杂1，因为最多output长度为15，是一个定值。空间复杂1.class Solution { public String intToRoman(int num) { int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}; String[] symbols = {"M","CM","D","CD","C.
2020-12-30 04:31:26
94
原创 Leetcode 9. Palindrome Number
方法1: 先convert to string，然后two pointer。时间复杂log10（x）x为input。空间复杂1。class Solution { public boolean isPalindrome(int x) { String str = String.valueOf(x); int start = 0; int end = str.length() - 1; while(start < end){ .
2020-12-30 00:34:14
71
原创 Leetcode 8. String to Integer (atoi)
方法1: 这题主要就是考虑edge cases，除了耐心还是耐心。时间复杂n，空间复杂1.class Solution { public int myAtoi(String s) { String str = s.trim(); if(str.length() == 0) return 0; if((int)str.charAt(0) != 43 && (int)str.charAt(0) != 45 && ((int.
2020-12-30 00:19:50
53
原创 Leetcode 7. Reverse Integer
方法1： 从后往前pop出每个digit，然后持续添加到最后要返回的结果中。记住在添加进去的时候我们要检查添加进去之后会不会stackoverflow，这是本题重要的一点。时间复杂logx（x为input），空间复杂1.class Solution { public int reverse(int x) { int res = 0; while(x != 0){ int currDigit = x % 10; if(.
2020-12-29 22:55:06
43
原创 Leetcode 25. Reverse Nodes in k-Group
方法1： recursion。真的是一下就想到recursion，但是recursion注定空间复杂度不是1。但是recursion是一个非常好的开始，可以为方法2做铺垫。我这边是用了一个arraylist存放reverse后的每k个node。然后最后把arraylist中的node全部连起来就好了。时间复杂n的平方，空间复杂n。我建议去看一下lc的官方解答1，它上面的recursion更好，时间复杂是n，而且没用多余的数据结构存储nodes。这边展示一下我自己的代码：/** * Definition.
2020-12-29 09:44:23
96
原创 Leetcode 23. Merge k Sorted Lists
方法1: 其实最先就应该联想到merge two sorted linked list那题。然后利用recursion就可以完美完成。时间复杂nlogk，n为merge two算法的时间复杂度， k为list的数量，一共需要计算logk次mergetwo，这相当于一个bottom up的二叉树。/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next;.
2020-12-29 08:13:09
54
原创 Leetcode 147. Insertion Sort List
方法1: 题目说的很明确用insertion sort，而且也解释了interstion sort的原理，其实这从根本上已经把用什么算法来解答告诉我们了。但是啊，对于链表题，我是真的创建太多reference之后我会搞不清哪一个是哪一个，而且一旦涉及到prev node我也会很头疼。这链表题今天就要刷完了，还是这样，说明水平还是不到位。时间复杂n的平方，空间复杂1./** * Definition for singly-linked list. * public class ListNode { .
2020-12-29 07:09:48
111
原创 Leetcode 148. Sort List
方法1: 看到要求nlogn，那么第一想到merge sort。我发现我对各种排序算法还不是很清晰。然后这题逻辑分为两个部分。先把list对半分，然后两半list分别sort（recursion）。然后把两个sort好的list merge一下。时间复杂nlogn，空间复杂nlogn。这边提一下，merge我也是用的recursion实现的，但是用iterate来实现会更好，但是我现在不想看了，所以复盘的时候一定要去看，lc官方merge就使用的iterate实现的。/** * Definition .
2020-12-29 03:16:29
59
原创 Leetcode 143. Reorder List
方法1: recursion。利用一个arraylist先存储所有nodes。时间复杂n，空间复杂n。/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListN.
2020-12-29 02:12:01
105
原创 Leetcode 86. Partition List
方法1: 用两个arraylist把node全部存起来。遍历两个arraylist，分别构造两个list，最后连接两个list。时间复杂n，空间复杂n。/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * .
2020-12-27 13:20:55
74
原创 Leetcode 237. Delete Node in a Linked List
方法1: 这题目被踩的很厉害，但是对于我来说还是学到点东西的。这题我让我知道了要彻底删除一个节点需要知道头节点，lc给出的做法其实就是修改这个node的值，修改这个node的去向。其实就是把要删除的node易容成了它的下一个节点，但是本身并没有删除。时间1，空间1./** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNod.
2020-12-27 05:38:05
191
原创 Leetcode 203. Remove Linked List Elements
方法1: iterate。这题主要是要设置一个prev node，然后还要设置一个哨兵node，就这个比较烦，因为遍历的时候会修改原来的list导致最后不知道返回什么了（我经常做到最后不知道要返回什么）。时间复杂n，空间复杂1./** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListN.
2020-12-27 05:04:52
130
原创 Leetcode 138. Copy List with Random Pointer
方法1: 这题我没看懂题目什么叫deep copy。其实就是创建一个和input一模一样的list。第一个方法是lc官方解答1，是借助了一个map。我这个方法其实没怎么看，其实还没怎么搞清楚，推荐看lc的官方解答1，说的挺好。时间复杂n。空间复杂n。/*// Definition for a Node.class Node { int val; Node next; Node random; public Node(int val) { this.v.
2020-12-27 04:19:18
205
原创 Leetcode 234. Palindrome Linked List
方法1: 先reverse linked list，然后再与原先的list比较是否相同。这边需要注意一点，reverse操作会改变原先的list，这个无法避免。所以我们需要事先用一个arraylist存放原来list各个node的值。时间复杂n，空间复杂n。/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() .
2020-12-27 01:04:12
132
原创 Leetcode 19. Remove Nth Node From End of List
方法1: three pass way，先reverse，再remove node，最后再reverse回去。时间复杂度n，空间复杂度1。这个方法其实可以稍微优化一点，变成two pass，也就是lc官方解答1。第一个pass算出list的长度，从而推算出从前往后数要删除的node在什么位置上；第二个pass只要remove node就行。two pass时间，空间复杂度和three pass一样。下面给出three pass代码。/** * Definition for singly-linked .
2020-12-26 13:58:28
66
原创 Leetcode 82. Remove Duplicates from Sorted List II
方法1: 这题主要就是要设置一个prev节点和later节点，然后把两个节点中间的重复节点给去掉，然后连接这两个节点。特别注意开头就是重复节点的情况。时间复杂度n，空间复杂度1。/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val =.
2020-12-26 12:15:20
60
原创 Leetcode 83. Remove Duplicates from Sorted List
方法1: 非常直接的做法，就是遍历链表，去除重复的node。时间复杂度n，空间复杂度1./** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode nex.
2020-12-26 04:25:53
257
1
原创 Leetcode 61. Rotate List
方法1: 每次向右移动一次，但是这个方法tle。时间复杂度n平方。/** * 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.v.
2020-12-26 04:07:34
360
原创 Leetcode 142. Linked List Cycle II
方法1: 这题是141的升级版，141是只要判断有没有circle，这题是要先判断有没有circle然后再找出这个circle的entry。做法也是一样，就是归途赛跑的算法，只不过这边有两个phase。具体思路可以直接看lc官方解答。时间复杂度n，空间复杂度1。/** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) .
2020-12-26 02:12:15
410
原创 Leetcode 141. Linked List Cycle
方法1: hashtable。时间复杂度n，空间复杂度n。/** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */public class Solution { public boo.
2020-12-25 06:14:22
112
原创 Leetcode 92. Reverse Linked List II
方法1: recursion。这道题是206的升级版，记住，一定要把206刷到滚瓜烂熟。这题我又没做出来，不过没关系，我觉得稳住心态吧，这是最重要的。详细的逻辑可以看lc官方解答下面的热评第一。时间复杂度：n，空间复杂度n。/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNod.
2020-12-25 05:28:49
207
原创 Leetcode 206. Reverse Linked List
方法1: 这道easy题两个方法我都没有解出来，主要原因是感觉还是接触链表题目太少。第一个方法是iterate。这个方法关键在于要新建一个prev node，初始化为null。具体思路是curr node的next指向prev node，然后在向右移动curr node和pre node。时间复杂度n，空间复杂度1/** * Definition for singly-linked list. * public class ListNode { * int val; * List.
2020-12-25 02:56:24
141
原创 Leetcode 24. Swap Nodes in Pairs
方法1: 迭代。就是非常直白的swap两个node。但是这题烦就烦在怎么swap两个node，在swap时候要考虑哪些东西，一样都不能漏掉，而且这些东西哪个先写哪个后写都很重要，不能乱写。具体怎呢swap，我这里推荐一个视频，介绍的还算比较清楚：链接。时间复杂度n，n为链表长度；空间复杂度为1./** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next;.
2020-12-24 15:07:23
80
原创 Leetcode 160. Intersection of Two Linked Lists
思路1: brute force。非常简单nested loop，遍历两个链表，找到第一个相同的node。时间复杂度n^2，空间复杂度1。/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * }.
2020-12-24 13:01:16
166
原创 Leetcode 21 Merge Two Sorted Lists
思路1： 我的最直接思路就是遍历两个链表，一边遍历一边比较大小，同时将小的值存进结果链表中。时间复杂度为 O(m+n) m，n分别为两个链表的长度。下面展示代码：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; }.
2020-12-24 10:45:49
52
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人