2. 程式人生 > >面試考題之9.2:連結串列(C/C++版)

面試考題之9.2:連結串列(C/C++版)

阿新 • • 發佈：2019-02-13

2.1 編寫程式碼，移除未排序連結串列中的重複結點。進階：如果不得使用臨時緩衝區，該怎麼解決？

解決方案：

方案1： 使用散列表

暫略

方案2：不借助額外緩衝區

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 #include <iostream>
#include
 <cstring>
#include <cstdio>   // getchar()
#include <cstdlib>  // free()

#include "LinkedList.h"

using namespace std;

void printData(LinkedList aList)
{
    cout << aList->data << "  ";
    return;
}


/************************************************************************/
// 函式名稱：deleteDups
// 函式目的：移除連結串列中重複的節點
// 函式引數：myList: 待操作的連結串列
// 函式返回：無
// 使用條件：
/************************************************************************/

void deleteDups(LinkedList theList)
{
    if (theList == NULL) return;

    LinkedList current = theList;
    while(current != NULL){
        // 移除後續值相同的所有結點
        LinkedList runner = current;
        while (runner->next != NULL){
            if (runner->next->data == current->data){
                LinkedList nextNode = runner->next;
                runner->next = runner->next->next;
                freeNode(nextNode);
            }
            else

                runner = runner->next;
        }
        current = current->next;
    }

    return;
}

int main()
{
    int arr[] = { 12, 13, 2, 4, 12, 6, 6, 8, 10, 4, 4, 2 };

    for (size_t i = 0; i < sizeof(arr) / sizeof(int); i++){
        //insert( makeNode(arr[i]) );
        insertBack( makeNode(arr[i]) );
    }

    traverse(printData);
    cout << endl;

    LinkedList theList = getHead();
    deleteDups(theList);
    cout << "呼叫deleteDups()函式後：" << endl;

    traverse(printData);
    cout << endl;

    destroy(); // 釋放連結串列

    getchar();
    return 0;
}

執行結果：


思考體會：

1、散列表怎樣解決該問題？

2.2 實現一個演算法，找出單向連結串列中倒數第K個結點。

解決方案：

方案1：遞迴

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 #include <iostream>
#include <cstring>
#include <cstdio>   // getchar()

#include "LinkedList.h"

using namespace std;

void printData(LinkedList aList)
{
    cout << aList->data << "  ";
    return;
}

/************************************************************************/
// 函式名稱：nthToLast
// 函式目的：求倒數第K個結點
// 函式引數：aList: 待操作的連結串列， k:第K個結點、i:計數器
// 函式返回：無
// 使用條件：
/************************************************************************/
LinkedList nthToLast(LinkedList aList, size_t k, size_t& i)
{
    if (NULL == aList) {
        return NULL;
    }

    LinkedList theList = nthToLast(aList->next, k, i);
    i += 1;
    if (i == k){
        return aList;
    }

    return theList;
}


int main()
{
    int arr[] = { 12, 13, 2, 4, 12, 6, 6, 8, 10, 4, 4, 2 };

    for (size_t i = 0; i < sizeof(arr) / sizeof(int); i++){
        insertBack( makeNode(arr[i]) );
    }

    traverse(printData);
    cout << endl;

    LinkedList theList = getHead();
    size_t k1 = 1, k2 = 4, i1 = 0, i2 = 0;
    LinkedList alist1 = nthToLast(theList, k1, i1);
    LinkedList alist2 = nthToLast(theList, k2, i2);

    cout << "K1 = " << alist1->data << endl;
    cout << "K2 = " << alist2->data << endl;     destroy(); // 釋放連結串列     getchar();
    return 0;
}

其他方案：

執行結果：


思考體會：

1、連結串列與遞迴的關係總是那麼若影若離，本題主要考查遞迴在連結串列中的使用。 2、其他高效方案？

2.3 實現一個演算法，刪除單向連結串列中間的某個結點，假定你只能訪問該結點。

示例

輸入：單向連結串列a->b->c->d->e中的結點c.

輸出：不返回任何資料，但該連結串列變為：a->b->d->e.

解決方案：

