面试笔试常考的关于链表的题

面试笔试常考的关于链表的题

1、单链表逆序，在原链表数据的基础上进行调整：

要在原链表的基础上进行逆序操作，可以使用三个指针prev、current和next来实现。遍历链表，将当前节点的指针指向前一个节点，然后更新prev、current和next指针，直到遍历完整个链表。最后将链表的头节点指向原链表的尾节点即可。

Node* reverse_linked_list(Node* head) 
{
	Node* prev = NULL;
	Node* current = head->next;
	Node* next = NULL;

	while (current != NULL)
	{
		next = current->next;
		current->next = prev;
		prev = current;
		current = next;
	}

	head->next = prev; // 更新头节点的next指针为逆序后的第一个节点
	return head;
}

2、找出单链表的倒数第n个结点：

可以使用双指针法来找到倒数第n个节点。首先让一个指针先移动n步，然后让另一个指针从头节点开始和第一个指针一起移动，直到第一个指针到达链表末尾。此时第二个指针就指向倒数第n个节点。

Node* find_nth_from_end(Node* head, int n) {
    Node *slow = head;
    Node *fast = head;
// 让快指针先移动n步
for (int i = 0; i < n; i++) {
    if (fast == NULL) {
        return NULL; // 链表长度小于n
    }
    fast = fast->next;
}

// 一起移动直到快指针到达末尾
while (fast != NULL) {
    slow = slow->next;
    fast = fast->next;
}

return slow;
}

3、判断链表中是否有环：

使用快慢指针法，快指针每次移动两步，慢指针每次移动一步，如果存在环，快慢指针最终会相遇。

bool has_cycle(Node* head) {
    if (head == NULL || head->next == NULL) {
        return false;
    }
Node *slow = head;
Node *fast = head;

while (fast != NULL && fast->next != NULL) {
    slow = slow->next;
    fast = fast->next->next;

    if (slow == fast) {
        return true; // 相遇，存在环
    }
}

return false; // 快指针到达链表末尾，不存在环
}

4、找出环形链表的入口：

当快慢指针相遇后，让其中一个指针回到头节点，然后两个指针每次移动一步，再次相遇的位置就是环的入口点。

Node* find_cycle_entry(Node* head) {
    Node *slow = head;
    Node *fast = head;
while (fast != NULL && fast->next != NULL) {
    slow = slow->next;
    fast = fast->next->next;

    if (slow == fast) {
        slow = head;
        while (slow != fast) {
            slow = slow->next;
            fast = fast->next;
        }
        return slow; // 返回环的入口点
    }
}

return NULL; // 不存在环
}

5、合并两个有序链表，合并后依然有序：

递归地比较两个链表的头节点，将较小的头节点作为新链表的头节点，然后递归地处理剩余的部分。

Node* merge_sorted_lists(Node* l1, Node* l2) {
    if (l1 == NULL) {
        return l2;
    } 
    if (l2 == NULL) {
        return l1;
    }
Node* merged = NULL;
if (l1->data <= l2->data) {
    merged = l1;
    merged->next = merge_sorted_lists(l1->next, l2);
} else {
    merged = l2;
    merged->next = merge_sorted_lists(l1, l2->next);
}

return merged;
}

6、判断两个链表是否是Y型链表，找出相交点：

遍历两个链表，分别计算它们的长度，然后让较长的链表先移动多出来的节点数，然后两个链表一起移动直到相遇，即为相交点。

Node* find_intersection(Node* head1, Node* head2) {
    int len1 = get_length(head1);
    int len2 = get_length(head2);
Node* current1 = head1;
Node* current2 = head2;

int diff = abs(len1 - len2);
if (len1 > len2) {
    for (int i = 0; i < diff; i++) {
        current1 = current1->next;
    }
} else {
    for (int i = 0; i < diff; i++) {
        current2 = current2->next;
    }
}

while (current1 != NULL && current2 != NULL) {
    if (current1 == current2) {
        return current1; // 返回相交点
    }
    current1 = current1->next;
    current2 = current2->next;
}

return NULL; // 未相交
}