Linked List on 跟著 Desolve 學程式

從LeetCode學演算法 - 82 Linked List (10)

Thu, 09 Jan 2020 00:00:00 +0800

0086. Partition List (Medium)

寫在前面

再過兩天就是投票日了，懇請各位讀者們，
不論支持誰，都要好好地去了解候選人們及政黨的政見，
在1/11投下您寶貴的一票。**

筆者在這裡提醒大家去思考一下：
程式的世界很單純，很多東西不是True就是False，
而一個按照正常邏輯運行的程式，最終該呈現怎樣的結果，
大抵都是可以預期的。

想像一下，如果一個同事常常遲到早退，罔顧專案進度，
讓大家必須要幫忙收拾爛攤子；
話說的很滿，遇到事情卻推拖閃躲，
顧左右而言他的話，相信這樣的人，
我們不會希望其成為自己的頂頭上司。

既然如此，我們會希望這種人成為自己的大老闆嗎？

運用簡單的邏輯思考，相信聰明的各位都能得到正確答案。
儘管這種人的餅畫得再大再漂亮，我們知道，
那都不是真的，因為我們難以相信一個沒有誠信的人能夠說到做到。

Question

Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

Example:

1
2


Input: head = 1->4->3->2->5->2, x = 3
Output: 1->2->2->4->3->5

分析/解題

給定一個Linked List和一個值x，使用x來將所有節點進行分段，
令較x小的節點排在≥x的分段位置的前面。
注意在分段時，同時也要保有原先兩段的節點順序。

這題其實有點像是之前我們在講Merge Two Sorted Lists的感覺，
為了要能夠讓兩個段落分開且照順序，
我們應該要有兩個做為頭的dummy節點 ，稱為d1/d2。
所有小於x的部分都接到d1，反之則接到d2。
那麼實際上來說，我們只要將整個List遍歷過一遍，
就可以依照實際和x之間的比較，來決定要將這次看到的節點 ，
必須要接到d1還是d2上面。

由於最後我們需要將兩段接起來，
所以d1/d2保持不動的狀況下，
我們需要另一個變數來儲存現在遍歷的部份走到的節點，
先稱其為ite1/ite2，所以ite1/ite2起始分別是d1/d2。

那麼，按照邏輯來說，我們可以能會想到下面的寫法：

1
2
3
4


if (head.val < x) {
 　ite1.next = head;
 　ite1 = ite1.next;
}

但這麼考慮欠缺了一個條件：
當我們選定ite1.next = head時，head裡面還藏有它的next的資訊 ，
造成你以為是只有納入head，殊不知head.next也被隱含進去了 ！
要解決這個問題，我們可以將ite1.next重新設為null 。
問題來了，這一設為null，反而變成head的資訊就消失了 ，
同時head.next的資訊也消失了 。

所以，我們要一開始用一個nxt的ListNode來記錄head.next，
接下來兩種狀況下的next相關操作做完以後，
最後再讓head接上先前儲存的nxt。

依此，寫成程式碼。

Java

Java的部分，我們先用直觀的方式來處理，
所以包含前面的處理都完整的話，
我們應該能得到d1及其後面的一組(直到ite1)、
d2及其後面的另一組(直到ite2)，
若其中一個沒有接上任何節點的話，
可以直接吐出d1.next/d2.next 的狀況。
若兩者皆有，則先將第一排的結尾接給第二排的開頭 ，
最後回傳d1.next即可。

同時，運用陣列可以更輕鬆地化簡邏輯，
這裡將改善過後的版本放在註解欄中。

Python

就Python的部分而言，只要使用跟前述相近的處理方式，
最後再回傳d1.next 即可。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(1))

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium優惠(最後一波早鳥優惠了，不確定調回原價是什麼時候)： ** https://hiskio.com/courses/319?promo_code=VEQZV7E**

從LeetCode學演算法 - 80 Linked List (9)

Sat, 04 Jan 2020 00:00:00 +0800

0082. Remove Duplicates from Sorted List II (Medium)

Question

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

Example 1

1
2


Input: 1->2->3->3->4->4->5
Output: 1->2->5

Example 2

1
2


Input: 1->1->1->2->3
Output: 2->3

分析/解題

給定一個排序好的鏈結串列，將擁有重複的數字的節點全數刪去，
只保留原先在串列上相異的數字。

