輕鬆搞定面試中的鏈表題目

原創 csdn_chai 2020-02-22 21:00

版權所有，轉載請註明出處，謝謝！
http://blog.csdn.net/walkinginthewind/article/details/7393134

鏈表是最基本的數據結構，面試官也常常用鏈表來考察面試者的基本能力，而且鏈表相關的操作相對而言比較簡單，也適合考察寫代碼的能力。鏈表的操作也離不開指針，指針又很容易導致出錯。綜合多方面的原因，鏈表題目在面試中佔據着很重要的地位。本文對鏈表相關的面試題做了較爲全面的整理，希望能對找工作的同學有所幫助。

鏈表結點聲明如下：

struct ListNode
{
    int m_nKey;
    ListNode * m_pNext;

};

鏈表相關元操作：

1. 本節點是否是尾節點

pNode->next == NULL; 


題目列表：

1. 求單鏈表中結點的個數
2. 將單鏈表反轉
3. 查找單鏈表中的倒數第K個結點（k > 0）
4. 查找單鏈表的中間結點
5. 從尾到頭打印單鏈表
6. 已知兩個單鏈表pHead1 和pHead2 各自有序，把它們合併成一個鏈表依然有序
7. 判斷一個單鏈表中是否有環
8. 判斷兩個單鏈表是否相交
9. 求兩個單鏈表相交的第一個節點
10. 已知一個單鏈表中存在環，求進入環中的第一個節點
11. 給出一單鏈表頭指針pHead和一節點指針pToBeDeleted，O(1)時間複雜度刪除節點pToBeDeleted


詳細解答

1. 求單鏈表中結點的個數

這是最最基本的了，應該能夠迅速寫出正確的代碼，注意檢查鏈表是否爲空。時間複雜度爲O（n）。參考代碼如下：

[cpp] view plain copy
  1. // 求單鏈表中結點的個數  
  2. unsigned int GetListLength(ListNode * pHead)  
  3. {  
  4.     if(pHead == NULL)  
  5.         return 0;  
  6.   
  7.     unsigned int nLength = 0;  
  8.     ListNode * pCurrent = pHead;  
  9.     while(pCurrent != NULL)  
  10.     {  
  11.         nLength++;  
  12.         pCurrent = pCurrent->m_pNext;  
  13.     }  
  14.     return nLength;  
  15. }  


2. 將單鏈表反轉

從頭到尾遍歷原鏈表，每遍歷一個結點，將其摘下放在新鏈表的最前端。注意鏈表爲空和只有一個結點的情況。時間複雜度爲O（n）。參考代碼如下：

[cpp] view plain copy
  1. // 反轉單鏈表  
  2. ListNode * ReverseList(ListNode * pHead)  
  3. {  
  4.         // 如果鏈表爲空或只有一個結點，無需反轉，直接返回原鏈表頭指針  
  5.     if(pHead == NULL || pHead->m_pNext == NULL)    
  6.         return pHead;  
  7.   
  8.     ListNode * pReversedHead = NULL; // 反轉後的新鏈表頭指針，初始爲NULL  
  9.     ListNode * pCurrent = pHead;  
  10.     while(pCurrent != NULL)  
  11.     {  
  12.         ListNode * pTemp = pCurrent;  
  13.         pCurrent = pCurrent->m_pNext;  
  14.         pTemp->m_pNext = pReversedHead; // 將當前結點摘下，插入新鏈表的最前端  
  15.         pReversedHead = pTemp;  
  16.     }  
  17.     return pReversedHead;  
  18. }  

3. 查找單鏈表中的倒數第K個結點（k > 0）

最普遍的方法是，先統計單鏈表中結點的個數，然後再找到第（n-k）個結點。注意鏈表爲空，k爲0，k爲1，k大於鏈表中節點個數時的情況。時間複雜度爲O（n）。代碼略。

這裏主要講一下另一個思路，這種思路在其他題目中也會有應用。

主要思路就是使用兩個指針，先讓前面的指針走到正向第k個結點，這樣前後兩個指針的距離差是k-1，之後前後兩個指針一起向前走，前面的指針走到最後一個結點時，後面指針所指結點就是倒數第k個結點。

參考代碼如下：

