精選挑選了9道連結串列相關是演算法題，每道都給出了對應的解答以及技巧，看完這些連結串列問題，相信你再也不怕連結串列問題了，建議點贊、收藏。
為了方便大家查詢，我這裡先給出個目錄
1、如何優雅著反轉單連結串列
2、環形單連結串列約瑟夫問題最優解
3、三種方法帶你優雅判斷迴文連結串列
4、刪除單連結串列的中間節點
5、將單向連結串列按某值劃分成左邊小，中間相等，右邊大的形式
6、複製含有隨機指標節點的連結串列
7、將單連結串列的每K個節點之間逆序
8、將搜尋二叉樹轉換成雙向連結串列
9、刪除單連結串列的第 K個節點
更多演算法問題，大家也可以關注我的公眾號：苦逼的碼農，主要寫演算法、計算機基礎之類的文章，裡面已有100多篇原創文章
1、如何優雅著反轉單連結串列
【題目描述】
反轉單連結串列。例如連結串列為：
1->2->3->4
反轉後為
4->3->2->1
【要求】
如果連結串列的長度為 N, 時間複雜度達到 O(N), 額外空間複雜度達到 O(1)
【解答】
方法1
這道題還是挺簡單的，當我們在反轉一個節點的時候，把一個節點的後驅改為指向它前驅就可以了。這裡需要注意的點就是，當你把當前節點的後驅指向前驅的時候，這個時候連結串列會被截斷，也就是說後面的節點和當前節點分開了，所以我們需要一個變數來儲存當前節點的後驅，以訪丟失。
具體程式碼如下：
程式碼如下
//節點
class Node{
public int value;
public Node next;
public Node(int data) {
this.value = data;
}
}
複製程式碼 //反轉單連結串列
public static Node reverseList(Node head) {
Node next = null;//指向當前節點的後驅
Node pre = null;//指向當前節點的前驅
while (head != null) {
next = head.next;
//當前節點的後驅指向前驅
head.next = pre;
pre = head;
//處理下一個節點
head = next;
}
return pre;
複製程式碼方法二
這道題也可以用遞迴來做，假設 方法 reverse() 的功能是將單連結串列進行逆轉。採用遞迴的方法時，我們可以不斷著對子連結串列進行遞迴。例如對於如下的連結串列：
我們對子連結串列 2->3->4 進行遞迴，即 Node newList = reverse(head.next)。遞迴之後的結果如下：
逆轉之後子連結串列 2->3->變為了 4->3->2。 注意，我剛才假設 reverse() 的功能就是對連結串列進行逆轉。不過此時節點 1 仍然是指向節點 2 的。這個時候，我們再把節點1 和 2逆轉一下，然後 1 的下一個節點指向 null 就可以了。如圖：
遞迴的結束條件就是：當子連結串列只有一個節點，或者為 null 時，遞迴結束。程式碼如下：
//用遞迴的方法反轉連結串列
public static Node reverseList2(Node head){
if (head == null || head.next == null) {
return head;
}
//遞迴反轉子lian連結串列
Node newList = reverseList2(head.next);
//第三張圖
head.next.next = head;
head.next = null;
return newList;
}
複製程式碼問題擴充
題目：反轉部分連結串列節點
【題目描述】
題目：給定一個單向連結串列的頭結點head,以及兩個整數from和to ,在單項鍊表上把第from個節點和第to個節點這一部分進行反轉
列如： 1->2->3->4->5->null,from=2,to=4
結果：1->4->3->2->5->null
列如：
1->2->3->null from=1,to=3
結果為3->2->1->null
【要求】
1、如果連結串列長度為N，時間複雜度要求為O（N),額外空間複雜度要求為O（1）
2、如果不滿足1<=from<=to<=N,則不調整
【解答】
這個就直接扔出程式碼了
public static Node reversePart(Node head, int from, int to) {
int len = 0;//記錄連結串列的長度
Node node1 = head;
Node fPre = null;//指向第 from-1個節點
Node tPos = null;//指向第 to + 1個節點
while (node1 != null) {
len++;
if(len == from - 1)
fPre = node1;
if(len == to + 1)
tPos = node1;
node1 = node1.next;
}
//判斷給定的值是否合理
if(from > to || from < 1 || to > len)
return head;
//把from-to這部分連結串列進行反轉
//node1指向部分連結串列的第一個節點
node1 = fPre == null ? head : fPre.next;
Node cur = node1.next;//cur指向當前要處理的節點
node1.next = tPos;//先把第一個節點給反轉處理了
Node next = null;
while (cur != tPos) {
next = cur.next;//儲存當前節點的下一個節點
cur.next = node1;
node1 = cur;
cur = next;
}
if (fPre != null) {
fPre.next = node1;
return head;
}
return node1;
}
複製程式碼想學習演算法大家也可以關注公眾號「苦逼的碼農」，主要寫演算法、計算機基礎之類的文章，裡面已有100多篇原創文章哦。
2、環形單連結串列約瑟夫問題
【題目描述】
【要求】
輸入：一個環形單向連結串列的頭節點 head 和報數 m.
返回：最後生存下來的節點，且這個節點自己組成環形單向連結串列，其他節點都刪除掉。
【解答】
方法1：時間複雜度為 O( n * m)
這道題如果不考慮時間複雜度的話還是挺簡單的，就遍歷環形連結串列，每遍歷 m 個節點就刪除一個節點，知道連結串列只剩下一個節點就可以了。
程式碼如下
//時間複雜度為O(n*m)的解決方法
public static Node josephusKill(Node head, int m) {
if(head == null || m < 1)
return head;
Node last = head;
//定位到最後一個節點
while (head.next != last) {
head = head.next;
}
System.out.println(head.value);
int count = 0;
while (head.next != head) {
if (++count == m) {
head.next = head.next.next;
count = 0;
} else {
head = head.next;
}
}
return head;
}
複製程式碼這個方法的時間複雜度為 O(n * m)。下面用時間複雜度為方法解決。
方法二：時間複雜度為 O(n)
這個方法的難度為：
校：★★★☆
我們可以給環形連結串列的節點編號，如果連結串列的節點數為 n, 則從頭節點開始，依次給節點編號，即頭節點為 1， 下一個節點為2， 最後一個節點為 n.
我們用 f(n) 表示當環形連結串列的長度為n時，生存下來的人的編號為 f(n)，顯然當 n = 1 時，f(n) = 1。假如我們能夠找出 f(n) 和 f(n-1) 之間的關係的話，我們我們就可以用遞迴的方式來解決了。我們假設 人員數為 n, 報數到 m 的人就自殺。則剛開始的編號為
...
m - 2
m - 1
m
m + 1
m + 2
...
進行了一次刪除之後，刪除了編號為m的節點。刪除之後，就只剩下 n - 1 個節點了，刪除前和刪除之後的編號轉換關係為：
刪除前 -------- 刪除後
... ---------- ...
m - 2 ------- n - 2
m - 1 ------ n - 1
m ---------- 無(因為編號被刪除了)
m + 1 ------ 1(因為下次就從這裡報數了)
m + 2 ------ 2
... -------- ...
新的環中只有 n - 1 個節點。且編號為 m + 1, m + 2, m + 3 的節點成了新環中編號為 1， 2， 3 的節點。
假設 old 為刪除之前的節點編號， new 為刪除了一個節點之後的編號，則 old 與 new 之間的關係為 old = (new + m - 1) % n + 1。
注：有些人可能會疑惑為什麼不是 old = (new + m ) % n 呢？主要是因為編號是從 1 開始的，而不是從 0 開始的。如果 new + m == n的話，會導致最後的計算結果為 old = 0。所以 old = (new + m - 1) % n + 1.
這樣，我們就得出 f(n) 與 f(n - 1)之間的關係了，而 f(1) = 1.所以我們可以採用遞迴的方式來做。
程式碼如下：
//時間複雜度為O(n)
public static Node josephusKill2(Node head, int m) {
if(head == null || m < 1)
return head;
int n = 1;//統計一共有多少個節點
Node last = head;
while (last.next != head) {
n++;
last = last.next;
}
//直接用遞迴算出目的編號
int des = f(n, m);
//把目的節點取出來
while (--des != 0) {
head = head.next;
}
head.next = head;
return head;
}
private static int f(int n, int m) {
if (n == 1) {
return 1;
}
return (getDes(n - 1, m) + m - 1) % n + 1;
}
複製程式碼問題擴充
對於上道題，假設是從第 K 個節點開始報數刪除呢？ 又該如何解決呢？
3、三種方法帶你優雅判斷迴文連結串列
【題目描述】
給定一個連結串列的頭節點 head, 請判斷該連結串列是否為迴文結構。
例如：
1->2->1，返回 true.
1->2->2->1, 返回 true。
1->2->3，返回 false。
【要求】
如果連結串列的長度為 N, 時間複雜度達到 O(N)。
【解答】
方法1
我們可以利用棧來做輔助，把連結串列的節點全部入棧，在一個一個出棧與連結串列進行對比，例如對於連結串列 1->2->3->2->2，入棧後如圖:
這種解法比較簡單，時間複雜度為 O(n), 空間複雜度為 O(n)。
程式碼如下
//方法1
public static boolean f1(Node head) {
if (head == null || head.next == null) {
return true;
}
Node temp = head;
Stack<Node> stack = new Stack<>();
while (temp != null) {
stack.push(temp);
temp = temp.next;
}
while (!stack.isEmpty()) {
Node t = stack.pop();
if (t.value != head.value) {
return false;
}
head = head.next;
}
return true;
}
複製程式碼方法二
真的需要全部入棧嗎？其實我們也可以讓連結串列的後半部分入棧就可以了，然後把棧中的元素與連結串列的前半部分對比，例如 1->2->3->2->2 後半部分入棧後如圖：
然後逐個出棧，與連結串列的前半部分(1->2)對比。這樣做的話空間複雜度會減少一半。
程式碼如下：
//方法2
public static boolean f(Node head) {
if(head == null || head.next == null)
return true;
Node slow = head;//慢指標
Node fast = head;//快指標
Stack<Node> stack = new Stack<>();
//slow最終指向中間節點
while (fast.next != null && fast.next.next != null) {
slow = slow.next;
fast = fast.next.next;
}
System.out.println(slow.value);
slow = slow.next;
while (slow != null) {
stack.push(slow);
slow = slow.next;
}
//進行判斷
while (!stack.isEmpty()) {
Node temp = stack.pop();
if (head.value != temp.value) {
return false;
}
head = head.next;
}
return true;
}
複製程式碼**方法三：**空間複雜度為 O(1)。
上道題我們有作過連結串列的反轉的，沒看過的可以看一下勒：【連結串列問題】如何優雅著反轉單連結串列]，我們可以把連結串列的後半部分進行反轉，然後再用後半部分與前半部分進行比較就可以了。這種做法額外空間複雜度只需要 O(1), 時間複雜度為 O(n)。
程式碼如下:
//方法3
public static boolean f2(Node head) {
if(head == null || head.next == null)
return true;
Node slow = head;//慢指標
Node fast = head;//快指標
//slow最終指向中間節點
while (fast.next != null && fast.next.next != null) {
slow = slow.next;
fast = fast.next.next;
}
Node revHead = reverse(slow.next);//反轉後半部分
//進行比較
while (revHead != null) {
System.out.println(revHead.value);
if (revHead.value != head.value) {
return false;
}
head = head.next;
revHead = revHead.next;
}
return true;
}
//反轉連結串列
private static Node reverse(Node head) {
if (head == null || head.next == null) {
return head;
}
Node newHead = reverse(head.next);
head.next.next = head;
head.next = null;
return newHead;
}
複製程式碼問題擴充
思考：如果給你的是一個環形連結串列，並且指定了頭節點，那麼該如何判斷是否為迴文連結串列呢？
4、：刪除單連結串列的中間節點
【題目描述】
給定連結串列的頭節點head，實現刪除連結串列的中間節點的函式。
例如：
步刪除任何節點；
1->2，刪除節點1；
1->2->3，刪除節點2；
1->2->3->4，刪除節點2；
1->2->3->4-5，刪除節點3；
【要求】
如果連結串列的長度為 N, 時間複雜度達到 O(N), 額外空間複雜度達到 O(1)
【解答】
這道題要求刪除中間節點，我們可以採用雙指標的方法來做，就是用一個快指標和一個慢指標，快指標每次前進兩個節點，而慢指標每次前進一個節點。當快指標遍歷完節點時，慢指標剛好就在中間節點了。之前寫過一篇一些演算法的常用技巧也有所過指標使用的一些技巧。
不過在做的時候，最好是先把一些特殊情況先處理好，例如刪除的可能是第一個節點，也有可能不用刪除節點(只有一個節點時就不用刪除了。
程式碼如下
public static Node removeMidNode(Node head) {
if(head == null || head.next == null)
return head;
if (head.next.next == null) {
return head.next;
}
Node fast = head.next.next;//快指標
Node slow = head;//慢指標
//slow最終指向中間節點的前驅
while (fast.next != null && fast.next.next != null) {
slow = slow.next;
fast = fast.next.next;
}
//進行刪除
slow.next = slow.next.next;
return head;
}
複製程式碼上次拿到刪除倒數第 K 個節點的題其實也是可以使用雙指標的，但個人認為，那道題使用雙指標的方法並沒有我上次那個做法優雅，而這次刪除中間節點，則用雙指標比較優雅。至於原因，可以自己打下程式碼看看
問題擴充
題目：刪除連結串列中 a / b 處的節點
【題目描述】
給定連結串列的頭節點 head、整數 a 和 b，實現刪除位於 a/b 處節點的函式。
例如：
連結串列：1->2->3->4->5，假設 a/b 的值為 r。
如果 r = 0，不刪除任何節點；
如果 r 在區間 (0,1/5] 上，刪除節點 1；
如果 r 在區間 (1/5,2/5] 上，刪除節點 2；
如果 r 在區間 (2/5,3/5] 上，刪除節點 3；
如果 r 在區間 (3/5,4/5] 上，刪除節點 4；
如果 r 在區間 (4/5,1] 上，刪除節點 5；
如果 r 大於 1，不刪除任何節點。
【要求】
如果連結串列的長度為 N, 時間複雜度達到 O(N), 額外空間複雜度達到 O(1)
【解答】
可以自己動手做一下或者想一下，我直接扔程式碼了
//這道題可以轉換為刪除第 K = (a * n / b)個節點。其中n表示連結串列節點
//的個數，但由於(a * n / b)有可能出現小數，所以我們取 K的上限。
//所謂上限就是大於等於K的最小整數。
public static Node removeByRatio(Node head, int a, int b) {
if(a < 1 || a > b)
return head;
int n = 0;
Node cur = head;
//統計一共有多少個節點
while (cur != null)
n++;
//問題轉換為刪除第K個節點,取(a * n / b)的整數上限
int K = (int)Math.ceil((double)(a * n) / (double)b);
if(K == 1)
return head.next;
if (K > 1) {
cur = head;
//定位到第K個節點的前驅
while (--K != 1) {
cur = cur.next;
}
cur.next = cur.next.next;
}
return head;
}
複製程式碼最後推廣下我的公眾號：苦逼的碼農，主要寫演算法、計算機基礎之類的文章，裡面已有100多篇原創文章
5、將單向連結串列按某值劃分成左邊小，中間相等，右邊大的形式md
【題目描述】
給定一個單向連結串列的頭結點head,節點的值型別是整型，再給定一個整數privot。實現一個調整連結串列的函式，將連結串列調整為左部分都是值小於privot的節點，中間部分都是值等於privot的節點，右部分都是大於privot的節點。且對某部分內部節點的順序不做要求
例如:連結串列9-0-4-5-1，pivot=3。
調整後是1-0-4-9-5，
也可以是0-1-9-5-4
【要求】
如果連結串列的長度為 N, 時間複雜度達到 O(N)。
【解答】
這道題在思路上還是比較簡單的，但是在實現上還是有一些細節需要主要的。
本題對某部分的內部節點不做要求，一種很簡單的方法就是用一個陣列來存連結串列的節點，然後像類似於快速排序的分割函式那樣，按照某個值把他們進行劃分。
不過這樣做的話，空間複雜度為 O(N)。我們也可以採取使用3個指標，把原連結串列依次劃分成三個部分的連結串列，然後再把他們合併起來，這種做法不但空間複雜度為 O(1), 而且內部節點的順序也是和原連結串列一樣的。雖然思路簡單，但在程式碼實現上也是有很多細節需要注意的，有時間的話希望大家動手打下碼。
程式碼如下
//用三個指標處理，這道題主要是要注意串聯連結串列時的一些細節處理
public static Node listPartition(Node head, int pivot) {
Node sB = null;//小的指標頭，即small begin
Node sE = null;//小的指標尾，即 small end
Node eB = null;//中的指標頭，即 equal begin
Node eE = null;//中的指標尾，即emall end
Node bB = null;//大的指標頭，即 big begin
Node bE = null;//大的指標尾，即 big end
Node next = null;//儲存下一個節點
//進行劃分
while (head != null) {
next = head.next;
head.next = null;
if (head.value < pivot) {
if (sB == null) {
sB = head;
sE = head;
} else {
sE.next = head;
sE = sE.next;
}
} else if (head.value == pivot) {
if (eB == null) {
eB = head;
eE = head;
} else {
eE.next = head;
eE = eE.next;
}
} else {
if (bB == null) {
bB = head;
bE = head;
} else {
bE.next = head;
bE = bE.next;
}
}
head = next;
}
//把三部分串連起來，串聯的時候細節還是挺多的，
//串聯的過程下面程式碼的精簡程度是最學習的部分了
//1.小的與中的串聯
if (sB != null) {
sE.next = eB;
eE = eE == null ? sE : eE;
}
//2.中的和大的連線
if (eB != null) {
eE.next = bB;
}
return sB != null ? sB : eB != null ? eB : bB;
}
複製程式碼整理不容易，寫這些文章更加不容易，如果你覺得這篇內容對你挺有啟發，為了讓更多的人看到這篇文章：不妨
1、點贊，讓更多的人也能看到這篇內容（收藏不點贊，都是耍流氓 -_-）
2、關注我和專欄，讓我們成為長期關係
3、關注公眾號「苦逼的碼農」，主要寫演算法、計算機基礎之類的文章，裡面已有100多篇原創文章