我們之前就嘗試過從鏈結串列刪去節點 的題目了，
只是今天這組更激進一點XD
原本是刪到剩一個即可，現在變成要將重複的全都刪掉，
那麼，該怎麼辦呢？

由於有可能刪到第一個，一般來說這種狀況，
習慣上會開出一個dummy node做為不會變動的節點參照，
我們先將其叫做dum，簡單將dum的next連接至head即可。

接下來要處理的是：我們要記得數值一致的節點群前面的那一個節點 ，
這樣刪去的時候才能將前後重新連接上。
因此，我們需要一個節點記錄，這裡將它叫做pre ；
另一個節點則做為迭代用，記錄現在所在的位置，將其稱做cur ，且就位置關係來說，pre的next應該會是cur 。
開始時pre的起始點 應該是dum ，這樣cur 會從head 開始，
當cur還沒走到底的時候要進行迴圈遍歷 。
另外在內部每次要迴圈檢查 ：
1. cur是否有下一個節點
且
2. cur的下一個節點和自己的值是否相等
(和先前一樣，這個迴圈用來略過所有重複值的節點 )

當走完以後有可能是

cur還沒到底(有值) =>
pre的next就是cur ，所以再往下找的話要將pre設為pre.next
cur已經碰到底了 (cur.next == null) =>
將pre.next指向null (pre.next = cur.next)

最後，別忘了將cur往下走(cur = cur.next) 。
最終做完的時候，由於先前我們將dum.next設定成head ，
中間連接有變動的話，會被pre的操作給連接過去，
所以新的head的位置不管有無更動，
應該還是位於dum.next上。
(因為pre一開始等於dum，pre.next一開始會連動到dum.next )

依此，寫成程式碼。

Java

Java的部分不要忘記該new的dum，
剩下就只有判斷null的時候不像Python可以直接用if not，
其他大多大同小異；Python的邏輯是一致的，就不再贅述說明了。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(1))

相似及延伸

這題理論上也可以用遞迴的方法解，有興趣的讀者可以嘗試看看。

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

從LeetCode學演算法 - 74 Linked List (8)

Mon, 16 Dec 2019 00:00:00 +0800

0234. Palindrome Linked List (Easy)

Question

Given a singly linked list, determine if it is a palindrome.

Example 1

1
2


Input: 1->2
Output: false

Example 2

1
2


Input: 1->2->2->1
Output: true

Follow up:
Could you do it in O(n) time and O(1) space?

分析/解題

給定一個單向鏈結串列，試判斷它是否是palindrome(回文)。
所謂palindrome就是從尾到頭和從頭到尾看起來會相同 。
在這題當中，由於我們的結構是Linked List，無法很輕鬆的到達尾端，
也無法輕易的回頭，那麼該怎麼辦呢？
要判斷回文有一個重點，就是從中間切開來兩邊是對稱的 。
因此，我們可以設定fast/slow的兩個pointer，
以之前常用的技巧，每次fast走兩步，slow走一步 ；
讓fast走到底時，slow剛好走到一半 。
節點總數是偶數時，切開來的第二段應該是從slow的下一個節點 開始，
所以當fast不是NIL 時，我們應該讓slow多走一步 。
(例如總共有10個節點，按上面的方法走完，
fast會在10，slow會在5，但第二段應該從6開始，所以slow要往下走一步)

所以比較「從slow到串列尾端的反轉串列 」及
「從head往下的對應節點 」，即可檢驗串列是否為回文。

那麼要怎麼反轉串列呢？上上篇文章 不就是嗎XD
我們可以用之前的reverse函數進行反轉，
反轉後再對兩個串列一一進行比較，
一旦值不相等即回傳false。

依此，寫成程式碼如下：

Java

我們也可以使用另一種思路，
先多設定一個rev節點，
在slow/fast行進時，將slow經過節點進行反轉連接，
這樣在走完的時候，讓rev 變成前半段反轉後的串列的開頭 ，
而slow 則是後半段的串列的開頭 。最後同樣一個一個檢查，
即可判斷整個串列是否是回文。

Python

務必請留意這麼做的缺點是整個串列就被我們拆成兩半了 ，
如果不是要求空間複雜度是O(1)的話，
用別的資料結構輔助去存入一半的節點，能夠保有原先的結構。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(1))