[cpp] view plain copy
  1. // 查找單鏈表中倒數第K個結點  
  2. ListNode * RGetKthNode(ListNode * pHead, unsigned int k) // 函數名前面的R代表反向  
  3. {  
  4.     if(k == 0 || pHead == NULL) // 這裏k的計數是從1開始的，若k爲0或鏈表爲空返回NULL  
  5.         return NULL;  
  6.   
  7.     ListNode * pAhead = pHead;  
  8.     ListNode * pBehind = pHead;  
  9.     while(k > 1 && pAhead != NULL) // 前面的指針先走到正向第k個結點  
  10.     {  
  11.         pAhead = pAhead->m_pNext;  
  12.         k--;  
  13.     }  
  14.     if(k > 1 || pAhead == NULL)     // 結點個數小於k，返回NULL  
  15.         return NULL;  
  16.     while(pAhead->m_pNext != NULL)  // 前後兩個指針一起向前走，直到前面的指針指向最後一個結點  
  17.     {  
  18.         pBehind = pBehind->m_pNext;  
  19.         pAhead = pAhead->m_pNext;  
  20.     }  
  21.     return pBehind;  // 後面的指針所指結點就是倒數第k個結點  
  22. }  

4. 查找單鏈表的中間結點

此題可應用於上一題類似的思想。也是設置兩個指針，只不過這裏是，兩個指針同時向前走，前面的指針每次走兩步，後面的指針每次走一步，前面的指針走到最後一個結點時，後面的指針所指結點就是中間結點，即第（n/2+1）個結點。注意鏈表爲空，鏈表結點個數爲1和2的情況。時間複雜度O（n）。參考代碼如下：

[cpp] view plain copy
  1. // 獲取單鏈表中間結點，若鏈表長度爲n(n>0)，則返回第n/2+1個結點  
  2. ListNode * GetMiddleNode(ListNode * pHead)  
  3. {  
  4.     if(pHead == NULL || pHead->m_pNext == NULL) // 鏈表爲空或只有一個結點，返回頭指針  
  5.         return pHead;  
  6.   
  7.     ListNode * pAhead = pHead;  
  8.     ListNode * pBehind = pHead;  
  9.     while(pAhead->m_pNext != NULL) // 前面指針每次走兩步，直到指向最後一個結點，後面指針每次走一步  
  10.     {  
  11.         pAhead = pAhead->m_pNext;  
  12.         pBehind = pBehind->m_pNext;  
  13.         if(pAhead->m_pNext != NULL)  
  14.             pAhead = pAhead->m_pNext;  
  15.     }  
  16.     return pBehind; // 後面的指針所指結點即爲中間結點  
  17. }  


5. 從尾到頭打印單鏈表

對於這種顛倒順序的問題，我們應該就會想到棧，後進先出。所以，這一題要麼自己使用棧，要麼讓系統使用棧，也就是遞歸。注意鏈表爲空的情況。時間複雜度爲O（n）。參考代碼如下：

自己使用棧：

[cpp] view plain copy
  1. // 從尾到頭打印鏈表，使用棧  
  2. void RPrintList(ListNode * pHead)  
  3. {  
  4.     std::stack<ListNode *> s;  
  5.     ListNode * pNode = pHead;  
  6.     while(pNode != NULL)  
  7.     {  
  8.         s.push(pNode);  
  9.         pNode = pNode->m_pNext;  
  10.     }  
  11.     while(!s.empty())  
  12.     {  
  13.         pNode = s.top();  
  14.         printf("%d\t", pNode->m_nKey);  
  15.         s.pop();  
  16.     }  
  17. }  

使用遞歸函數：

[cpp] view plain copy
  1. // 從尾到頭打印鏈表，使用遞歸  
  2. void RPrintList(ListNode * pHead)  
  3. {  
  4.     if(pHead == NULL)  
  5.     {  
  6.         return;  
  7.     }  
  8.     else  
  9.     {  
  10.         RPrintList(pHead->m_pNext);  
  11.         printf("%d\t", pHead->m_nKey);  
  12.     }  
  13. }  


6. 已知兩個單鏈表pHead1 和pHead2 各自有序，把它們合併成一個鏈表依然有序

這個類似歸併排序。尤其注意兩個鏈表都爲空，和其中一個爲空時的情況。只需要O（1）的空間。時間複雜度爲O（max(len1, len2)）。參考代碼如下：

