### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

- 本文是《LeetCode第三題(Longest Substring Without Repeating Characters)三部曲》的第三篇，之前的兩篇文章列出了思路並寫出了Java程式碼，雖然在LeetCode網站提交透過，但是成績並不理想，40多毫秒的速度，與諸多優秀的方案有不小差距，
今天就來一起最佳化程式碼，提升速度；

### 三部曲完整連結
1. [《LeetCode第三題(Longest Substring Without Repeating Characters)三部曲之一：解題思路》](https://blog.csdn.net/boling_cavalry/article/details/86563586);
2. [《LeetCode第三題(Longest Substring Without Repeating Characters)三部曲之二：編碼實現》](https://blog.csdn.net/boling_cavalry/article/details/86654969);
3. [《LeetCode第三題(Longest Substring Without Repeating Characters)三部曲之三：兩次最佳化》](https://blog.csdn.net/boling_cavalry/article/details/86655675);

### 原有程式碼
- 這裡再回顧一下原有程式碼：

```java
public int lengthOfLongestSubstring(String s) {
        //視窗的起始位置,視窗的結束為止,最長記錄
        int left = 0, right = 0, max = 0;

//表示視窗內有哪些值
        Set<character> set = new HashSet<>();

while (right < s.length()) {
            //例如"abcdc"，視窗內是"abcd"，此時right等於[4],
            //發現視窗內有array[right]的值，就縮減視窗左邊，
            //縮到窗內沒有array[right]的值為止，
            //當left一路變大，直到left=3的時候，視窗內已經沒有array[right]的值了
            if (set.contains(s.charAt(right))) {
                //假如視窗內是"abc"，當前是"c"，那麼下面的程式碼只會將"a"刪除,left加一，再次迴圈
                //而新一次迴圈依舊發現"c"還在set中，就再把"b"刪除，left再加一...
                set.remove(s.charAt(left++));
            } else {
                //視窗內沒有array[right]的時候，就把array[right]的值放入set中，表示當前視窗內有哪些值
                set.add(s.charAt(right++));

if ((right - left) > max) {
                    max = right - left;
                }
            }
        }

return max;
    }
```

### 第一次最佳化
- 這次的重點是HashSet物件，此物件儲存視窗中的所有元素，每加入一個新元素之前都檢查HashSet中是否存在該元素；

- 如下圖所示，程式碼中透過**set.add**和**set.remove**方法將HashSet中的內容始終與視窗中的內容保持一致：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190126120126708.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 最佳化前：判斷一個元素是否在視窗中，現在的做法是以HashSet中為準，當判定某個元素要從視窗中移除，就呼叫HashSet的remove方法從HashSet中刪除；
- 上述的程式碼可以最佳化，最佳化後可以不用執行HashSet的remove方法，具體的邏輯是使用HashMap替代HashSet，HashMap的key是字串的元素，value是元素在陣列中的位置，舉個例子，當left=1，right=3時，整體的效果是下圖這樣的，HashMap中已經儲存了"a"、"b"、"c"三個元素作為key，而value就是它們在陣列中的下標：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/2019012614212375.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 現在要檢查陣列中下標為4的元素"b"：以"b"為key查詢HashMap，如果不存在就表示不在視窗中，如果存在，就用對應的value=1去和left比較，如果小於left就表示不在視窗中，如果大於或者等於left就表示在視窗中，如下圖所示：

![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190126143223486.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 這裡要注意的是：hashmap中任意一個value，表示的是某個元素在**整個陣列**中的位置，而不是在視窗中的位置，因為程式中不會對hashmap做remove操作；
- 接著上面的圖分析，"b"元素被發現在視窗中存在後，除了將left調整為2，right調整為4，還要呼叫HashMap的put方法，將"b"元素的位置從原來的1更新為4；
- 另外還有個最佳化點：假設當前視窗中是"abc"，而檢查的元素是"b"，之前的程式碼中，要執行兩次迴圈：先刪除"a"，left加一，再刪除"b"，left再加一，現在用了HashMap就能得到"b"的位置，直接將left改為"b"的下一個位置即可，不需要執行兩次迴圈了；
- 以上就是最佳化思路了，用HashMap取代HashSet，不再執行remove方法，對程式碼的調整並不大，調整後的完整程式碼如下：

```java
public int lengthOfLongestSubstring(String s) {
        int left =0, right =0, max = 0;
        Map<character> map = new HashMap<>();
        while (right<s.length if="" int="" pos="map.get(s.charAt(right));">=left){
                	//注意這又是個最佳化點，假設當前視窗中是"abc"，而檢查的元素是"b"，
                	//之前的程式碼中，要執行兩次迴圈：先刪除"a"再刪除"b"，
                	//現在用了HashMap就能得到"b"的位置，直接將left改為"b"的下一個位置即可，不需要執行兩次迴圈了
                    left = pos + 1;
                }
            }
            map.put(s.charAt(right), right++);
            if((right-left)>max){
                max = right-left;
            }
        }

return max;
    }
```

- 提交上述程式碼到LeetCode，這次的成績是27毫秒，比之前好了不少，如下圖：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190126145012608.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 然而，這個成績依然很平庸，因為它還有可最佳化之處，接下來再次最佳化；

### 第二次最佳化
- 第一次的最佳化點是消除remove方法和while迴圈次數，第二次最佳化則是針對HashMap，每次處理新的元素都涉及到HashMap的操作，如果您對HashMap的內容有所瞭解，就知道計算hashcode、建立EntrySet，呼叫equals方法這些操作會被頻繁執行，如果能省去這些操作，那麼效能應該會有明顯提升，問題是：如何才能去掉HashMap而不影響功能呢？
- 我們先明確HashMap在程式中的作用：**儲存一個元素在陣列中的位置**，所以最佳化的方向就是尋找HashMap的替代品；
- 假設一共可能出現二十六種字元：從"a"到"z"，那就簡單了，用一個長度為26的int陣列來記錄每個字元的位置，array[0]的值就是元素"a"的位置，array[1]的值就是元素"b"的位置，array[2]的值就是元素"c"的位置，如下圖所示，圖中的數字97是"a"的ASCII碼：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190126161315129.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 按照上面的設計，array[0]=3就表示"a"元素在整個陣列中最後一次出現的位置是3，array[1]=1表示"b"元素在整個陣列中最後一次出現的位置是1，array[2]=2就表示"c"元素在整個陣列中最後一次出現的位置是2，如下圖：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190126161700850.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 按照以上設計是不是就可以立即編碼並提交到LeetCode了呢？我當時就是這麼做的，很不幸因為測試沒有透過而提交失敗了，沒透過的原因是：字串中不僅會有"a"到"z"的小寫，還有大寫字母、空格字元、加減乘除等字元，遇到這些字元時，我們之前設計的長度26的陣列就不夠用了，看來要重新設計陣列；

- 新的陣列總長度是95，這是因為所有英文可見字元一共是95個，從空格開始，到"`"結束，如下圖的三個紅框所示：

![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190126162456462.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 如上所示，長度為95的陣列，可以將所有可見字元都納入進來，array[0]儲存的是空格字元的位置，因此計算字元"a"在array陣列中的下標就從之前的**'a'-97=0**變成了**'a'-32=65**；

- 另外要注意的是，這個陣列中每個元素初始值都是**-1**，表示字串中沒有這個元素(或者說還沒有處理到)；
- 按照上述思路最佳化後的程式碼如下所示，可見改動並不大，只是把HashMap相關的地方全部改成了上述的陣列邏輯：

```java
public int lengthOfLongestSubstring(String s) {
        int left =0, right =0, max = 0;

int[] array = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                -1, -1, -1, -1, -1};

int offset;
        while (right<s.length offset="s.charAt(right)" if="">-1){
                int pos = array[offset];

if(pos>=left){
                    left = pos + 1;
                }
            }

array[offset] = right++;

if((right-left)>max){
                max = right-left;
            }
        }

return max;
    }
```
- 將以上程式碼提交到LeetCode，順利透過，成績提升到17ms，超過了99.94%的java方案，如下圖：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190120165602563.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 最終效果證明這次最佳化的方向和結果都是正確的，之前已經有朋友問過最佳化思路從何而來，其實靈感來自**桶排序**，思想是類似的；

- 至此，LeetCode第三題的解題思路、編碼實現、最佳化實戰就全部完成了，希望能給讀者您在解題過程中帶來一些參考，刷題之路，大家一起努力！

### 歡迎關注ITpub：程式設計師欣宸
> [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</s.length></s.length></character></character>

LeetCode第三題三部曲之三：兩次最佳化

相關文章