「如果不計較空間複雜度，有沒有辦法保留原先的linked list呢？」
(Python的話可以使用list來做兩邊儲存比較的動作，
或者要使用stack來置入前半段的節點，後面pop出來做比較也可以)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium限額5名優惠(額滿即截止)： https://hiskio.com/courses/319?promo_code=VE9NJQE

問卷抽書＆取得上架通知： https://pse.is/MS2J2
如果你對線上課程不放心，
也可以先來12/17(二) 我在天瓏分享的講座看看！
講座連結： https://pse.is/JS3LJ

從LeetCode學演算法 - 72 Linked List (7)

Mon, 02 Dec 2019 00:00:00 +0800

0206. Reverse Linked List (Easy)

Question

Reverse a singly linked list.

Example:

1
2


Input: 1->2->3->4->5->NULL
Output: 5->4->3->2->1->NULL

分析/解題

試反轉一個單向鏈結串列。
很久以前我們嘗試解過這題的較困難的版本
(0092. Reverse Linked List II (Medium))，
不過是透過stack的輔助，這題較為簡單，
我們來嘗試不使用其他資料結構來試試看吧XD！

先舉一個簡單的例子：
head -> a -> b -> c -> d -> NIL
這個單向鏈結串列在反轉的時候應該會變成：
NIL <- head <- a <- b <- c <- d

我們可以先看head, a, b這段，
在反轉時，我們要將head的next從a改成別的指向；
但如果先改掉的話，那就喪失掉a的位置了，
所以我們需要一個tmp來記錄a的位置，
再將head的next指向到前一個node (這邊一開始是NIL)，
最後讓tmp這個node做為下一個要處理的對象。
反覆處理，最終當head是null的時候，
回傳前一個node即為新的linked list的開頭(反轉前的尾端)。

所以以迭代法的步驟上會像這樣：

先宣告一個NIL的ListNode，我們命名為prev
當head非null時，進行迴圈：
2-1. 宣告一個節點n，位置指定到head的位置
2-2. head往下走到其next
2-3. n的next位置指定成prev
2-4. 再將prev的位置指定到n
迴圈完成後回傳prev即可

1

1. (prev=NIL) head -> a -> b ...

1
2


2. (n)
 (prev=NIL) head -> a -> b ...

1
2


2-3 (head)
 prev=NIL <- n a -> b ...

1

2-4 NIL <- prev head=a -> b ...

以第一輪的迴圈推導會如上面，讀者也可以自行嘗試推演看看。

若用遞迴的話也可以達到相同效果：

呼叫一個遞迴函式rev，將(null, head)做為參數傳入
(在rev中，參數為前一個節點prev，跟當前的節點n)
如果n為NIL的話則直接回傳prev
宣告一個tmp節點，其位置指定為n.next
再將n.next的位置指定給prev
回傳rev(n, tmp)

所以不論哪一種方式，
我們基本上都是使用宣告的節點去記錄next的部分，
再將當前的節點的next指向到prev，從而完成將鏈結反向的工作。

依此，寫成如下的程式碼：

Java

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(1))

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

從LeetCode學演算法 - 70 Linked List (6)

Wed, 20 Nov 2019 00:00:00 +0800

0203. Remove Linked List Elements (Easy)

Question

Remove all elements from a linked list of integers that have value *val *.

Example:

1
2


Input: 1->2->6->3->4->5->6, val = 6
Output: 1->2->3->4->5

分析/解題

題目要求將一個給定的linked list上值是val的所有元素均去除掉。

前面已經講過一些linked list的題目了，
在處理的重點上，不外乎就是在於如何進行遍歷，
以及移動和取代的不同，是很多人容易弄混的。

我們先假定有一組node的連結長這樣：
prev -> curr -> next

今天如果想要遍歷的話，我們應該做的事情是先宣告一個node，
並將prev的位置指定給node：

1
2
3
4
5
6


Java:
ListNode node = prev;
while (node != null) {
 System.out.println(node.val);
 node = node.next;
}

1
2
3
4
5


Python:
node = prev
while node:
 print(node.val)
 node = node.next

這當中，node = node.next的方式變動了node所指向的記憶體位址，
使其切換到下一個(也就是curr所在的位址)，但prev仍然在原地 。

回歸到題目本身，
題目要求的是跳過特定的val值，例如1->2->6->3，目標val是6。
遇到val值時，應該要將2的連接從6改到3 ，換言之，
當結點node走到2時，發現node.next.val跟目標val一樣，
連接上就會變成：
node.next = node.next.next