[cpp] view plain copy
  1. // 合併兩個有序鏈表  
  2. ListNode * MergeSortedList(ListNode * pHead1, ListNode * pHead2)  
  3. {  
  4.     if(pHead1 == NULL)  
  5.         return pHead2;  
  6.     if(pHead2 == NULL)  
  7.         return pHead1;  
  8.     ListNode * pHeadMerged = NULL;  
  9.     if(pHead1->m_nKey < pHead2->m_nKey)  
  10.     {  
  11.         pHeadMerged = pHead1;  
  12.         pHeadMerged->m_pNext = NULL;  
  13.         pHead1 = pHead1->m_pNext;  
  14.     }  
  15.     else  
  16.     {  
  17.         pHeadMerged = pHead2;  
  18.         pHeadMerged->m_pNext = NULL;  
  19.         pHead2 = pHead2->m_pNext;  
  20.     }  
  21.     ListNode * pTemp = pHeadMerged;  
  22.     while(pHead1 != NULL && pHead2 != NULL)  
  23.     {  
  24.         if(pHead1->m_nKey < pHead2->m_nKey)  
  25.         {  
  26.             pTemp->m_pNext = pHead1;  
  27.             pHead1 = pHead1->m_pNext;  
  28.             pTemp = pTemp->m_pNext;  
  29.             pTemp->m_pNext = NULL;  
  30.         }  
  31.         else  
  32.         {  
  33.             pTemp->m_pNext = pHead2;  
  34.             pHead2 = pHead2->m_pNext;  
  35.             pTemp = pTemp->m_pNext;  
  36.             pTemp->m_pNext = NULL;  
  37.         }  
  38.     }  
  39.     if(pHead1 != NULL)  
  40.         pTemp->m_pNext = pHead1;  
  41.     else if(pHead2 != NULL)  
  42.         pTemp->m_pNext = pHead2;  
  43.     return pHeadMerged;  
  44. }  

也有如下遞歸解法：

[cpp] view plain copy
  1. ListNode * MergeSortedList(ListNode * pHead1, ListNode * pHead2)  
  2. {  
  3.     if(pHead1 == NULL)  
  4.         return pHead2;  
  5.     if(pHead2 == NULL)  
  6.         return pHead1;  
  7.     ListNode * pHeadMerged = NULL;  
  8.     if(pHead1->m_nKey < pHead2->m_nKey)  
  9.     {  
  10.         pHeadMerged = pHead1;  
  11.         pHeadMerged->m_pNext = MergeSortedList(pHead1->m_pNext, pHead2);  
  12.     }  
  13.     else  
  14.     {  
  15.         pHeadMerged = pHead2;  
  16.         pHeadMerged->m_pNext = MergeSortedList(pHead1, pHead2->m_pNext);  
  17.     }  
  18.     return pHeadMerged;  
  19. }  


7. 判斷一個單鏈表中是否有環

這裏也是用到兩個指針。如果一個鏈表中有環，也就是說用一個指針去遍歷，是永遠走不到頭的。因此，我們可以用兩個指針去遍歷，一個指針一次走兩步，一個指針一次走一步，如果有環，兩個指針肯定會在環中相遇。時間複雜度爲O（n）。參考代碼如下：

[cpp] view plain copy
  1. bool HasCircle(ListNode * pHead)  
  2. {  
  3.     ListNode * pFast = pHead; // 快指針每次前進兩步  
  4.     ListNode * pSlow = pHead; // 慢指針每次前進一步  
  5.     while(pFast != NULL && pFast->m_pNext != NULL)  
  6.     {  
  7.         pFast = pFast->m_pNext->m_pNext;  
  8.         pSlow = pSlow->m_pNext;  
  9.         if(pSlow == pFast) // 相遇，存在環  
  10.             return true;  
  11.     }  
  12.     return false;  
  13. }  


8. 判斷兩個單鏈表是否相交

如果兩個鏈表相交於某一節點，那麼在這個相交節點之後的所有節點都是兩個鏈表所共有的。也就是說，如果兩個鏈表相交，那麼最後一個節點肯定是共有的。先遍歷第一個鏈表，記住最後一個節點，然後遍歷第二個鏈表，到最後一個節點時和第一個鏈表的最後一個節點做比較，如果相同，則相交，否則不相交。時間複雜度爲O(len1+len2)，因爲只需要一個額外指針保存最後一個節點地址，空間複雜度爲O(1)。參考代碼如下：

[cpp] view plain copy
  1. bool IsIntersected(ListNode * pHead1, ListNode * pHead2)  
  2. {  
  3.         if(pHead1 == NULL || pHead2 == NULL)  
  4.                 return false;  
  5.   
  6.     ListNode * pTail1 = pHead1;  
  7.     while(pTail1->m_pNext != NULL)  
  8.         pTail1 = pTail1->m_pNext;  
  9.   
  10.     ListNode * pTail2 = pHead2;  
  11.     while(pTail2->m_pNext != NULL)  
  12.         pTail2 = pTail2->m_pNext;  
  13.     return pTail1 == pTail2;  
  14. }  