解法：將後繼結點的資料複製到當前結點，然後刪除這個後繼結點。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 #include <iostream>
#include <cstring>
#include <cstdio>   // getchar()

#include "LinkedList.h"

using namespace std;

void printData(LinkedList aList)
{
    cout << aList->data << "  ";
    return;
}

/************************************************************************/
// 函式名稱：deletNode2
// 函式目的：刪除單鏈表中的某個結點
// 函式引數：pNode:連結串列結點
// 函式返回：true:刪除成功
// 使用條件：pNode為非尾結點
/************************************************************************/
bool deletNode2(LinkedList pNode)
{
    if (pNode == NULL || pNode->next == NULL)
        return false;

    LinkedList nextNode = pNode->next;
    pNode->data = nextNode->data;
    pNode->next = nextNode->next;
    freeNode(nextNode);

    return true;
}

int main()
{
    int arr[] = { 12, 13, 2, 4, 12, 6, 6, 8, 10, 4, 4, 2 };

    for (size_t i = 0; i < sizeof(arr) / sizeof(int); i++){
        insertBack( makeNode(arr[i]) );
    }

    traverse(printData);
    cout << endl;

    LinkedList theList = getHead();

    LinkedList pNode = search(8);
    deletNode2(pNode);

    traverse(printData);

    destroy(); // 釋放連結串列

    getchar();
    return 0;
}

執行結果：


思考體會：

1、只要考查特殊情況。

2、在C++中刪除後繼結點時要手動刪除。

2.4 編寫程式碼，以給定值x為基準將連結串列分割為兩部分，所有小於x的結點排在大於或等於x的結點之前。

解決方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 #include <iostream>
#include <cstring>
#include <cstdio>   // getchar()

#include "LinkedList.h"

using namespace std;

void printData(LinkedList aNode)
{
    cout << aNode->data << "  ";
    return;
}

/************************************************************************/
// 函式名稱：partition
// 函式目的：以定值X分割pList
// 函式引數：pList:待操作連結串列首結點
// 函式返回：
// 使用條件：
/************************************************************************/
LinkedList partition(LinkedList pList, int x)
{
    LinkedList beforeStart  = NULL;
    LinkedList beforeEnd    = NULL;
    LinkedList afterStart   = NULL;
    LinkedList afterEnd     = NULL;

    if (pList == NULL) return NULL;

    // 分割連結串列
    LinkedList current = pList;  // 指向第一個元素
    while (current != NULL){
        // current結點要插入before或after表
        LinkedList nextNode = current->next;
        current->next = NULL;

        if (current->data < x){
            // 將結點插入before連結串列
            if (beforeStart == NULL){
                beforeStart = current;
                beforeEnd   = beforeStart;
            }else {
                beforeEnd->next = current;
                beforeEnd   = current;
            }
        }else {
            // 將結點插入before連結串列
            if (afterStart == NULL){
                afterStart  = current;
                afterEnd    = afterStart;
            }else {
                afterEnd->next = current;
                afterEnd = current;
            }
        }

        current = nextNode;
    } // end while()

    if (beforeStart == NULL) {
        return afterStart;
    }

    // 合併before和after連結串列
    beforeEnd->next = afterStart;
    return beforeStart;
}

int main()
{
    int arr[] = { 12, 13, 2, 4, 12, 6, 6, 8, 10, 4, 4, 2 };

    for (size_t i = 0; i < sizeof(arr) / sizeof(int); i++){
        insertBack( makeNode(arr[i]) );
    }

    traverse(printData);
    cout << endl;

    LinkedList theList = getHead();
    theList = partition(theList, 8);

    sethead(theList);

    traverse(printData);
    cout << endl;

    destroy(); // 釋放連結串列

    getchar();
    return 0;
}

執行結果：


思考體會：

1、沒有重新分配記憶體存放新的連結串列，靠移動指標來完成題設要求。

2、注意處理時一些細節。

2.5  給定兩個連結串列表示的整數，每個結點包含一個數位。這些數位是反向存放的，也就是個位排在連結串列首部。編寫函式對這兩個整數求和，並用連結串列形式返回結果。

示例：

輸入：(7->1->6) + (5->9->2), 即：617 + 295.