此外，為了要進行遍歷，所以每次node都需要往下一個前進，
在前一個狀況下已經確定了會將node.next接到node.next.next去了，
若val不同的話，則需要將node的位置移到下一個 去：
node = node.next

還有一個問題，就是如果一開頭的値就符合val的話，
刪去頭會導致原先的head消失，
為了避免麻煩，常見的做法是宣告一個dummy node，將其連接到head處。
中間不論如何都不去動dummy，結尾時再將dummy.next 回傳即可。

Java的部分，我們初始化一個dummy node並另開一個curr來進行移動。
**每次curr.next的値符合時，就將curr.next接到curr.next.next，
否則就讓curr往下走。**這麼一來，只要不斷檢查curr.next是否為NIL並遞進即可。

Java

Python的部分大同小異。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/ O(1))

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

我將於11/26 開設系列同名線上課程**「從Leetcode學演算法｜基礎篇」。** 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
問卷抽書＆取得上架通知： https://pse.is/MS2J2
Leetcode解題挑戰拿優惠： https://pse.is/NAUVP
如果你對線上課程不放心，
也可以先來12/17(二) 我在天瓏分享的講座看看！
講座連結： https://pse.is/JS3LJ

從LeetCode學演算法 - 44 Linked List (5)

Tue, 03 Sep 2019 00:00:00 +0800

0160. Intersection of Two Linked Lists (Easy)

Question

Write a program to find the node at which the intersection of two singly linked lists begins.

For example, the following two linked lists:

begin to intersect at node c1.

Example 1

1
2
3


Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
Output: Reference of the node with value = 8
Input Explanation: The intersected node's value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,0,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.

Example 2

1
2
3


Input: intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
Output: Reference of the node with value = 2
Input Explanation: The intersected node's value is 2 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [0,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.

Example 3

1
2
3
4


Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
Output: null
Input Explanation: From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values.
Explanation: The two lists do not intersect, so return null.

Notes:

If the two linked lists have no intersection at all, return null.
The linked lists must retain their original structure after the function returns.
You may assume there are no cycles anywhere in the entire linked structure.
Your code should preferably run in O(n) time and use only O(1) memory.

分析/解題

有兩個單向連結串列，試找出其交會開始的節點。
如果它們彼此之間沒有相交，則回傳null。
(注意中提到最好時間使用O(n)且空間僅使用O(1)。)

這題其實相當簡單，但要特別留意一點：
就算兩個節點的值相等，也並不代表它們是同一個節點。
從Example 1中就可以看到這個例子，
節點值都是1，但並非同節點，這部分要特別留意。
不過我們並未特別針對ListNode去實作相等的function的狀況下，
直接用**==** 判斷即可。

那麼，怎麼來找共同的交會節點呢？
我們可以先假設它們有一個交會點，
那麼list A跟list B在這個交會點(含)以後的節點數會相等。
(因為重合了XD)

所以比如說A總長度是9，B總長度是6，
我們可以先讓A從開頭走3步 ，(這樣才能對齊 )
接著兩邊開始依序走訪比對走到的節點是否交會，
若交會則回傳；若走到底還沒有看到相同的節點，
則回傳null(或None)。

所以大體上的操作如下：

設定iteA/iteB作為走訪list A/list B用的節點
先各自走訪過一輪來取得A和B分別的長度
長度相減，讓比較長的list的起始節點先多走相差的節點數
同時開始第二次的走訪，一邊比對節點是否交會，
是則回傳該節點，不是則走到至少一邊走完為止
若4走完尚未回傳則回傳null(表示沒有交會)

寫成程式碼如下。

Java

Python的部分可以寫得稍微簡潔一點，
留意用來遞進用的迴圈這裡的for會使用單底線，
因為我們只想要使用重複diff或-diff次的功能，
並不在意迴圈執行到第幾次。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N), O(1)，我們共遍歷了最多兩次的list，
且只有額外使用到幾個輔助用的節點和變數。)

相似及延伸

1.0599. Minimum Index Sum of Two Lists

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 31 Linked List (4)

Thu, 15 Aug 2019 00:00:00 +0800

0141. Linked List Cycle (Easy)

Question

Given a linked list, determine if it has a cycle in it.

To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.

Example 1

1
2
3


Input: head = [3,2,0,-4], pos = 1
Output: true
Explanation: There is a cycle in the linked list, where tail connects to the second node.