9. 求兩個單鏈表相交的第一個節點
對第一個鏈表遍歷，計算長度len1，同時保存最後一個節點的地址。
對第二個鏈表遍歷，計算長度len2，同時檢查最後一個節點是否和第一個鏈表的最後一個節點相同，若不相同，不相交，結束。
兩個鏈表均從頭節點開始，假設len1大於len2，那麼將第一個鏈表先遍歷len1-len2個節點，此時兩個鏈表當前節點到第一個相交節點的距離就相等了，然後一起向後遍歷，知道兩個節點的地址相同。

時間複雜度，O(len1+len2)。參考代碼如下：

[cpp] view plain copy
  1. ListNode* GetFirstCommonNode(ListNode * pHead1, ListNode * pHead2)  
  2. {  
  3.     if(pHead1 == NULL || pHead2 == NULL)  
  4.         return NULL;  
  5.   
  6.     int len1 = 1;  
  7.     ListNode * pTail1 = pHead1;  
  8.     while(pTail1->m_pNext != NULL)  
  9.     {  
  10.         pTail1 = pTail1->m_pNext;  
  11.         len1++;  
  12.     }  
  13.   
  14.     int len2 = 1;  
  15.     ListNode * pTail2 = pHead2;  
  16.     while(pTail2->m_pNext != NULL)  
  17.     {  
  18.         pTail2 = pTail2->m_pNext;  
  19.         len2++;  
  20.     }  
  21.   
  22.     if(pTail1 != pTail2) // 不相交直接返回NULL  
  23.         return NULL;  
  24.   
  25.     ListNode * pNode1 = pHead1;  
  26.     ListNode * pNode2 = pHead2;  
  27.         // 先對齊兩個鏈表的當前結點，使之到尾節點的距離相等  
  28.     if(len1 > len2)  
  29.     {  
  30.         int k = len1 - len2;  
  31.         while(k--)  
  32.             pNode1 = pNode1->m_pNext;  
  33.     }  
  34.     else  
  35.     {  
  36.         int k = len2 - len1;  
  37.         while(k--)  
  38.             pNode2 = pNode2->m_pNext;  
  39.     }  
  40.     while(pNode1 != pNode2)  
  41.     {  
  42.         pNode1 = pNode1->m_pNext;  
  43.         pNode2 = pNode2->m_pNext;  
  44.     }  
  45.         return pNode1;  
  46. }  

10. 已知一個單鏈表中存在環，求進入環中的第一個節點

首先判斷是否存在環，若不存在結束。在環中的一個節點處斷開（當然函數結束時不能破壞原鏈表），這樣就形成了兩個相交的單鏈表，求進入環中的第一個節點也就轉換成了求兩個單鏈表相交的第一個節點。參考代碼如下：

[cpp] view plain copy
  1. ListNode* GetFirstNodeInCircle(ListNode * pHead)  
  2. {  
  3.     if(pHead == NULL || pHead->m_pNext == NULL)  
  4.         return NULL;  
  5.   
  6.     ListNode * pFast = pHead;  
  7.     ListNode * pSlow = pHead;  
  8.     while(pFast != NULL && pFast->m_pNext != NULL)  
  9.     {  
  10.         pSlow = pSlow->m_pNext;  
  11.         pFast = pFast->m_pNext->m_pNext;  
  12.         if(pSlow == pFast)  
  13.             break;  
  14.     }  
  15.     if(pFast == NULL || pFast->m_pNext == NULL)  
  16.         return NULL;  
  17.   
  18.     // 將環中的此節點作爲假設的尾節點，將它變成兩個單鏈表相交問題  
  19.     ListNode * pAssumedTail = pSlow;   
  20.     ListNode * pHead1 = pHead;  
  21.     ListNode * pHead2 = pAssumedTail->m_pNext;  
  22.   
  23.     ListNode * pNode1, * pNode2;  
  24.     int len1 = 1;  
  25.     ListNode * pNode1 = pHead1;  
  26.     while(pNode1 != pAssumedTail)  
  27.     {  
  28.         pNode1 = pNode1->m_pNext;  
  29.         len1++;  
  30.     }  
  31.       
  32.     int len2 = 1;  
  33.     ListNode * pNode2 = pHead2;  
  34.     while(pNode2 != pAssumedTail)  
  35.     {  
  36.         pNode2 = pNode2->m_pNext;  
  37.         len2++;  
  38.     }  
  39.   
  40.     pNode1 = pHead1;  
  41.     pNode2 = pHead2;  
  42.     // 先對齊兩個鏈表的當前結點，使之到尾節點的距離相等  
  43.     if(len1 > len2)  
  44.     {  
  45.         int k = len1 - len2;  
  46.         while(k--)  
  47.             pNode1 = pNode1->m_pNext;  
  48.     }  
  49.     else  
  50.     {  
  51.         int k = len2 - len1;  
  52.         while(k--)  
  53.             pNode2 = pNode2->m_pNext;  
  54.     }  
  55.     while(pNode1 != pNode2)  
  56.     {  
  57.         pNode1 = pNode1->m_pNext;  
  58.         pNode2 = pNode2->m_pNext;  
  59.     }  
  60.     return pNode1;  
  61. }  