輸出：2->1->9,即：912.

進階：假設這些數位是正向存放的，請在做一遍。

示例：(6->1->7) + (2->9->5), 即：617 + 295.

輸出：9->1->2, 即：912。

解決方案：

方案1：數位反向存放

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 #include <iostream>
#include <cstring>
#include <cstdio>   // getchar()

#include "LinkedList.h"

using namespace std;

void printData(LinkedList aNode)
{
    cout << aNode->data << "  ";
    return;
}

/************************************************************************/
// 函式名稱：addLists
// 函式目的：兩個連結串列相加
// 函式引數：list1、ist2
// 函式返回：相加之後的連結串列
// 使用條件: 數位反向存放
/************************************************************************/
LinkedList addLists(LinkedList list1, LinkedList list2)
{
    LinkedList lt1 = list1, lt2 = list2, newList = NULL;

    int addData = 0;    // 相加和
    int carryI  = 0;    // 進位值
    while ( lt1 != NULL || lt2 != NULL ){

        if (lt1 != NULL && lt2 != NULL){
            addData = lt1->data + lt2->data;
            lt1 = lt1->next;
            lt2 = lt2->next;
        }else if (lt1 == NULL && lt2 != NULL){
            addData = lt2->data;
            lt2 = lt2->next;
        }else {
            addData = lt1->data;
            lt1 = lt1->next;
        }

        int totalData = addData + carryI;
        newList = insertBack( newList, makeNode(totalData % 10) );
        //newList = insert( newList, makeNode(totalData % 10) );
        carryI = totalData / 10;
    }

    if (carryI > 0){
        newList = insertBack( newList, makeNode(carryI) );
        //newList = insert( newList, makeNode(carryI) );
    }

    return newList;
}


int main()
{
    int arr1[] = {6, 1, 7};
    int arr2[] = {2, 9, 5};

    LinkedList list1 = NULL, list2 = NULL, newList = NULL;

    for (size_t i = 0; i < sizeof(arr1) / sizeof(int); i++){
        //list1 = insertBack( list1, makeNode(arr1[i]) );
        list1 = insert( list1, makeNode(arr1[i]) );
    }

    for (size_t i = 0; i < sizeof(arr2) / sizeof(int); i++){
        //list2 = insertBack( list2, makeNode(arr2[i]) );
        list2 = insert( list2, makeNode(arr2[i]) );
    }

    newList = addLists(list1, list2);

    cout << "list1 = ";   traverse(list1, printData);    cout << endl;
    cout << "list2 = ";   traverse(list2, printData);    cout << endl;
    cout << "newList = "; traverse(newList, printData);  cout << endl;

    getchar();
    return 0;
}

執行結果：


方案2：數位正向存放

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 #include <iostream>
#include <cstring>
#include <cstdio>   // getchar()

#include "LinkedList.h"

using namespace std;

void printData(LinkedList aNode)
{
    cout << aNode->data << "  ";
    return;
}

/************************************************************************/
// 函式名稱：addLists
// 函式目的：兩個連結串列相加
// 函式引數：list1、ist2
// 函式返回：相加之後的連結串列
// 使用條件: 數位反向存放
/************************************************************************/
LinkedList addLists(LinkedList list1, LinkedList list2)
{
    LinkedList lt1 = list1, lt2 = list2, newList = NULL;

    int addData = 0;    // 相加和
    int carryI  = 0;    // 進位值
    while ( lt1 != NULL || lt2 != NULL ){

        if (lt1 != NULL && lt2 != NULL){
            addData = lt1->data + lt2->data;
            lt1 = lt1->next;
            lt2 = lt2->next;
        }else if (lt1 == NULL && lt2 != NULL){
            addData = lt2->data;
            lt2 = lt2->next;
        }else {
            addData = lt1->data;
            lt1 = lt1->next;
        }

        int totalData = addData + carryI;
        newList = insertBack( newList, makeNode(totalData % 10) );
        carryI = totalData / 10;
    }

    if (carryI > 0){
        newList = insertBack( newList, makeNode(carryI) );
    }

    return newList;
}