Example 2

1
2
3


Input: head = [1,2], pos = 0
Output: true
Explanation: There is a cycle in the linked list, where tail connects to the first node.

Example 3

1
2
3


Input: head = [1], pos = -1
Output: false
Explanation: There is no cycle in the linked list.

Follow up:

Can you solve it using O(1) (i.e. constant) memory?

分析/解題

給定一個Linked List，試檢查其是否含有一個環(Cycle) 在裡面。
我們有一小段時間沒有講Linked List，這邊不再贅述其基礎特性，
想要複習的讀者可以參閱第4篇的說明。

當我們在考慮這個題目的時候，會留意到兩個特性：

這個Linked List是指Single Linked List(也就是指向的方向只有單向)。
如果有環的話，應該會從最後一個節點再連接到前面的節點。
(從中間的話就會產生分歧的狀況)

在以上的特性狀況下，假設有一個環在Linked List中的話，
取一個節點從head開始不斷往其next走，會先經過最後一個節點，
接著再接回到前面某個節點再往下走，這樣會是一個循環；
更重要的是，顯然一進入這個環中，接下來就會一直在環內移動 。
(因為走到尾端又會再接回來)

這裡我們引入一個蠻常用的解題方式：設定快速和慢速的指標 。
我們讓fast和slow先設定在head的位置，每次fast走兩步，slow走一步 ，
它們就像是國小時針分針追趕的感覺一樣。

接下來我們可以將狀況分成以下兩種：

假設有環的狀況，
不管走多快多慢都會陷入這個環內 ，
所以會變成每次fast多走了一步，這一步用來追趕slow 。
因為slow也沒別的地方可以躲，所以fast每次多走一步一定可以趕得上
(也因為一步一步趕所以沒有追上卻錯開的可能)。
因此，我們知道fast和slow最終會來到相同的位置(也就是兩者相等 )
假設沒有環 的狀況，
由於不會重複，故最終fast一定會先走到尾端 ，最後看到NIL 。

故我們要做的事情很簡單，只要先設定fast跟slow，
在它們沒有走到NIL之前，每次去檢查fast是否有追上slow。
追上的話就回傳true ，而如果看到fast的下一個節點是NIL 的話，
就代表走到盡頭了 ，此時應該要回傳false 。

整個演算的順序：

考量起始的狀況，我們必須先檢查head跟head.next 當中是否有NIL值
開始一個迴圈，
開始前讓fast被設定為fast.next.next，slow則被設定為slow.next 。
當fast還沒有遇到NIL前，每次各自走相應步數，再檢查兩者是否相等。
(相等表示有環 ，回傳true )
請注意：當fast和fast.next 都處於非NIL 的狀況時，迴圈才能夠執行。
當fast或fast.next是NIL的話：表示走到盡頭了！跳離迴圈後，
將其return false 以表示它當中並沒有環。

寫成程式碼大概如下面所示：

Java

Python這邊額外提供了LeetCode使用者 StefanPochmann 的做法，
這個做法使用了try…except來進行錯誤處理，
有興趣的讀者不妨試試看。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N), O(1)
由於fast比slow每次多走一步，我們可預期在走環的部分時，為了相遇走的長度的複雜度為O(K)。那麼K最大也頂多就是囊括所有節點，
所以時間的複雜度最大就會取決於N 。
當然，還有另一種狀況是裡面沒有環 ，
時間複雜度也是O(N)。(走到底就結束了)
另外，我們沒有另外需要存下其他整個LinkedList的節點，所以僅有一些必要的節點被宣告，故空間複雜度為O(1))

相似及延伸：
1. ** 0142.** Linked List Cycle II

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 12 Linked List (3)/ Stack (1)

Fri, 12 Jul 2019 00:00:00 +0800

0092. Reverse Linked List II (Medium)

Question

Reverse a linked list from position m to n. Do it in one-pass.

Note: 1 ≤ m ≤ n ≤ length of the list.

Example:

1
2


Input: 1->2->3->4->5->NULL, m = 2, n = 4
Output: 1->4->3->2->5->NULL

分析/解題

給定一個linked list，在只經過一次的操作下(每個node不會額外再走訪)，
題目要求將m到n的位置的節點進行反轉。

由範例可知這邊的m跟n是以開頭為1而非0來計算，這點讀者請特別留意。