11. 給出一單鏈表頭指針pHead和一節點指針pToBeDeleted，O(1)時間複雜度刪除節點pToBeDeleted





對於刪除節點，我們普通的思路就是讓該節點的前一個節點指向該節點的下一個節點，這種情況需要遍歷找到該節點的前一個節點，時間複雜度爲O(n)。對於鏈表，鏈表中的每個節點結構都是一樣的，所以我們可以把該節點的下一個節點的數據複製到該節點，然後刪除下一個節點即可。要注意最後一個節點的情況，這個時候只能用常見的方法來操作，先找到前一個節點，但總體的平均時間複雜度還是O(1)。參考代碼如下：









[cpp] view
plain copy









    

  1. 
void Delete(ListNode * pHead, ListNode * pToBeDeleted)  
  2. 
{  
  3. 
    if(pToBeDeleted == NULL)  
  4. 
        return;  
  5. 
    if(pToBeDeleted->m_pNext != NULL)  
  6. 
    {  
  7. 
        pToBeDeleted->m_nKey = pToBeDeleted->m_pNext->m_nKey; // 將下一個節點的數據複製到本節點，然後刪除下一個節點  
  8. 
        ListNode * temp = pToBeDeleted->m_pNext;  
  9. 
        pToBeDeleted->m_pNext = pToBeDeleted->m_pNext->m_pNext;  
  10. 
        delete temp;  
  11. 
    }  
  12. 
    else // 要刪除的是最後一個節點  
  13. 
    {  
  14. 
        if(pHead == pToBeDeleted) // 鏈表中只有一個節點的情況  
  15. 
        {  
  16. 
            pHead = NULL;  
  17. 
            delete pToBeDeleted;  
  18. 
        }  
  19. 
        else  
  20. 
        {  
  21. 
            ListNode * pNode = pHead;  
  22. 
            while(pNode->m_pNext != pToBeDeleted) // 找到倒數第二個節點  
  23. 
                pNode = pNode->m_pNext;  
  24. 
            pNode->m_pNext = NULL;  
  25. 
            delete pToBeDeleted;  
  26. 
        }     
  27. 
    }  
  28. 
}  















站內首發文章














csdn_chai



發佈了84 篇原創文章 · 獲贊 145 · 訪問量 9萬+





私信

關注

















發表評論














所有評論



還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.







相關文章








劍指Offer-在排序數組中查找數字 I






