合并两个排序的链表
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
示例1：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode dummy=new ListNode(0);
ListNode r=dummy;
while(l1!=null&&l2!=null){
if(l1.val<=l2.val){
r.next=l1;
l1=l1.next;
} else{
r.next=l2;
l2=l2.next;
}
r=r.next;
}
r.next=l1==null?l2:l1;
return dummy.next;
}
递归形式：
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if(l1==null){
return l2;
}
if(l2==null){
return l1;
}
ListNode head;
if(l1.val<=l2.val){
l1.next=mergeTwoLists(l1.next,l2);
return l1;
} else{
l2.next=mergeTwoLists(l1,l2.next);
return l2;
}
}
反转链表
方法一：迭代
public ListNode reverseList(ListNode head) {
ListNode newHead=null;
ListNode p=head;
while(p!=null){
ListNode next=p.next;
p.next=newHead;
newHead=p;
p=next;
}
return newHead;
}
方法二：递归
public ListNode reverseList(ListNode head) {
if(head==null||head.next==null){
return head;
}
ListNode p=reverseList(head.next);
head.next.next=head;
head.next=null;
return p;
}
反转链表 II
反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
说明:
1 ≤ m ≤ n ≤ 链表长度。
示例:
输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL
方法一：迭代
public ListNode reverseBetween(ListNode head, int m, int n) {
ListNode dummy=new ListNode(0);//m=1时
dummy.next=head;
ListNode p = dummy;//指向开始反转位置的前一个元素
ListNode nextP = dummy.next;//指向开始反转位置，即反转后的链尾
for (int i = 0; i < m-1 ; i++) {
p = p.next;
nextP = nextP.next;
}
ListNode[] ans = reverseList(nextP, n - m + 1);
p.next = ans[0];
nextP.next = ans[1];
return dummy.next;
}
public ListNode[] reverseList(ListNode head, int n) {
ListNode newHead = null;
ListNode p = head;
ListNode[] ans = new ListNode[2];
ListNode next =null;
for (int i = 0; i < n; i++) {
next = p.next;
p.next = newHead;
newHead = p;
p = next;
}
ans[0] = newHead;//新的头结点
ans[1] = next;//反转前链表尾的后一个元素
return ans;
}
方法二：递归
public ListNode reverseBetween(ListNode head, int m, int n) {
if(m==1){//从第一个位置开始，即返回前n个
return reverseList(head,n);
}
head.next=reverseBetween(head.next,m-1,n-1);
return head;
}
private ListNode successor;
//反转前n个元素
public ListNode reverseList(ListNode head, int n) {
if(n==1){
successor=head.next;//记录后继结点
return head;
}
ListNode p=reverseList(head.next,n-1);
head.next.next=head;
head.next=successor;//将head指向后继，反转整条链表尾null
return p;
}
K 个一组翻转链表
给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
示例：
给你这个链表：1->2->3->4->5
当 k = 2 时，应当返回: 2->1->4->3->5
当 k = 3 时，应当返回: 3->2->1->4->5
思路：回忆常规链表反转，将每部分反转的链起来
//常规链表反转
public static ListNode reverse(ListNode head,int k) {
ListNode p=head;
ListNode newHead=null;
for (int i = 0; i 对于这个链表：1->2->3->4->5
添加哑结点后: 0->1->2->3->4->5 此时p=0 q=1
第一次反转
temp=1 q=3 2= reverse(1,2)
0->2->1 p=1 剩下3->4>5
第二次反转
temp=3 q=5 4=reverse(3,2)
0->2->1->4->3 p=3 剩下 5
第三次
temp=5 q==null 0->2->1->4->3->5
新代码
public ListNode reverseKGroup(ListNode head, int k) {
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode p = head;
ListNode linkNode = dummy;//用于连接链表
while (p != null) {
ListNode seeNode = p;//向前查看是否有k个
for (int i = 0; i < k; i++) {
if (seeNode == null) {//不够了直接顺序返回
linkNode.next = p;
return dummy.next;
}
seeNode = seeNode.next;
}
ListNode[] reverseNode = reverse(p, k);
linkNode.next = reverseNode[0];//连接到反转后的头结点
linkNode = p;//反转前的头结点成了尾结点，现在连接从这里开始
p = reverseNode[1];
}
return dummy.next;
}
// 返回新的头结点和原来链表n+1位置的结点
public ListNode[] reverse(ListNode head, int n) {
ListNode newHead = null;
ListNode p = head;
for (int i = 0; i < n; i++) {
ListNode next = p.next;
p.next = newHead;
newHead = p;
p = next;
}
return new ListNode[]{newHead, p};
}
两两交换链表中的节点
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
提示：
- 链表中节点的数目在范围
[0, 100]内 0 <= Node.val <= 100
方法一：迭代
public ListNode swapPairs(ListNode head) {
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode p = head;
ListNode link = dummy;
while (p != null && p.next != null) {
ListNode pair = p.next;
ListNode next = pair.next;
pair.next = p;
link.next = pair;
link = p;
p.next = next;
p = next;
}
return dummy.next;
}
方法二：递归
public ListNode swapPairs(ListNode head) {
if (head == null || head.next == null) {
return head;
}
ListNode nextHead = swapPairs(head.next.next);
ListNode next = head.next;
next.next = head;
head.next = nextHead;
return next;
}