1 引言
單連結串列的操作演算法是筆試面試中較為常見的題目。本文將著重介紹平時面試中常見的關於連結串列的應用題目，希望對你們有幫助 ^_^
2 輸出單連結串列倒數第 K 個節點
2.1 問題描述
題目：輸入一個單連結串列，輸出此連結串列中的倒數第 K 個節點。（去除頭結點，節點計數從 1 開始）
2.2 兩次遍歷法
2.2.1 解題思想
（1）遍歷單連結串列，遍歷同時得出連結串列長度 N 。 （2）再次從頭遍歷，訪問至第 N - K 個節點為所求節點。
2.2.2 圖解過程
2.2.3 程式碼實現
/*計算連結串列長度*/
int listLength(ListNode* pHead){
int count = 0;
ListNode* pCur = pHead->next;
if(pCur == NULL){
printf("error");
}
while(pCur){
count++;
pCur = pCur->pNext;
}
return count;
}
/*查詢第k個節點的值*/
ListNode* searchNodeK(ListNode* pHead, int k){
int i = 0;
ListNode* pCur = pHead;
//計算連結串列長度
int len = listLength(pHead);
if(k > len){
printf("error");
}
//迴圈len-k+1次
for(i=0; i < len-k+1; i++){
pCur = pCur->next;
}
return pCur;//返回倒數第K個節點
}
複製程式碼採用這種遍歷方式需要兩次遍歷連結串列，時間複雜度為O(n*2)。可見這種方式最為簡單,也較好理解，但是效率低下。
2.3 遞迴法
2.3.1 解題思想
（1）定義num = k （2）使用遞迴方式遍歷至連結串列末尾。 （3）由末尾開始返回，每返回一次 num 減 1 （4）當 num 為 0 時，即可找到目標節點
2.3.2 圖解過程
2.3.3 程式碼實現
int num;//定義num值
ListNode* findKthTail(ListNode* pHead, int k) {
num = k;
if(pHead == NULL)
return NULL;
//遞迴呼叫
ListNode* pCur = findKthTail(pHead->next, k);
if(pCur != NULL)
return pCur;
else{
num--;// 遞迴返回一次，num值減1
if(num == 0)
return pHead;//返回倒數第K個節點
return NULL;
}
}
複製程式碼使用遞迴的方式實現仍然需要兩次遍歷連結串列，時間複雜度為O(n*2)
2.4 雙指標法
2.4.1 解題思想
（1）定義兩個指標 p1 和 p2 分別指向連結串列頭節點。 （2）p1 前進 K 個節點，則 p1 與 p2 相距 K 個節點。 （3）p1，p2 同時前進，每次前進 1 個節點。 （4）當 p1 指向到達連結串列末尾，由於 p1 與 p2 相距 K 個節點，則 p2 指向目標節點。
2.4.2 圖解過程
2.4.3 程式碼實現
ListNode* findKthTail(ListNode *pHead, int K){
if (NULL == pHead || K == 0)
return NULL;
//p1，p2均指向頭節點
ListNode *p1 = pHead;
ListNode *p2 = pHead;
//p1先出發，前進K個節點
for (int i = 0; i < K; i++) {
if (p1)//防止k大於連結串列節點的個數
p1 = p1->_next;
else
return NULL;
}
while (p1)//如果p1沒有到達連結串列結尾，則p1，p2繼續遍歷
{
p1 = p1->_next;
p2 = p2->_next;
}
return p2;//當p1到達末尾時，p2正好指向倒數第K個節點
}
複製程式碼可以看出使用雙指標法只需遍歷連結串列一次，這種方法更為高效時間複雜度為O(n)，通常筆試題目中要考的也是這種方法。
3 連結串列中存在環問題
3.1 判斷連結串列是否有環
單連結串列中的環是指連結串列末尾的節點的 next 指標不為 NULL ，而是指向了連結串列中的某個節點，導致連結串列中出現了環形結構。
連結串列中有環示意圖：
連結串列的末尾節點 8 指向了連結串列中的節點 3，導致連結串列中出現了環形結構。 對於連結串列是否是由有環的判斷方法有哪些呢？
3.1.1 窮舉比較法
3.1.1.1 解題思想
（1）遍歷連結串列，記錄已訪問的節點。 （2）將當前節點與之前以及訪問過的節點比較，若有相同節點則有環。 否則，不存在環。
這種窮舉比較思想簡單，但是效率過於低下，尤其是當連結串列節點數目較多，在進行比較時花費大量時間，時間複雜度大致在 O(n^2)。這種方法自然不是出題人的理想答案。如果筆試面試中使用這種方法，估計就要跪了，忘了這種方法吧。
3.1.2 雜湊快取法
既然在窮舉遍歷時，元素比較過程花費大量時間，那麼有什麼辦法可以提高比較速度呢？
3.1.2.1 解題思想
（1）首先建立一個以節點 ID 為鍵的 HashSe t集合，用來儲存曾經遍歷過的節點。 （2）從頭節點開始，依次遍歷單連結串列的每一個節點。 （3）每遍歷到一個新節點，就用新節點和 HashSet 集合當中儲存的節點作比較，如果發現 HashSet 當中存在相同節點 ID，則說明連結串列有環，如果 HashSet 當中不存在相同的節點 ID，就把這個新節點 ID 存入 HashSet ，之後進入下一節點，繼續重複剛才的操作。
假設從連結串列頭節點到入環點的距離是 a ，連結串列的環長是 r 。而每一次 HashSet 查詢元素的時間複雜度是 O(1), 所以總體的時間複雜度是 1 * ( a + r ) = a + r，可以簡單理解為 O(n) 。而演算法的空間複雜度還是 a + r - 1，可以簡單地理解成 O(n) 。
3.1.3 快慢指標法
3.1.3.1 解題思想
（1）定義兩個指標分別為 slow，fast，並且將指標均指向連結串列頭節點。 （2）規定，slow 指標每次前進 1 個節點，fast 指標每次前進兩個節點。 （3）當 slow 與 fast 相等，且二者均不為空，則連結串列存在環。
3.1.3.2 圖解過程
無環過程：
通過圖解過程可以看出，若表中不存在環形，fast 與 slow 指標只能在連結串列末尾相遇。
有環過程：
圖解過程可以看出，若連結串列中存在環，則快慢指標必然能在環中相遇。這就好比在環形跑道中進行龜兔賽跑。由於兔子速度大於烏龜速度，則必然會出現兔子與烏龜再次相遇情況。因此，當出現快慢指標相等時，且二者不為NULL，則表明連結串列存在環。
3.1.3.3 程式碼實現
bool isExistLoop(ListNode* pHead) {
ListNode* fast;//慢指標，每次前進一個節點
ListNode* slow;//快指標，每次前進2個節點
slow = fast = pHead ; //兩個指標均指向連結串列頭節點
//當沒有到達連結串列結尾，則繼續前進
while (slow != NULL && fast -> next != NULL) {
slow = slow -> next ; //慢指標前進一個節點
fast = fast -> next -> next ; //快指標前進兩個節點
if (slow == fast) //若兩個指標相遇，且均不為NULL則存在環
return true ;
}
//到達末尾仍然沒有相遇，則不存在環
return false ;
}
複製程式碼3.2 定位環入口
在 3.1 節中，已經實現了連結串列中是否有環的判斷方法。那麼，當連結串列中存在環，如何確定環的入口節點呢？
3.2.1 解題思想
slow 指標每次前進一個節點，故 slow 與 fast 相遇時，slow 還沒有遍歷完整個連結串列。設 slow 走過節點數為 s，fast 走過節點數為 2s。設環入口點距離頭節點為 a，slow 與 fast 首次相遇點距離入口點為 b，環的長度為 r。 則有： s = a + b; 2s = n * r + a + b; n 代表fast指標已經在環中迴圈的圈數。 則推出： s = n * r; 意味著slow指標走過的長度為環的長度整數倍。
若連結串列頭節點到環的末尾節點度為 L，slow 與 fast 的相遇節點距離環入口節點為 X。 則有： a+X = s = n * r = (n - 1) * r + (L - a); a = (n - 1) * r + (L - a - X); 上述等式可以看出： 從 slow 與 fast 相遇點出發一個指標 p1，請進 (L - a - X) 步，則此指標到達入口節點。同時指標 p2 從頭結點出發，前進 a 步。當 p1 與 p2 相遇時，此時 p1 與 p2 均指向入口節點。
例如圖3.1所示連結串列： slow 走過節點 s = 6； fast 走過節點 2s = 12； 環入口節點據流頭節點 a = 3； 相遇點距離頭節點 X = 3； L = 8； r = 6； 可以得出 a = (n - 1) * r + (L - a - X)結果成立。
3.2.2 圖解過程
3.2.3 程式碼實現
//找到環中的相遇節點
ListNode* getMeetingNode(ListNode* pHead) // 假設為帶頭節點的單連結串列
{
ListNode* fast;//慢指標，每次前進一個節點
ListNode* slow;//快指標，每次前進2個節點
slow = fast = pHead ; //兩個指標均指向連結串列頭節點
//當沒有到達連結串列結尾，則繼續前進
while (slow != NULL && fast -> next != NULL){
slow = slow -> next ; //慢指標前進一個節點
fast = fast -> next -> next ; //快指標前進兩個節點
if (slow == fast) //若兩個指標相遇，且均不為NULL則存在環
return slow;
}
//到達末尾仍然沒有相遇，則不存在環
return NULL ;
}
//找出環的入口節點
ListNode* getEntryNodeOfLoop(ListNode* pHead){
ListNode* meetingNode = getMeetingNode(pHead); // 先找出環中的相遇節點
if (meetingNode == NULL)
return NULL;
ListNode* p1 = meetingNode;
ListNode* p2 = pHead;
while (p1 != p2) // p1和p2以相同的速度向前移動，當p2指向環的入口節點時，p1已經圍繞著環走了n圈又回到了入口節點。
{
p1 = p1->next;
p2 = p2->next;
}
//返回入口節點
return p1;
}
複製程式碼3.3 計算環長度
3.3.1 解題思想
在3.1中找到了 slow 與 fast 的相遇節點，令 solw 與 fast 指標從相遇節點出發，按照之前的前進規則，當 slow 與fast 再次相遇時，slow 走過的長度正好為環的長度。
3.3.2 圖解過程
3.3.3 程式碼實現
int getLoopLength(ListNode* head){
ListNode* slow = head;
ListNode* fast = head;
while ( fast && fast->next ){
slow = slow->next;
fast = fast->next->next;
if ( slow == fast )//第一次相遇
break;
}
//slow與fast繼續前進
slow = slow->next;
fast = fast->next->next;
int length = 1; //環長度
while ( fast != slow )//再次相遇
{
slow = slow->next;
fast = fast->next->next;
length ++; //累加
}
//當slow與fast再次相遇，得到環長度
return length;
}
複製程式碼4 使用連結串列實現大數加法
4.1 問題描述
兩個用連結串列代表的整數，其中每個節點包含一個數字。數字儲存按照在原來整數中相反的順序，使得第一個數字位於連結串列的開頭。寫出一個函式將兩個整數相加，用連結串列形式返回和。
例如： 輸入： 3->1->5->null 5->9->2->null， 輸出： 8->0->8->null
4.2 程式碼實現
ListNode* numberAddAsList(ListNode* l1, ListNode* l2) {
ListNode *ret = l1, *pre = l1;
int up = 0;
while (l1 != NULL && l2 != NULL) {
//數值相加
l1->val = l1->val + l2->val + up;
//計算是否有進位
up = l1->val / 10;
//保留計算結果的個位
l1->val %= 10;
//記錄當前節點位置
pre = l1;
//同時向後移位
l1 = l1->next;
l2 = l2->next;
}
//若l1到達末尾，說明l1長度小於l2
if (l1 == NULL)
//pre->next指向l2的當前位置
pre->next = l2;
//l1指標指向l2節點當前位置
l1 = pre->next;
//繼續計算剩餘節點
while (l1 != NULL) {
l1->val = l1->val + up;
up = l1->val / 10;
l1->val %= 10;
pre = l1;
l1 = l1->next;
}
//最高位計算有進位，則新建一個節點保留最高位
if (up != 0) {
ListNode *tmp = new ListNode(up);
pre->next = tmp;
}
//返回計算結果連結串列
return ret;
}
複製程式碼5 有序連結串列合併
5.1 問題描述
題目：將兩個有序連結串列合併為一個新的有序連結串列並返回。新連結串列是通過拼接給定的兩個連結串列的所有節點組成的。
示例： 輸入： 1->2->4, 1->3->4 輸出： 1->1->2->3->4->4
5.2 演算法流程
5.3 一般方案
5.3.1 解題思想
（1）對空連結串列存在的情況進行處理，假如 pHead1 為空則返回 pHead2 ，pHead2 為空則返回 pHead1。（兩個都為空此情況在pHead1為空已經被攔截） （2）在兩個連結串列無空連結串列的情況下確定第一個結點，比較連結串列1和連結串列2的第一個結點的值，將值小的結點儲存下來為合併後的第一個結點。並且把第一個結點為最小的連結串列向後移動一個元素。 （3）繼續在剩下的元素中選擇小的值，連線到第一個結點後面，並不斷next將值小的結點連線到第一個結點後面，直到某一個連結串列為空。 （4）當兩個連結串列長度不一致時，也就是比較完成後其中一個連結串列為空，此時需要把另外一個連結串列剩下的元素都連線到第一個結點的後面。
5.3.2 程式碼實現
ListNode* mergeTwoOrderedLists(ListNode* pHead1, ListNode* pHead2){
ListNode* pTail = NULL;//指向新連結串列的最後一個結點 pTail->next去連線
ListNode* newHead = NULL;//指向合併後連結串列第一個結點
if (NULL == pHead1){
return pHead2;
}else if(NULL == pHead2){
return pHead1;
}else{
//確定頭指標
if ( pHead1->data < pHead2->data){
newHead = pHead1;
pHead1 = pHead1->next;//指向連結串列的第二個結點
}else{
newHead = pHead2;
pHead2 = pHead2->next;
}
pTail = newHead;//指向第一個結點
while ( pHead1 && pHead2) {
if ( pHead1->data <= pHead2->data ){
pTail->next = pHead1;
pHead1 = pHead1->next;
}else {
pTail->next = pHead2;
pHead2 = pHead2->next;
}
pTail = pTail->next;
}
if(NULL == pHead1){
pTail->next = pHead2;
}else if(NULL == pHead2){
pTail->next = pHead1;
}
return newHead;
}
複製程式碼5.4 遞迴方案
5.4.1 解題思想
（1）對空連結串列存在的情況進行處理，假如 pHead1 為空則返回 pHead2 ，pHead2 為空則返回 pHead1。 （2）比較兩個連結串列第一個結點的大小，確定頭結點的位置 （3）頭結點確定後，繼續在剩下的結點中選出下一個結點去連結到第二步選出的結點後面，然後在繼續重複（2 ）（3） 步，直到有連結串列為空。
5.4.2 程式碼實現
ListNode* mergeTwoOrderedLists(ListNode* pHead1, ListNode* pHead2){
ListNode* newHead = NULL;
if (NULL == pHead1){
return pHead2;
}else if(NULL ==pHead2){
return pHead2;
}else{
if (pHead1->data < pHead2->data){
newHead = pHead1;
newHead->next = mergeTwoOrderedLists(pHead1->next, pHead2);
}else{
newHead = pHead2;
newHead->next = mergeTwoOrderedLists(pHead1, pHead2->next);
}
return newHead;
}
}
複製程式碼6 刪除連結串列中節點，要求時間複雜度為 O(1)
6.1 問題描述
給定一個單連結串列中的表頭和一個等待被刪除的節點。請在 O(1) 時間複雜度刪除該連結串列節點。並在刪除該節點後，返回表頭。
示例： 給定 1->2->3->4，和節點 3，返回 1->2->4。
6.2 解題思想
在之前介紹的單連結串列刪除節點中，最普通的方法就是遍歷連結串列，複雜度為O(n)。 如果我們把刪除節點的下一個結點的值賦值給要刪除的結點，然後刪除這個結點，這相當於刪除了需要刪除的那個結點。因為我們很容易獲取到刪除節點的下一個節點，所以複雜度只需要O(1)。
示例 單連結串列：1->2->3->4->NULL 若要刪除節點 3 。第一步將節點3的下一個節點的值4賦值給當前節點。變成 1->2->4->4->NULL，然後將就 4 這個結點刪除，就達到目的了。 1->2->4->NULL
如果刪除的節點的是頭節點，把頭結點指向 NULL。 如果刪除的節點的是尾節點，那隻能從頭遍歷到頭節點的上一個結點。
6.3 圖解過程
6.4 程式碼實現
void deleteNode(ListNode **pHead, ListNode* pDelNode) {
if(pDelNode == NULL)
return;
if(pDelNode->next != NULL){
ListNode *pNext = pDelNode->next;
//下一個節點值賦給待刪除節點
pDelNode->val = pNext->val;
//待刪除節點指標指後面第二個節點
pDelNode->next = pNext->next;
//刪除待刪除節點的下一個節點
delete pNext;
pNext = NULL;
}else if(*pHead == pDelNode)//刪除的節點是頭節點
{
delete pDelNode;
pDelNode= NULL;
*pHead = NULL;
} else//刪除的是尾節點
{
ListNode *pNode = *pHead;
while(pNode->next != pDelNode) {
pNode = pNode->next;
}
pNode->next = NULL;
delete pDelNode;
pDelNode= NULL;
}
}
複製程式碼7 從尾到頭列印連結串列
7.1 問題描述
輸入一個連結串列，按連結串列值從尾到頭的順序返回一個 ArrayList 。
7.2 解法
初看題目意思就是輸出的時候連結串列尾部的元素放在前面，連結串列頭部的元素放在後面。這不就是 先進後出，後進先出 麼。
什麼資料結構符合這個要求？
棧 ！
7.2.1 程式碼實現
class Solution {
public:
vector<int> printListFromTailToHead(ListNode* head) {
vector<int> value;
ListNode *p=NULL;
p=head;
stack<int> stk;
while(p!=NULL){
stk.push(p->val);
p=p->next;
}
while(!stk.empty()){
value.push_back(stk.top());
stk.pop();
}
return value;
}
};
複製程式碼7.3 解法二
第二種方法也比較容易想到，通過連結串列的構造，如果將末尾的節點儲存之後，剩餘的連結串列處理方式還是不變，所以可以使用遞迴的形式進行處理。
7.3.1 程式碼實現
class Solution {
public:
vector<int> value;
vector<int> printListFromTailToHead(ListNode* head) {
ListNode *p=NULL;
p=head;
if(p!=NULL){
if(p->next!=NULL){
printListFromTailToHead(p->next);
}
value.push_back(p->val);
}
return value;
}
};
複製程式碼8 反轉連結串列
8.1 題目描述
反轉一個單連結串列。
示例:
輸入: 1->2->3->4->5->NULL
輸出: 5->4->3->2->1->NULL
複製程式碼進階: 你可以迭代或遞迴地反轉連結串列。你能否用兩種方法解決這道題？
8.2 解題思路
設定三個節點pre、cur、next
- （1）每次檢視
cur節點是否為NULL，如果是，則結束迴圈，獲得結果 - （2）如果
cur節點不是為NULL，則先設定臨時變數next為cur的下一個節點 - （3）讓
cur的下一個節點變成指向pre，而後pre移動cur，cur移動到next - （4）重複（1）（2）（3）
動畫演示
8.3 程式碼實現
8.3.1 迭代方式
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* pre = NULL;
ListNode* cur = head;
while(cur != NULL){
ListNode* next = cur->next;
cur->next = pre;
pre = cur;
cur = next;
}
return pre;
}
};
複製程式碼8.3.2 遞迴的方式處理
class Solution {
public:
ListNode* reverseList(ListNode* head) {
// 遞迴終止條件
if(head == NULL || head->next == NULL)
return head;
ListNode* rhead = reverseList(head->next);
// head->next此刻指向head後面的連結串列的尾節點
// head->next->next = head把head節點放在了尾部
head->next->next = head;
head->next = NULL;
return rhead;
}
};
複製程式碼End
最近文章點贊量有點少，如果文章對你有幫助的話，麻煩點個贊~