46.在排序數組中查找數字 I
統計一個數字在排序數組中出現的次數。
示例 1:
輸入: nums = [5,7,7,8,8,10], target = 8
輸出: 2
示例 2:
輸入: nums = [5,7,7,8,8,






Ga_Lip

2020-07-08 12:20:23









LeetCode-452. 用最少數量的箭引爆氣球






LeetCode-452. 用最少數量的箭引爆氣球
在二維空間中有許多球形的氣球。對於每個氣球，提供的輸入是水平方向上，氣球直徑的開始和結束座標。由於它是水平的，所以y座標並不重要，因此只要知道開始和結束的x座標就足夠了。開始座標






Ga_Lip

2020-07-08 12:20:23









LeetCode-680. 驗證迴文字符串






LeetCode-680. 驗證迴文字符串
給定一個非空字符串 s，最多刪除一個字符。判斷是否能成爲迴文字符串。
示例 1:
輸入: "aba"
輸出: True
示例 2:
輸入: "abca"
輸出: True
解釋: 你可






Ga_Lip

2020-07-08 12:20:23









基本數據結構——線性結構（列表/無序表）






1.什麼是列表（List）?
一個數據項按照相對位置存放的數據集。特別的，被稱爲“無序表(unordered list)”，其中數據項只按照存放位置來索引，如第1個、第2個…、最後一個等。
如一個考試分數的集合“54,26,93,






weixin_38324954

2020-07-08 11:06:53









算法複雜度評價指標（大o表示法）






大O表示法（1）常見的大o數量級函數（2）其他算法複雜度表示法
基本操作數量函數T(n)的精確值並不是特別重要，重要的是Tn(n)中起決定性因素的主導部分。用動態的眼光看，就是當問題規模增大的時候，T(n)中的一些部分會蓋過其他部






weixin_38324954

2020-07-08 11:06:52









“變位詞”判斷問題及算法複雜度






解法1 逐字檢查
解法思路：
將詞1中的字符逐個到詞2中檢查是否存在，存在就打勾標記（防止重複檢查）。如果每個字符都能找到，則兩個詞是變位詞。只要有一個字符找不到，就不是變位詞。
實現打勾標記：將詞2對應字符設爲None,由於






weixin_38324954

2020-07-08 11:06:52









基本數據結構——線性結構（有序表）






1. 什麼是有序表（OrderedList）
有序表是一種數據項依照其某可比性質（如整數大小、字母表先後）來決定在列表中的位置。越“小”的數據項越靠近列表的頭，越靠“前”。
2.抽象數據類型有序表（OrderedList）定義的






weixin_38324954

2020-07-08 11:06:52









python兩種內置數據類型（列表list和字典dict）上各個操作的大O數量級






python兩種內置數據類型（列表list和字典dict）上各個操作的大O數量級
1.對比list和dict操作
2.list列表數據類型常用操作性能
(1)按索引取值和賦值（v=a[i],a[i]=v）
由於列表的隨機訪問特性






weixin_38324954

2020-07-08 11:06:52









基本數據結構——線性結構（棧）






1.什麼是線性結構
線性結構是一種有序數據項的集合，其中每個數據項都有唯一的前驅和後繼（除了第一個沒有前驅，最後一個沒有後繼）。新的數據項加入到數據集中時，只會加入到原有某個數據項之前或之後。具有這種性質的數據集，就稱爲線性結構。






weixin_38324954

2020-07-08 11:06:52









基本數據結構——線性結構（隊列、雙端隊列）






1. 什麼是隊列？
隊列是一種有次序的數據集合，其特徵是新數據項的添加總髮生在一端（通常稱爲“尾端”），而現存數據項的移除總髮生在另一端（通常稱爲“首front”端）。
新加入的數據項必須在數據集末尾等待，而等待時間最長的數據項則






weixin_38324954

2020-07-08 11:06:52









遞歸(Recursion)及其應用






1. 什麼是遞歸
遞歸是一種解決問題的方法，其精髓在於將問題分解爲規模更小的相同問題，持續分解，直到問題規模小到可以用非常簡單直接的方式來解決。
遞歸問題分解方式非常獨特，其算法方面的明顯特徵就是：在算法流程中調用自身。
2. 遞






weixin_38324954

2020-07-08 11:06:52









未理解的題






關於樹的深度優先搜索算法描述錯誤的是
A : 按照某個條件往前試探搜索,如果前進中遭遇失敗, 則退回頭另選通路繼續搜索,直到找到條件目標爲止
B: 先訪問該節點所有的子節點, 遍歷完畢後選取它未訪問過的子節點重複上述過程,直到找到






harkecho

2020-07-08 10:56:02









按位與& 和 模運算 % 的關係






unsigned int MAX = 32; // 2的5次方
unsigned int index = 31;
index = (index + 100) % MAX;
printf ("inde






harkecho

2020-07-08 10:56:02









位運算判斷兩個數是否異號






首先介紹下負數在計算機中的表示和存儲
在計算機系統中，數值一律用補碼錶示和存儲。含符號位和數值位，符號位：0表示“正”； 1表示“負”。
正數的補碼 = 原碼
負數的補碼 = 負數的原碼取反（符號位保持不變）+ 1
列如
比如






harkecho

2020-07-08 10:56:01









按位或與加法的區別






0 | 0 = 0 1 | 1 = 1 0 | 1 = 1 1 | 0 = 1
0 ^ 0 = 0 1 ^ 1 = 0 0 ^ 1 = 1 1 ^ 0 = 1
0 & 0 = 0 1 &






harkecho

2020-07-08 10:56:01