int main()
{
    int arr1[] = {6, 1, 7};
    int arr2[] = {3, 9, 5};

    LinkedList list1 = NULL, list2 = NULL, newList = NULL;

    for (size_t i = 0; i < sizeof(arr1) / sizeof(int); i++){
        list1 = insertBack( list1, makeNode(arr1[i]) );
    }

    for (size_t i = 0; i < sizeof(arr2) / sizeof(int); i++){
        list2 = insertBack( list2, makeNode(arr2[i]) );
    }

    list1 = reverse(list1);
    list2 = reverse(list2);
    newList = addLists(list1, list2);

    // 轉換回原來的順序
    list1 = reverse(list1);
    list2 = reverse(list2);
    newList = reverse(newList);
    cout << "list1 = ";   traverse(list1, printData);    cout << endl;
    cout << "list2 = ";   traverse(list2, printData);    cout << endl;
    cout << "newList = "; traverse(newList, printData);  cout << endl;

    getchar();
    return 0;
}

執行結果：


思考體會：

1、正向存放題設解決這裡用一個函式reverse來反轉連結串列，在通過原來的addList計算，再把得到結果反轉回去。

2、其他更高效簡潔方法？

3、遞迴求解？

2.6  給定一個有環連結串列，實現一個演算法返回環路的開頭結點。有環連結串列定義：

在連結串列中某個結點的next元素指向在它前面出現過的結點，則表明該連結串列存在環路。

示例：

輸入：A->B->C->D->E->C(C結點出現兩次)。

輸出：C 

解決方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 #include <iostream>
#include <cstring>
#include <cstdio>   // getchar()

#include "LinkedList.h"

using namespace std;


/************************************************************************/
// 函式名稱：findBegining
// 函式目的：找到有環連結串列的開頭結點
// 函式引數：head:有環連結串列
// 函式返回：環開頭結點
// 使用條件:
/************************************************************************/
Node* findBegining(LinkedList head)
{
    LinkedList slow = head;
    LinkedList fast = head;

    /* 找出碰撞處，將處於連結串列中LOOP_SIZE-k步的位置 */
    while (fast != NULL && fast->next != NULL){
        slow = slow->next;
        fast = fast->next->next;

        if (slow == fast) {  // 碰撞
            break;
        }
    }

    /* 錯誤檢查，沒有碰撞處，也即沒有環路*/
    if (fast == NULL || fast->next == NULL){
        return NULL;
    }

    /* 將slow指向首部，fast指向碰撞處，兩者
     * 距離環路起始處k步，若兩者以相同的速度移動，
     * 則必定會在環路處碰撞在一起 */
     slow = head;
     while (slow != fast){
        slow = slow->next;
        fast = fast->next;
     }

    /* 至此兩者均指向環路起始處 */
    return fast;
}


int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9};

    for (size_t i = 0; i < sizeof(arr) / sizeof(int); i++){
        insertBack( makeNode(arr[i]) );
    }

    // 插入後形成環路
    Node* pNode = search(5);
    insertBack( pNode );

    LinkedList  head = getHead();
    Node* nodeBegin = findBegining( head );

    cout << "迴環開頭結點是：" << ((nodeBegin != NULL) ? nodeBegin : NULL ) << endl;
    cout << "迴環開頭結點值是：" << ((nodeBegin != NULL) ? nodeBegin->data : 0 ) << endl;

    getchar();
    return 0;
}

執行結果：


思考體會：

1、解答該題找到條件成立的點，得到規律。

2、經典面試題：檢測連結串列是否有環路，的變體。

2.7 編寫一個函式，檢查連結串列是否為迴文。

解決方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 #include <iostream>
#include <cstring>
#include <cstdio>   // getchar()

#include "LinkedList.h"

using namespace std;