我們先從理論上來看這題應該怎麼處理：
首先根據題目要求，m可能和n相等，
相等的狀況下其實完全不用做事，回傳head即可。

那麼如果是不相等的狀況呢？
在Linked List中，要知道某個位置的節點為何，唯有從頭一路走到該節點 。
我們想要反轉的是mn的位置：
以範例來說，會將24的位置進行反轉。
如何反轉呢？首先我們要先走到2的左邊，當我們把中間的部分反轉後，
我們還要將它們和左右兩邊接起來，要記得2的左邊跟4的右邊的節點才行。
(不然接不起來就GG了XD)
這邊將2的左邊命名為left，一路往下走的迭代節點命名為node，
走到m-1以前先記錄下left節點，再繼續往下走。

接下來問題來了，如何將2~4的部分反向連接呢？
你可以選擇一個一個拆解並重新鍵結，
但這裡筆者想介紹一個常用的資料結構：Stack(堆疊，或稱棧/堆棧)。
Stack的樣子，就跟某些苦命的辦公室人員的書桌一樣：
你會嘗試將書桌上的文件/工作處理完，但老闆總是會往上面再加新的。 也就是說，每次如果你選擇從最上面開始拿 (別從中間或下面，這麼高的文件可是會塌的！)，你會拿到最新的 工作。

Stack也是如此，假設你將1, 2, 3, 4, 5依序放入Stack中，那麼當你從Stack裡面拿東西的時候，拿出來的順序會是5, 4, 3, 2, 1。最後放進去的會最先被拿出來 ，這樣子的特性我們稱之為Last In First Out(後進先出，簡寫為LIFO)。有另一種資料結構叫Queue(隊列，或稱佇列) 跟它剛好相反，是先進先出 ，我們以後找機會再講解它。

如果這題應用上Stack的話，就簡單許多：
我們將2~4的部分通通丟進Stack中，再一個一個拿出來 ，
這時候順序就會變成4, 3, 2了！那麼，只要將剛剛存好的left，以及後面我們邊走邊看到4的時候，將它的右邊記錄起來的node，兩者再和中間的節點連結起來，就完成整個反轉的流程。

重新整理解題的順序：

判斷m是否和n相等，相等則直接回傳原先的head。
定義一個迭代用節點node，先走到m-1的位置以取得節點left。
讓node從m一路走到n，將每個node放入到Stack中。
(註:放入的術語在堆疊中叫作push)
node再額外走一步會走到n+1的位置
依次將Stack中的節點取出，並且依序連接所有節點的next，
直到Stack中再也沒有節點。
(註:取出的術語在堆疊中叫做pop)
將反轉完的尾巴和node做連接，結束整個反轉的流程。

這當中還有額外一點需要注意的是m=1 的狀況，
因為我們最後回傳的是用head 來代表整個linked list，
如果m為1的話，代表head其實已經被改變了，
我們需要同步更新head的部分。

請參照Java的寫法，我們採用了l1和l2兩個節點來處理依序連接的部分。
我們會先取出堆疊中第一個節點，這個節點會被left連接，
接下來使用l2 = st.pop(); l1.next=l2; l1 = l2;
來進行一次取一個node，將前後連接好以後，
將位置移到下一個準備連接的點。
也就是說，每次l1所在的位置，都是當前準備進行連接next的節點 。
(若讀者對這邊的說明感到抽象，請務必在紙上試著操作一下會較清楚)

在Java中，Stack的宣告方式是：

1

Stack<> st = new Stack<>();

請在"<>“之中填入你想要使用的資料型態，
在本例中為題目已經定義的class ListNode。

函式用法的部分，push()用來放入節點，pop()用來取出節點，
isEmpty()則是檢查Stack是否是空的。
(還有一個peek()，是用來看Stack最上面節點，
但不會真的將節點從Stack中移除)

Java

在Python中，list的特性可以方便的用來當作Stack使用，
放入節點可以使用append()，取出節點使用pop()。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N), O(n-m)，因為我們的堆疊最多只需要存中間的部分和兩旁的node)

「可以只用O(1)的空間嗎？」
(可以，如果我們按順序一個一個處理m~n之間的連結，
最後再將n和m和左右兩邊連起來，是可以不使用Stack的
中間的連接方式會像是：

1
2
3
4


third = cur.next
cur.next = prev
prev = cur
cur = third

讀者有興趣的話可以嘗試看看。)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 10 Linked List (2)

