LeetCode刷题day26

面试题 02.07. 链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'

解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'

解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null

解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

思路分析

题目的要求是求两个链表的交点,但是这里的交点是指指针相等,不是节点里面的值相同.

看如下两个链表，目前curA指向链表A的头结点，curB指向链表B的头结点,如何求得交点呢.

我们可以求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

此时我们就可以让CurA和CurB,从前往后遍历各自链表的节点,直到两者相等,此时对应的便是交点. 如果两个链表都遍历完还没有找到,则说明没有交点.

参考代码

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
	ListNode* curA = headA;
	ListNode* curB = headB;
	int lenA = 0,lenB = 0;
	while(curA!=NULL){//求LenA长度 
		curA = curA->next;
		lenA++; 
	} 
	while(curB!=NULL){//求LenB的长度 
		curB = curB->next;
		lenB++;
	}
	if(lenB>lenA){//始终让A代表的是最长的链表 
		swap(curA,curB);
		swap(lenA,lenB);
	} 
	int gap = lenA-lenB;
	while(gap--){
		curA = curA->next;
	}
	while(curA!=NULL){
		if(curA==curB){//注意:链表有交点指的是节点重复,而不是值重复. 
			return curA;
		}
		curA = curA->next;
		curB = curB->next;
	}
	return NULL;
}

142. 环形链表 II

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点

解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点

解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null

解释：链表中没有环。

思路分析

本题主要考察:

• 判断链表是否环
• 如果有环，如何找到这个环的入口

如何判断是否有环?:快慢指针

分别定义fast和slow指针,分别指向头结点,fast每次移动两个节点,slow每次移动一个节点,如果fast和slow指针在途中相遇,则说明这个链表有环.
这个过程就如同操场跑步一样,跑的快的人在一段时间后就会追上慢的人.

如果有环，如何找到这个环的入口$?$

从头结点出发一个指针index1，从相遇节点 也出发一个指针index2，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

证明过程可以参考卡尔大佬的文章,讲的通俗易懂,嘿嘿嘿

参考代码

ListNode *detectCycle(ListNode *head) {
	ListNode* fast,*slow;
	 fast = head;
	 slow = head;
	 while(fast!=NULL&&fast->next!=NULL){
	 	slow = slow->next;//slow走一步 
	 	fast = fast->next->next;//fast走两步
		if(slow==fast){//如果相遇 
			ListNode* index1 = fast;
			ListNode* index2 = head;
			while(index1!=index2){//此时如果相遇必定是入口节点 
				index1 = index1->next;
				index2 = index2->next; 
			} 
			return index1;
		}  
	 }
	 return NULL;//如果没有环,则返回NULL 
}

707. 设计链表

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

思路分析

盲猜面试出这个的可能性很大,很考查基础.

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

参考代码

#include<bits/stdc++.h>
using namespace std;

class MyLinkedList {
public:
    // 定义链表节点
    struct ListNode{
        int val;
        ListNode* next;
        ListNode():val(0),next(nullptr){
        }
        ListNode(int val):val(val),next(nullptr){
        }
        ListNode(int val,ListNode* next):val(val),next(next){
        }
    }; 
    MyLinkedList() {
    	// 头结点 
		head = new ListNode(0);
		// 链表长度(从0开始) 
		length = 0;
    }
    
    int get(int index) {
    	// 排除非法index 
		if(index > length-1 || index < 0) {
			return -1;
		}
		ListNode* cur = head;
		for(int i = 0; i <= index; i++){
			cur = cur->next;
		}
		return cur->val;
    }
    
    void addAtHead(int val) {
		ListNode* newNode = new ListNode(val,head->next);
		head->next = newNode;
		length++; 
    }
    
    void addAtTail(int val) {
		ListNode* cur = head;
		for(int i = 0;i < length; i++){
			cur = cur->next;
		}
		ListNode* newNode = new ListNode(val);
		cur->next = newNode;
		length++;
    }
    
    void addAtIndex(int index, int val) {
    	//判断index是否合理 
		if(index < 0 || index > length){
			return;
		}else if (index == 0){
			addAtHead(val);
			return;
		}else if(index == length){
			addAtTail(val);
			return;
		}
		// 其他普通位置 
		// 先找到index-1这个位置，然后插入节点
		ListNode* cur = head;
		for(int i = 0;i < index; i++) {
			cur = cur->next; 
		}
		ListNode* newNode = new ListNode(val,cur->next) ;
		cur->next = newNode;
		length++;
    }
    
    void deleteAtIndex(int index) {
		//判断删除位置是否合理
		if(index < 0 || index > length - 1) {
			return;
		}
		// 先找到index-1这个位置，然后删除节点
		ListNode* pre = head;
		for(int i = 0;i < index; i++) {
			pre = pre->next; 
		}
		ListNode* temp = pre->next;
		pre->next = pre->next->next;
		delete temp;
		length--;
    }

// 定义需要的变量(先定义在使用，所以需要放在下面~)
private:
    int length;
    ListNode* head;
};

本文的相关题目以及思路参考自卡尔大佬的代码随想录