/************************************************************************/
// 函式名稱：isPalindromes (遞迴實現)
// 函式目的：判斷一個連結串列是否是迴文
// 函式引數：head: 連結串列
// 函式返回：true: 是迴文
// 使用條件:
/************************************************************************/
bool isPalindrome(LinkedList head, size_t length, Node** nextNode)
{
    bool success = false;
    if ( NULL == head || length == 0){
        return false;
    }
    else if (length == 2){  // 偶數
        *nextNode = head->next;
    }
    else if (length == 3 ) { // 連結串列有奇數個元素，跳過中間元素
        *nextNode = head->next->next;
    }
    else {
         success =  isPalindrome(head->next, length - 2, nextNode);
         if (!success)  return false;
    }

    if ( nextNode == NULL || (*nextNode) == NULL) {
        return false;
    }

    // test
    cout << head->data << "\t" << (*nextNode)->data << endl;

    if (head->data != (*nextNode)->data) {
        return false;
    }

    *nextNode = (*nextNode)->next;  // 後移一位
    return true;
}

int main()
{
    int arr1[] = {6, 1, 7, 1, 6};
    int arr2[] = {3, 9, 5, 5, 9, 3};

    LinkedList list1 = NULL, list2 = NULL;

    for (size_t i = 0; i < sizeof(arr1) / sizeof(int); i++){
        list1 = insertBack( list1, makeNode(arr1[i]) );
    }

    for (size_t i = 0; i < sizeof(arr2) / sizeof(int); i++){
        list2 = insertBack( list2, makeNode(arr2[i]) );
    }

    Node** theNode = &list1;
    cout << "list1 = " << (isPalindrome(list1, size(list1), theNode) ?
                           "true" : "false") << endl;
    cout << "list2 = " << (isPalindrome(list2, size(list2), theNode) ?
                           "true" : "false") << endl;

    getchar();
    return 0;
}

執行結果：


思考體會：

1、理解遞迴的的的巧妙運用.

2、仔細體會指標的指標的應用.

相關推薦

面試考題之9.2:連結串列(C/C++版)

2.1 編寫程式碼，移除未排序連結串列中的重複結點。進階：如果不得使用臨時緩衝區，該怎麼解決？ 解決方案： 方案1： 使用散列表 暫略 方案2：不借助額外緩衝區 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

Leetcode中級演算法之奇偶連結串列(328)C++

給定一個單鏈表，把所有的奇數節點和偶數節點分別排在一起。請注意，這裡的奇數節點和偶數節點指的是節點編號的奇偶性，而不是節點的值的奇偶性。 請嘗試使用原地演算法完成。你的演算法的空間複雜度應為 O(1)，時間複雜度應為 O(nodes)，nodes 為節點總數。 示例 1: 輸入:

C#LeetCode刷題之#203-刪除連結串列中的節點（Remove Linked List Elements）

問題 刪除連結串列中等於給定值 val 的所有節點。 輸入: 1->2->6->3->4->5->6, val = 6 輸出: 1->2->3-&

C#LeetCode刷題之#206-反轉連結串列（Reverse Linked List）

問題 反轉一個單鏈表。 輸入: 1->2->3->4->5->NULL輸出: 5->4->3->2->1->NULL 進階: 你可以

玩轉C線性表和單向連結串列之Linux雙向連結串列優化

　　前言： 　　這次介紹基本資料結構的線性表和連結串列，並用C語言進行編寫；建議最開始學資料結構時，用C語言；像棧和佇列都可以用這兩種資料結構來實現。 　　一、線性表基本介紹　　 　　1 概念：                  線性表也就是關係戶中最簡單的一種關係，一對一。            

C++ STL之list雙向連結串列容器

不同於採用線性表順序儲存結構的vector和deque容器，list雙向連結串列中任一位置的元素查詢、插入和刪除，都具有高效的常數階演算法時間複雜度O(1)。 list技術原理 為了支援前向和反向訪問list容器的元素，list採用雙向迴圈的連結串列結構組織資

資料結構實現 2.1：連結串列（C++版）

1. 概念及基本框架 連結串列 是一種 線性結構 ，而且儲存上屬於 鏈式儲存（即記憶體的物理空間是不連續的），是線性表的一種。連結串列結構如下圖所示： 下面以一個我實現的一個簡單的連結串列類來進一步理解連結串列。 template <class T&g

ALGO-107演算法訓練 9-7連結串列資料求和操作 （c++）

  演算法訓練 9-7連結串列資料求和操作   時間限制：1.0s   記憶體限制：512.0MB      　　讀入10個複數，建立對應連結串列，然後求所有複數的和。 樣例輸入 1 2 1 3 4 5 2