Wed, 10 Jul 2019 00:00:00 +0800

0083. Remove Duplicates from Sorted List (Easy)

Question

Given a sorted linked list, delete all duplicates such that each element appears only once.

Example 1

1
2


Input: 1->1->2
Output: 1->2

Example 2

1
2


Input: 1->1->2->3->3
Output: 1->2->3

分析/解題

題目給定一個已排序好的linked list，要求將所有重複的node皆刪除，
使得每個元素均只出現一次。

這題也算是比較簡單的linked list類型，只要確定連接正確的話並不難解。
由於已經排序過的原因，所有會重複的元素值均會相鄰，那麼我們所要做的就是遇到重複時總共只保留一個就好了 。
保留哪一個呢？當然是保留第一個囉！

我們可以先宣告一個ListNode，命名為ite用來做為iterator(迭代器)，
每次取得ite的下一個node(命名為tmp)做為暫存。
接下來開始一路往下尋找，如果ite和tmp前後值相等時，就讓tmp開始往下一直走到底部(表示後面值都一樣) 或者找到下一個不同的值。 對於前者的狀況 而言，表示結束，tmp會指到null(或None)，
只要將ite.next指向到tmp 即可。

對於後者的狀況 ，這時候tmp的位置就在下一個相異值的點 。
像是1->2->2->2->3->4這樣子，從ite在碰到第一個2以後，
tmp會一路找到3的位置，所以我們只要將ite.next指向到tmp ，
即可將第一個2接到3的位置，從而中間的部分就等於被我們刪去了。

討論完兩者狀況後，我們會發現無論是哪一種，
結果都會是將ite.next指向到tmp，
最後要記得ite本身要遞移到下一個開始找的位置，
所以我們還需要將tmp的位置交給ite。

Java

以Python的部分來說，還記得判斷式可以直接適用於if的話，
就可以寫得看起來簡潔一些。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N), O(1))

其它應該沒什麼好問的，至少我沒想到XD
這篇主要是協助讀者再熟悉一下這些連接/斷開的操作。

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 4 Linked List (1)

Mon, 01 Jul 2019 00:00:00 +0800

0021. Merge Two Sorted Lists (Easy)

Question

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

Example:

1
2


Input: 1->2->4, 1->3->4
Output: 1->1->2->3->4->4

分析/解題

題目要求將兩個已排序的linked lists合併，
且所產生的新list必須由原有的節點(node)所構成。

Linked List是一個很常見的資料結構，資料與資料連接的方式是單向的，
通常從第一個節點(node)往後連接到最後一個節點(node)。
每個節點上會存放一個(或一組)資料以及連結(link)，
每個連結會指向到下一個節點 的位置(記憶體位址)。
(在C/C++裡面連結基本上就是指標(pointer))

你可能會問，那麼最後一個節點呢?
最後一個節點除了儲存資料以外，因為連結沒有東西了，所以會給定空值。在演算法的書中一般會稱為NIL ，NIL在英文裡面就是nothing 的意思，
表示沒有任何東西。

在Java中有LinkedList的資料結構，它同樣是List的一種。
但一般遇到題目的時候會給的通常是一個node，
用來指向到該List的第一個節點。

我們會看到如果你打開LeetCode選擇Java時，
上方已經先用註解告訴你這個ListNode的結構了：

1
2
3
4
5
6
7
8


/**
 * Definition for singly-linked list.
 * public class ListNode {
 * int val;
 * ListNode next;
 * ListNode(int x) { val = x; }
 * }
 */

也就是說，題目預先定義了一個class叫做ListNode，
val用來存放每個node的值，next用來指向到下一個node ，
有一個ListNode(int x) 的建構子(constructor)，
可以讓你在產生一個新的節點時給定其值。

對於LinkedList來說，它最大的好處在於新增/刪除節點時相當方便。
例如現在有a->b，我想要加一個資料值為20的c節點，放在b後面的話，
以Java而言只需要:

1
2
3


ListNode b = a.next; // 因為一開始我們只知道a的位置而已XD
ListNode c = new ListNode(20);
b.next = c;

如果是插入在a跟b中間呢？也不難，
只是我們要先記住b，不然一旦沒有人記它，它就消失在時空裂縫中了(誤)
(會依照各自編譯器的規範，只是以我們而言是真的就沒辦法找到它了)

1
2
3
4
5


// a -> c -> b
ListNode b = a.next;
ListNode c = new ListNode(20);
a.next = c;
c.next = b;

