LeetCode——链表专题

链表逆序

1.简单

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

简单，直接上手。

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode newHead = null;//新头节点
        ListNode cur = head;
        while(cur!=null){//顺序遍历，头插法插入
            ListNode Next = cur.next;//存储后继结点
            cur.next = newHead;
            newHead = cur;
            cur = Next;
        }
        return newHead;
    }
}

2.中等

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

说明:
1 ≤ m ≤ n ≤ 链表长度。

示例:

输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL

思路：先移动到要逆序的链表处，然后逆序之后再相连，思路简单，关键是做好标记变量。

class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
        int change_len = n - m + 1;//需要逆置的节点个数
        ListNode pre = null;//head结点的前驱
        ListNode res = head; //返回结果
        while(head!=null&&(--m!=0)){//移动到要逆置的链表头
            pre = head;
            head = head.next;
        }
        ListNode tail = head;//逆置后的链表尾
        ListNode newHead = null;
        while(head!=null&&(change_len!=0)){//逆置链表
            ListNode Next = head.next;
            head.next = newHead;
            newHead = head;
            head = Next;
            change_len--;
        }
        tail.next = head; //将逆置后的链表与后面剩余的链表相连
        if(pre!=null){//如果不是从头开始逆置的
            pre.next = newHead;//将前面剩余的尾结点指向逆置后的新节点
        }else{
            res = newHead;
        }
        return res;
    }
}

链表相交

1.简单

编写一个程序，找到两个单链表相交的起始节点。

如下面的两个链表：

在节点 c1 开始相交。

 

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 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
输出：Reference of the node with value = 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。

 

注意：

    如果两个链表没有交点，返回 null.
    在返回结果后，两个链表仍须保持原有的结构。
    可假定整个链表结构中没有循环。
    程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
	   public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
	        HashSet<ListNode> set =  new HashSet<>();
	        ListNode res = null;
	        while(headA!=null){
	            set.add(headA);
	            headA = headA.next;
	        }
	        while(headB!=null) {
	        	if(set.add(headB)==false) {
	        		res = headB;
                    break;
	        	}
                headB = headB.next;
	        }
	        return res;
	    }
}

给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

 

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

 

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

public class Solution {
    public boolean hasCycle(ListNode head) {
        boolean flg = false;
        HashSet<ListNode> set = new HashSet<>();
        while(head!=null){
            if(!set.add(head)){
                flg = true;
                break;
            }
            head = head.next;
        }
        return flg;
    }
}

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

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

 

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：tail connects to node index 1
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：tail connects to node index 0
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：no cycle
解释：链表中没有环。

 

进阶：
你是否可以不用额外空间解决此题？

public class Solution {
    public ListNode detectCycle(ListNode head) {
        HashSet<ListNode> set = new HashSet<>();
        while(head!=null){
            if(!set.add(head)){
                return head;
            }
            head = head.next;
        }
        return null;
    }
}