力扣热题100---链表篇

回顾链表知识：单链表有一个头结点，不存储元素的值，所以P.next才是指链表的第一个元素。
1.合并两个有序链表
法一：递归

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2){
        if(l1==null){
            return l2;
        }
        if(l2==null){
            return l1;
        }
        if(l1.val>=l2.val){
          l2.next=mergeTwoLists(l1,l2.next);
          return l2;
        }else{
            l1.next=mergeTwoLists(l1.next,l2);
            return l1;
        }
    }
}

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

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

示例：

示例 1：

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

示例 2：

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

示例 3：

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

法一：循环
思路：使用哈希表来存储节点，如果该节点已经存在于哈希表中，则是循环链表。
代码：

public class Solution {
    public boolean hasCycle(ListNode head) {
        Set<ListNode> set=new HashSet<ListNode>();
        while(head!=null){
            if(set.add(head)){
                return true;
            }
            head=head.next;
        }
        return false; //只有一个节点时返回false
    }
}

法二：Floyd判圈算法（也称龟兔赛跑算法，快慢指针算法）
***算法介绍：***也称龟兔赛跑算法，假设龟兔同时进入链表，如果链表有环，则龟兔一定会相遇，否则兔子一定一直在乌龟前面。
思路：兔子结点走两步，龟结点走一步，

public class Solution {
    public boolean hasCycle(ListNode head) {
         if(head==null||head.next==null){
            return false;
        }
         ListNode fast=head.next;
         ListNode slow=head;
       
        while(slow!=fast){
            if(fast==null||fast.next==null){
                return false;
            }
            slow=slow.next;
            fast=fast.next.next;
        }
        return true;
    }
}

3.相交链表

题目：

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

思路：

链表1不相交长度为a,链表2不相交长度为b,相交部分链表长度为c,两个指针不会同时到达相交的节点，当遍历完一条链表时就走到另一个链表的头部，则当两个链表的起始节点都走完a+c+b时，就会在相交节点相遇。

三目运算：
x=a>b?a:b
解释：如果a>b，则x=a,否则x=b

代码：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
               if(headA==null||headB==null){
            return null;
        }
        ListNode pA=headA;
        ListNode pB=headB;
       while(pA!=pB){
           pA = pA == null ? headB : pA.next;
           pB = pB == null ? headA : pB.next;
        }
        return  pA;
    }
}

4.反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表

法一：递归
（没懂）

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode newHead = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }
}

法二：迭代
改变指针指向的方向
1->2->3变为1<-2<-3
（动笔画一下就会了）

class Solution {
   public ListNode reverseList(ListNode head) {
        ListNode prev=null;
        ListNode curr=head;
        while(curr!=null){
            ListNode next=curr.next;
            curr.next=prev;//头结点指向一个新结点
            prev=curr;
            curr=next;
        }
        return prev;
     }
}

5.回文链表

请判断一个链表是否为回文链表

示例 1:
输入: 1->2
输出: false

示例 2:
输入: 1->2->2->1
输出: true

法一：把链表的值复制到顺序表

思路：
1.把链表的值复制到顺序表（数组）中
2.通过数组比较值

注意区别ArrayList和int[] array

ArrayList:

1. size()
2. get(i)
3. equals()

int[] array:

1. length
2. array[i]
3. ==

class Solution {
    public boolean isPalindrome(ListNode head) {
        List arrayList=new ArrayList();//这个链表是顺序表，不是数组，函数不同
        //将链表中的值复制到数组中
        while(head!=null){
            arrayList.add(head.val);
            head=head.next;
        }
        int n= arrayList.size()-1;
        for(int i=0;i<n;i++){
            if(arrayList.get(i).equals(arrayList.get(n-i))){
                return true;
            }
        }
        return false;
    }
}