【C++】STL常用容器總結之四：連結串列list

5、連結串列list List是每個節點包含前驅指標、後繼指標和資料域三個部分的雙向連結串列。List不提供隨機存取，訪問元素需要按順序走到需存取的元素，時間複雜度為O(n)，在list的任何位置上執行插入或刪除操作都非常迅速，只需在list內部調整一下指標。

資料結構程式碼實現之佇列的連結串列實現（C/C++）

上班閒著無聊，一直想著要開始寫部落格，但又不知道寫什麼。最近又回顧了下資料結構的知識，那就從資料結構開始吧。 前言 關於C語言結構體的知識以及佇列的特性請讀者自行了解，此處不做過多解釋，嘻嘻。 同時此篇文章僅僅是關於佇列的連結串列實現。 第一步：結構體編寫 我們首先分析一下佇列的

C++STL之list雙向連結串列容器

list容器實現了雙向連結串列的資料結構，資料元素是通過連結串列指標串成邏輯意義上的線性表，選擇對連結串列的任一位置的元素進行插入，刪除和查詢都是非常高效的。 list的每個節點有三個域：前驅元素指標域，資料域，後繼元素指標域，前驅元素的指標域儲存了前驅元

C語言遊戲之貪吃蛇--連結串列實現

早自習時突然想到怎麼寫貪吃蛇，話不多說，程式碼如下： 開發環境：vs2015 雖然開始還是出了很多指標問題。。。（很煩C語言指標）除錯了很久也大概是可以暢快的玩了。 C語言新手，有很多寫得不好的地方望大神提出 當然，我也不介意把我程式碼拿去學習（這樣就說明我的程式碼有

C++ STL 容器技術 之 list雙向連結串列容器

簡介： list是雙向連結串列的一個泛化容器，它的資料元素可通過連結串列指標串接成邏輯意義上的線性表。不同於採用線性表順序儲存結構的vector和deque容器，list雙向連結串列中任一位置的元素查詢、插入和刪除，都具有高效的常數階演算法時間複雜度O(1)。 lis

C++實現二叉樹之二叉連結串列

#include "stdafx.h" #include <iostream> #include <deque> using namespace std; template<typename T> struct TreeNode{

[C++ 從入門到放棄-07]C++STL之list雙向連結串列容器

學過資料結構都知道，其中有一章專門講線性表，其中有兩塊，一是順序表（也就是我們平時用的比較多的陣列，結構陣列），二是連結串列（有指標在，想想都複雜）。而C++ STL中給我們封裝好了一個list容器，

資料結構之單向連結串列（C++語言描述）

該檔案是整個原始檔，包括單向連結串列節點的定義，各種操作函式，main()測試用例。 #include <iostream> using namespace std; struct ListNode //用class時需要加publi

演算法面試之迴文連結串列判斷

簡介 【題目】 判斷一個連結串列是否為迴文結構 給定一個連結串列的頭節點head，請判斷該連結串列是否為迴文結構。 例如： 1->2->1，返回true。 1->2->2->1，返回true。 15->6->15，返

FreeRTOS程式碼分析之：全域性連結串列

注：有序插入：則根據xItemValue值從小到大(MAX：0xFF)，排序插入        無序插入：按照插入的時間先後順序，從第一個節點到最後一個節點(vListEnd)，依次插入 有序插入的執行時間較長，先後順序即代表了執行的順序，如CurrentTimer

資料結構之——陣列和連結串列

1. 陣列 1.1 陣列為什麼從零編號？ 陣列名代表陣列的首地址，陣列的下標其實代表陣列中某個元素相對首地址的偏移量，陣列的第一個元素是零偏移，因此從 0 開始。 上面其實也只是一個解釋， C 語言設計者用零開始編號，後來的各種語言也便紛紛效仿，因此就形成了這個習慣。 1

資料結構實現（五）：連結串列（C++版）

資料結構實現（五）：連結串列（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 增加操作 2.2 刪除操作 2.3 修改操作 2.4 查詢操作 2.5 其他操作 3. 演算法複雜度分析