鏈表有關的常見面試題

1.單鏈表逆序

實現1：

遍歷:

/*
 * 遍歷鏈表， 將每個結點的next置為其前驅
 * 遍歷過程中需要額外的指針來記錄結點的前驅和后繼
 */
LinkList ReverseList(LinkList L)
{
    if (!L || !L->next) {
        return L;
    }

    Node *pre, *cur, *next;

    pre = next = NULL;
    cur = L->next;
    while (cur) {
        next = cur->next;
        cur->next = pre;
        pre = cur;
        cur = next;
    }
    L->next = pre;

    return L;
}

實現2：

遞歸:

 

/*
 * 采用遞歸，每次遞歸返回子鏈表反轉后的頭指針
 */
Node * ReverseList(Node *node)
{
    if (!node || !node->next) {
        return node;
    }

    Node *next = node->next;
    Node *head = ReverseList(next);
    next->next = node;
    node->next = NULL;

    return head;
}

2.合並有序鏈表

實現1：

遍歷， 遍歷兩個鏈表，每次將較小的結點插入到合並后的新鏈表。

Node *Merge(Node *head1, Node *head2)
{
    /* 如果一個鏈表為空, 則直接返回另一個 */
    if (!head1) {
        return head2;
    }
    if (!head2) {
        return head1;
    }

    /* head為合並后的頭指針, p1 p2分別用來遍歷兩個鏈表 */
    Node *head, *p1, *p2;
    head = p1 = p2 = NULL;
    if (head1->data < head2->data) {
        head = head1;
        p1 = head1->next;
        p2 = head2;
    } else {
        head = head2;
        p2 = head2->next;
        p1 = head1;
    }

    /* cur為合並后鏈表的當前結點, 從p1和p2從選出較小的作為其后繼 */
    Node *cur = head;
    while (!p1 && !p2) {
        if (p1->data <= p2->data) {
            cur->next = p1;
            cur = p1;
            p1 = p1->next;
        } else {
            cur->next= p2;
            cur = p2;
            p2 = p2->next;
        }
    }

    /* 遍歷完一個鏈表后,將另一鏈表剩余結點插入到新鏈表中 */
    if (!p1) {
        cur->next= p1;
    } else {
        cur->next= p2;
    }

    return head;
}

實現2：

遞歸，每次遞歸返回合並后新鏈表的頭結點。

Node *MergeRecursive(Node *head1, Node *head2)
{
    if (!head1 || !head2) {
        return head1 ? head1 : head2;
    }

    Node *head;
    if (head1->data < head2->data) {
        head = head1;
        head->next = MergeRecursive(head1->next, head2);
    } else {
        head = head2;
        head->next = MergeRecursive(head1, head2->next);
    }

    return head;
}

3.判斷兩個無環單鏈表是否交叉，如果是則返回交點

實現1:

判斷是否交叉：因為無環單鏈表只可能是Y型交叉，所以遍歷兩個鏈表至最后一個結點，判斷最后一個結點是否相等即可。

bool IsCross(Node *head1, Node *head2)
{
    if (!head1 || !head2) {
        return false;
    }

    Node *p1 = head1;
    Node *p2 = head2;
    while (p1->next) {
        p1 = p1->next;
    }
    while (p2->next) {
        p2 = p2->next;
    }

    return (p1 == p2);
}

找出交點：遍歷兩個鏈表，記錄長度分別為L1和L2，先讓長的鏈表向后移動abs(L1-L2)，然后在逐個比較結點，第一個相等的結點即為交點。

Node *FindCross(Node *head1, Node *head2)
{
    if (!head1 || !head2) {
        return NULL;
    }

    /* 求出兩個鏈表的長度 */
    Node *p1, *p2;
    p1 = head1;
    p2 = head2;
    int len1, len2, len;
    len1 = len2 = 0;
    while (p1) {
        len1++;
        p1 = p1->next;
    }
    while (p2) {
        len2++;
        p2 = p2->next;
    }

    /* 將長鏈表先移動len個結點 */
    int i;
    len = abs(len1 - len2);
    p1 = head1;
    p2 = head2;
    if (len1 > len2) {
        for (i = 0; i < len; ++i) {
            p1 = p1->next;
        }
    } else {
        for (i = 0; i < len; ++i) {
            p2 = p2->next;
        }
    }

    /* 遍歷 找到第一個相等的結點即為交點 */
    while (!p1) {
        p1 = p1->next;
        p2 = p2->next;
        if (p1 == p2) {
            return p1;
        }
    }

    return NULL;
}

實現2：

將其中一個鏈表首尾相連，這樣就轉換成為判斷另一個鏈表是否有環即求進入環的結點的問題。

4.判斷單鏈表是否有環， 如果有環則返回進入環的第一個結點.

實現1：

設置快慢指針，初始都指向鏈表頭，快指針每次前進兩步，慢指針每次前進一步，如果有環則兩個指針必定相遇。

判讀是否有環:

bool HaveCircle(Node *head)
{
    if (!head) {
        return false;
    }

    Node *fast, *slow;
    fast = slow = head;

    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        if (fast == slow) {
            return true;
        }
    }

    return false;
}

找出環的位置:
實現2：

將結點的地址做hash，遍歷鏈表，檢測是否有地址相等的結點。

5.找出單鏈表的中間元素

實現：

設置快慢指針，初始都指向鏈表頭，快指針每次前進兩步，慢指針每次前進一步，當快指針到達鏈表末尾時，慢指針所指即為單鏈表的中間元素。

Node *FindMid(Node *head)
{
    if (!head) {
        return NULL;
    }

    Node *fast, *slow;
    fast = slow = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    /* 如果是fast為NULL, 則鏈表長度為奇數, slow為中間結點
    *  如果是fast->next為NULL, 則鏈表長度為偶數, slow 和 slow->next 為中間結點
    */
    return slow;
}

6.刪除單鏈表中倒數第k個結點

實現：

設置兩個指針p1和p2，p1指向鏈表第一個結點，p2指向第k+1個結點，兩個指針同時前進，當p2到達鏈表尾時，p1指向倒數第k+1個結點，刪除p1后面的一個結點即可。

Node *DeleteK(Node *head, int k) {
    if (!head) {
        return NULL;
    }

    int i;
    Node *p1, *p2;
    p1 = p2 = head;
    for (i = 0; i <= k; ++i) {
        if (p2) {
            p2 = p2->next;
        } else {
            return NULL;
        }
    }

    while (p2) {
        p1 = p1->next;
        p2 = p2->next;
    }
    p2 = p1->next;
    p1->next = p2->next;

    return p2;
}

7.從單鏈表中刪除指定的中間結點

實現：

將指定結點的后繼的值賦值給指定結點，然后刪除其后繼即可。

void DeleteMidNode(Node *del)
{
    if (!del) {
        return;
    }

    Node *next = del->next;
    if (next) {
        del->data= next->data;
        del->next= next->next;
        free(next);
    }
}

8.在單鏈表的指定結點前插入一個結點

實現：

將結點插入到指定結點后，然后交換兩節點的值即可。

int InsertBeforeNode(Node *node, Node *insert)
{
    if (!node || !insert) {
        return -1;
    }

    Node temp = *node;
    node->data = insert->data;
    node->next= insert;
    *insert = temp;

    return 0;
}