寫在前面
最近經常覺得自己越來越笨，一些很簡單的問題愣是想不出來。今天去leetcode上做了幾道題，面對上學時不止一次刷過的題目竟然有的連最笨的方法都想不出來。感覺還是要經常用用腦子，不然真的會生銹。。。
算法對我目前的工作確實用不到，而且一些基礎常用的基本各個語言都有實現，專業算法更是各種現成的工具包。但真遇到問題時就算用別人的方法，自己起碼也要做到理解到位吧。所以貴在堅持積累，從基礎拾起??。
目的
解題不是目的，重要的是通過做一道題目幫助自己get到哪些東西。我總結了以下幾點：
- 數據結構。 定義合理的數據結構很重要。比如今天下面遇到的問題無非都是哈希表的使用、雙指針、數組的奇偶等。對復雜的問題這點就更為明顯。
- 時間復雜度。 有時會發現一個笨方法也能通過，但不能做完拉倒，想想問題理論上最優的時間復雜度是多少，自己有沒更優的方法。之后再去查閱其他人的解答，理解消化。
- 知識點。 畢業后還給老師的知識，有些很基礎的自以為早學透的東西，真正自己動手去寫發現還是有很多地方沒理解到位、沒掌握好的。
- 代碼風格。 有時候業務邏輯寫多了，明明有更簡潔還易讀的方式卻還是寫一堆冗長的代碼，在閱讀別人代碼時多思考。
1.兩數之和
給定一個整數數組和一個目標值，找出數組中和為目標值的兩個數。你可以假設每個輸入只對應一種答案，且同樣的元素不能被重復利用。
示例:
給定 nums = [2, 7, 11, 15], target = 9
因為 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
這個我是想都沒想就兩層遍歷提交通過，也沒想過是不是有更好的方法。后來做到別的題目才想到，這種簡單問題兩層遍歷O(n^2)是很高的時間復雜度了，寫的時候就該下意識的思考下，一般都有更優的方法。笨方法就不貼了，理論上一次遍歷就可以找到，借助哈希表O(1)的查找實現：
class Solution {
public int[] twoSum(int[] nums, int target) {
HashMap<Integer,Integer> map = new HashMap<>();
for (int i=0,count=nums.length;i<count;i++) {
if (map.get(target-nums[i]) != null) {
return new int[]{i,map.get(target-nums[i])};
}
map.put(nums[i],i);
}
return null;
}
}
2.兩數相加
給定兩個非空鏈表來表示兩個非負整數。位數按照逆序方式存儲，它們的每個節點只存儲單個數字。將兩數相加返回一個新的鏈表。
你可以假設除了數字 0 之外，這兩個數字都不會以零開頭。
示例：
輸入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
輸出：7 -> 0 -> 8
原因：342 + 465 = 807
這道題確實在面試中被問過，好在還能寫得出來，主要是注意細節：兩數不等長、后面的進位等，問題在于之前說過的代碼太過冗長，我當時這么寫的：
class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode result = new ListNode(0);
ListNode p1=l1,p2=l2,pr=result;
int sum=0,carry=0;
while(p1!=null && p2!=null){
sum = (p1.val+p2.val+carry)%10;
carry = (p1.val+p2.val+carry)/10;
pr.next = new ListNode(sum);
pr = pr.next;
p1 = p1.next;
p2 = p2.next;
}
while (p1!=null){
sum = (p1.val+carry)%10;
carry = (p1.val+carry)/10;
pr.next = new ListNode(sum);
pr = pr.next;
p1 = p1.next;
}
while (p2!=null){
sum = (p2.val+carry)%10;
carry = (p2.val+carry)/10;
pr.next = new ListNode(sum);
pr = pr.next;
p2 = p2.next;
}
if (carry != 0)
pr.next = new ListNode(carry);
return result.next;
}
}
思路還算清楚，但這代碼著實看著不舒服。對比找了網上的解答來看，其實這個結果鏈表往前加的來源就三個：兩個加數和進位，只要存在其中一個循環就繼續，這樣寫起來就簡潔多了：
class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode result = new ListNode(0);
ListNode p1=l1,p2=l2,pr=result;
int carry=0;
while(p1 != null || p2 != null || carry != 0){
int sum = ((p1 == null) ? 0 : p1.val) + ((p2 == null) ? 0 : p2.val) + carry;
carry = sum/10;
pr.next = new ListNode(sum%10);
pr = pr.next;
if(p1 != null) p1 = p1.next;
if(p2 != null) p2 = p2.next;
}
return result.next;
}
}
3.無重復字符的最長子串
給定一個字符串，找出不含有重復字符的最長子串的長度。
示例：給定 "abcabcbb" ，沒有重復字符的最長子串是 "abc" ，那么長度就是3。
給定 "bbbbb" ，最長的子串就是 "b" ，長度是1。
給定 "pwwkew" ，最長子串是 "wke" ，長度是3。請注意答案必須是一個子串，"pwke" 是 子序列 而不是子串。
這個做的時候沒想出來，但總的寫一下在去查答案。。最笨的窮舉總是可以試試的，兩層遍歷以每個字符為起點，還得通過string的contains方法做判斷，竟然還超過了4%的java提交記錄。。。只能說這個網站對運行時間測的不準吧，算上contains方法這個時間復雜度高得嚇人了，肯定是超時的。
寫的過程竟還錯了好多細節，瞬間感覺自己菜的一匹：
class Solution {
public int lengthOfLongestSubstring(String s) {
int length = s.length();
if(length == 0 || length == 1) return length;
int result = 1;
for(int i=0; i<= length-result ;i++){
// 這里一開始寫的 for(int j=i+result ...) ，以當前result為基準查找，有
// 點想當然了，中間也可能有重復的。
for(int j=i+1;j<length;j++)
{
if(!s.substring(i,j).contains(s.substring(j,j+1)))
{
if (result < j-i+1) result = j-i+1;
}
else
{
break;
}
}
}
return result;
}
}
這么垃圾的方法還一再運行不過，確實有點受打擊。但仔細想想，這道題在學校校招那會肯定做過不止一次，和第一題一樣，利用哈希表存下標，只是一時沒想起來（這么安慰下自己吧）
思路就是兩個指針，一個用來遍歷，一個記錄當前字符前一次出現的下標pre，這個下標信息可以用一個HashMap記錄，只要當前字符在pre之后出現過，就將pre移動到出現的位置之后(因為這之間的子串都包含當前字符的重復，而子串不會是最長的)：
class Solution {
public int lengthOfLongestSubstring(String s) {
int result = 0;
HashMap<Character,Integer> preIdx = new HashMap<>();
for (int i=0, pre=0, length=s.length();i<length;i++) {
Integer p = preIdx.get(s.charAt(i));
if (p != null && p >= pre){
pre = p + 1;
}
result = Math.max(result,i-pre+1);
preIdx.put(s.charAt(i),i);
}
return result;
}
}
總結一下：
- 1和3都沒有一次找到最優方案，這兩個類似，都是用map存儲下標，因為查找起來復雜度為O(1)；
- 2是代碼冗余，遇到問題不要上來就寫循環，先理清楚思路，想想出入口；
- 不要想當然，確保正確性，細節問題、臨界點等要先想好；
- 遇到看都看不懂的，說明有模糊的知識點需要好好梳理了
