＜LeetCode＞链表题汇总

206.链表翻转

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

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */

class Solution {
    public ListNode reverseList(ListNode head) {
     ListNode pre=null;
     ListNode curr=head;

     while(curr!=null)
     {
      //next 用来记录当前的下一个节点
         ListNode next = curr.next;
      // 当前节点可以指向pre（翻转的新链表）
         curr.next =pre;
      //记录好了然后，可以当前链表节点可以赋给pre了
         pre  = curr;
      //根据记录的next往下走一个节点
         curr =next;
     }
    return pre;
    }
}

92、翻转中间部分节点

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

class Solution{
public ListNode reverseBetween(ListNode head,int left, int right){
//因为头结点有可能发生变化，使用虚拟头结点存一下
ListNode dummyNode = new ListNode(-1);
dummyNode.next = head;

ListNode pre = dummyNode;
//第一步：走left-1步数，找到left的前一个节点
for(int i=0;i<left -1;i++)
{
pre=pre.next;
}
//第二步：来到right节点
ListNode rightNode = pre;
for(i=0;i<right-left+1;i++)
{
rightNode=rightNode.next;
}
//第三步：切断链表（切除一个子链表）
ListNode leftNode = pre.next;
ListNode curr = rightNode.next;
//切断链表
pre.next=null;
rightNode.next=null;

//第四部直接使用206的翻转
reverseLinkList(leftNode);

//把翻转后的链表接回去
pre.next = rightNode;
leftNode.next = curr;

return dummyNode.next;
}


 private void reverseLinkedList(ListNode head) {
        // 也可以使用递归反转一个链表
        ListNode pre = null;
        ListNode cur = head;

        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
    }


}

21、合并·两个有序链表

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode prehead = new ListNode(-1);

        ListNode prev = prehead;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }

        // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev.next = l1 == null ? l2 : l1;

        return prehead.next;
    }
}
。

61、旋转链表

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

方法一：闭合为环
思路及算法

记给定链表的长度为 nn，注意到当向右移动的次数 k \geq nk≥n 时，我们仅需要向右移动 k \bmod nkmodn 次即可。因为每 nn 次移动都会让链表变为原状。这样我们可以知道，新链表的最后一个节点为原链表的第 (n - 1) - (k \bmod n)(n−1)−(kmodn) 个节点（从 00 开始计数）。

这样，我们可以先将给定的链表连接成环，然后将指定位置断开。

具体代码中，我们首先计算出链表的长度 nn，并找到该链表的末尾节点，将其与头节点相连。这样就得到了闭合为环的链表。然后我们找到新链表的最后一个节点（即原链表的第 (n - 1) - (k \bmod n)(n−1)−(kmodn) 个节点），将当前闭合为环的链表断开，即可得到我们所需要的结果。

特别地，当链表长度不大于 11，或者 kk 为 nn 的倍数时，新链表将与原链表相同，我们无需进行任何处理。

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if (k == 0 || head == null || head.next == null) {
            return head;
        }
        int n = 1;
        ListNode iter = head;
        while (iter.next != null) {
            iter = iter.next;
            n++;
        }
        int add = n - k % n;
        if (add == n) {
            return head;
        }
        iter.next = head;
        while (add-- > 0) {
            iter = iter.next;
        }
        ListNode ret = iter.next;
        iter.next = null;
        return ret;
    }
}

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-linked-list-ii