链表有关的常见面试题

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;
}