請留意如果你調動了一些節點的順序，留意他們的next是否被妥善處理，
該被清空的請給定NIL。在Java中是用null來表示，而Python則是用None。 回到題目，我們該如何去合併排列好的兩個LinkedList呢？
這邊提供一個很簡單的遞迴思路。
(遞迴的概念，我們之後再專門做一篇相關的來講解)
我們合併兩個list的狀況目標還是要呈現排序好的樣子，
那麼怎麼排呢？
由於原先的list已經是排好的，
我們拿出最左邊的node比較，稱為l1跟l2。
l1是全空的狀況下，那其實答案就是l2(因為後面就不用繼續排了)，
反之l2是全空的話，答案就是l1。
那麼如果l1的值小於l2的值的話，那麼l1應該要當頭，
接下來我們要拿l1.next 跟l2 來做比較大小，比較小的，
就會是新的l1連接的下一個節點。
一直連接到最後，我們就可以得到合併好的list了！
相等的狀況因為題目沒有特別要求要分辨是l1還是l2的節點，
所以任取一個均可。

例：
l1: 1 -> 3 -> 5 ->8 ->10, l2: 2 -> 4 -> 4
1先跟2比，1比較小所以當頭(1) ->
3跟2比，2比較小(1->2) ->
3跟4比(1->2->3) ->
5跟4比(1->2->3->4) ->
5跟4比(1->2->3->4->4) ->
l2的部分已經空了，填入l1中5以後剩下的部分
(1->2->3->4->4-> 5 ->8 ->10)

寫成Java的程式如下。

Java:

當然我們也可以用迴圈(迭代)的方法來解，
但這時候我們就要比較仔細的去處理節點間的關係了。
在Python中判斷是否為None可以使用if，
通過if的話節點就代表該節點是有值的，
你也可以加入not的關鍵字來處理你所需要的判斷式。
比如我可以用if not (l1 and l2)來表達其中一個以上是空的狀況，
並回傳不是None的那個node。

操作上，我們需要一個dummy node做為旁觀者，
讓它從頭到尾都只保持在同樣的位置 ，並指向到第一個節點。

接著我們定義一個節點叫做prev，
prev的next 會指定給下一個比較過後較小的那個節點 。
那麼，每次將prev的next拿到以後，
l1或l2(看哪個比較小)就自己遞移到下一個節點 ，
並且prev也往下走到自己的next，準備接取下一個節點；
重覆上面的動作直到其中一邊節點用光 ，
即可把剩下的直接全接到prev.next上。

最終我們回傳的答案是dum.next ，因為只有dum沒有被動過，
其他的節點其實都已經被改動過指向的位址了。

Python

在有關linked list的部分，因為牽扯到位址的概念，
所以操作上要稍微再思考一下，比較不容易搞混。
最重要的是，對於Java和Python來說，由於所使用的都是class來建立node，
所以其實你看到的等號，除了給定val的狀況以外，
其他其實都是在做把右邊放的記憶體位址存到左邊 的動作，
所以指向的記憶體位址變了，代表的節點也就跟著變了 ，務必要留意這點。

面試實際可能會遇到的問題

「請用iterative(迭代或迴圈)/recursive(遞迴)的方式來解」
(上面Java是recursive solution，Python是iterative solution，
讀者可以嘗試改成另一個語言試看看)

「使用遞迴的話會有什麼限制？」
(有可能受到編譯器規範的最大function stack上限限制，
同時，連續的函式呼叫的效率，相對於在迴圈中執行來說會較差)

「那為什麼你會用遞迴？」
(因為遞迴比較好想啊XDDDDD)(別這麼誠實，雖然大家都知道XD)
(因為在一般狀況下，遞迴解通常會較為容易閱讀，
也比較符合人類的思路模式，就像推骨牌一樣，
當起始條件和後續的脈絡定下來以後，後面的結果就會水到渠成。)

「時間複雜度是？」
( worst case是O(N1+N2)，best case是O(min(N1, N2))。)

「如果希望你另外開一個新的linked list，不用原本的節點來解這題呢？」
(這樣會比較簡單，一樣兩兩比較，但改成較小的取其val來產生一個新的ListNode，接在你的新的linked list後面，讀者可以嘗試看看，
別忘記要留dummy node歐！)

從LeetCode學演算法，我們下次見囉，掰~