题目:有一个单链表,请设计一个算法,使得每K个节点之间逆序,如果最后不够K个节点一组,则不调整最后几个节点。例如链表1->2->3->4->5->6->7->8->null,K=3这个例子。调整后为,3->2->1->6->5->4->7->8->null。因为K==3,所以每三个节点之间逆序,但其中的7,8不调整,因为只有两个节点不够一组。给定一个单链表的头指针head,同时给定K值,返回逆序后的链表的头指针。
思路:这里的所谓逆序是对现有顺序的逆排序,不是指降序排序,即将k个结点的部分链表进行反转,反转链表在前面LB2中已经做过了,要反转一个链表,可以使用栈,思路很方便,但是需要额外的空间复杂度,最优解是使用空间复杂度为O(1)的解决方案:即总是保留连续的3个结点ppre,pcur,pnext;将pcur.next设置为ppre,然后将ppre,pcur,pnext全部向下移动一个结点即可。即反转K个结点是容易的。
关键是反转了K个结点之后,要将它与前面的已有链表连接起来,即将k个结点的前一个结点pleft与链表的尾结点pend连接起来,然后将链表头结点pstart与k个结点的下一个结点pright连接起来,从而完成链表中局部K个结点的反转。
对于原始链表来说,需要不断隔离出K个结点,对其进行逆序然后再连接到原始链表上面,总是需要保留k个结点之前的结点pleft以及k个结点之后的结点pright。
特殊地:
对于K=0,1时不需要逆序,直接返回原来链表的头结点head即可;
对于第一组的k个结点,反转后的head变成pend,最终返回的是pend,pstart与下一组k个结点的第一个结点pstart进行连接。
代码①:如果不单独将逆序放在一个方法中(即进行方法内联)
public class KInverse {
public ListNode inverse(ListNode head, int k) {
// 特殊的输入
if (head == null) return null;
if (k < 2) return head;
// 找出k个结点,需要用到4个工具点
ListNode pleft = null;
ListNode pstart = head;
ListNode pright = null;
ListNode pend = null;
// 遍历链表,每得到k个结点进行一次逆序排序操作
ListNode pcur = head;
int count = 1;
while (pcur != null) {
if (count == k) {
// 如果没有反转直接后面返回head,只有对于第一组反转即pend==null需要 // 改变头结点head为pcur,之后都不用改变head,即只有对第一组要修改头结点
//常识:这里使用三目运算优先级是先三目运算得到返回值再赋值:head = pend == null ? pcur : head
head = (pend == null ? pcur : head);
//这里pend是空间位置上的k个结点的最后结点,遍历顺序是321,反转指针后按顺序是123
pend = pcur;
pright = pcur.next;
// 链表的反转问题:设置3个结点(已知pleft,pstart,pright,pend进行反转)
ListNode ppre = pstart;
ListNode pcur2 = ppre.next;
ListNode pnext = null;
while (pcur2 != pright) {
pnext = pcur2.next;
pcur2.next = ppre;
ppre = pcur2;
pcur2 = pnext;
}
// 连接到原链表,特殊的,对于第一组即pleft==null时,左端不需要连接;反转好k个指针后关键是将其连接到原来的链表上面,这里需要小心;如果是第一次反转,即pleft为null时,不需要指定pleft.next = ppre
//ppre是当前遍历的k个结点中的最后结点,也是逆序后k个结点开始的结点。
if (pleft != null) pleft.next = ppre;
//pstart是k个结点空间上的第一个结点,即321中的1,也是逆序后的k个结点中的最后一个结点,他要与之后的结点连接
pstart.next = pright;
// 每次反转后需要重新设置pstart和pleft
pleft = pstart;
pstart = pleft.next;
//完成k个结点的逆序后,将count置为0,然后再找之后的k个结点
count = 0;
// 此时pcur向下移动到第k+1个结点而不是pcur.next,因为pcur已经逆向,对于pcur=1,他的pcur.next=2而不是6
pcur = pright;
} else {
pcur = pcur.next;
}
count++;
}
return head;
}
}
代码②:如果将进行逆序的方法单独提取出来形成一个方法inverseKNode,那么在已知pleft,pstart,pright,pend的情况下如果要对这段链表逆序,需要在调用方法时传入这4个参数,在方法中显然会对pleft,pstart,pright,pend进行修改,关键是理解在方法inverseKNode()中对输入对象的修改是否会真实地对调用位置的pleft,pstart,pright,pend产生变化,这里需要对Java引用传递的深入理解:
pleft,pstart,pright,pend这些字符本身其实是变量符号而已,是存放在栈中的引用指针,他们的值才是存放在堆中的对象,对于变量其实就可以当做是对象实体本身。于是,当pleft,pstart,pright,pend传入给方法inverseKNode之后,相当于方法中的形参pleft,pstart,pend,pright也指向了属性pleft,pstart,pend,pright指向的对象,即他们虽然名称相同,但是是两个变量,指针,批次没有关系,但是他们指向的对象是同一个。于是,当在方法inverseKNode对pstart.next=pright;修改时形参pstart指向的对象与外部pstart变量指向的还是同一个对象,因此在外部pstart还是可以访问到原来的对象,只是对象next值变化了;而在pleft=pstart;pstart=pleft.next修改时形参pleft,pstart指向了不同的对象,即与外部的pleft,pstart指向的不是同一个对象,所以这里对pleft,pstart的修改不会导致外部变量pleft,pstart对应对象的变化,所以在本方法调用后他们的pleft,pstart指向的对象与方法未调用前的值是一样的,即方法没有起效。
此时为了使得在方法inverseKNode中对pleft和pstart的改变能够影响到外部(即黄色部分)的值,需要将方法得到的值返回,这里由于有两个对象值,所以使用hashMap来进行返回。
public class KInverse {
public ListNode inverse(ListNode head, int k) {
//特殊的输入
if(head==null) return null;
if(k<2) return head;
//找出k个结点,需要用到4个工具点
ListNode pleft=new ListNode(-1);
ListNode pstart=head;
ListNode pright=null;
ListNode pend=null;
//遍历链表,每得到k个结点进行一次逆序排序操作
ListNode pcur=head;
int count=1;
while(pcur!=null){
if(count==k){
//如果没有反转直接后面返回head,只有对于第一组反转即pend==null需要改变头结点head位pcur,之后都不用改变head
head=(pend==null? pcur:head);
pend=pcur;
pright=pcur.next;
//调用逆序方法对这k个结点排序并连接到原链表上面
HashMap<String, ListNode>hashMap= inverseKNode(pleft,pstart,pend,pright);
pleft=hashMap.get("pleft");
pstart=hashMap.get("pstart");
count=0;
//此时pcur向下移动到第k+1个结点
pcur=pright;
}else{
pcur=pcur.next;
}
count++;
}
return head;
}
//对于给定的pstart到pend这几个结点,且已知其前面的结点pleft和后面的结点pright,对结点逆序并且连接到pleft和pright之间
public HashMap<String, ListNode> inverseKNode(ListNode pleft,ListNode pstart,ListNode pend,ListNode pright){
//链表的反转问题:设置3个结点
ListNode ppre=pstart;
ListNode pcur2=ppre.next;
ListNode pnext=null;
while(pcur2!=pright){
pnext=pcur2.next;
pcur2.next=ppre;
ppre=pcur2;
pcur2=pnext;
}
//连接到原链表,特殊的,对于第一组即pleft==null时,左端不需要连接
if(pleft!=null) pleft.next=ppre;
//形参pstart指向的对象与外部pstart变量指向的还是同一个对象,因此在外部pstart还是可以访问到原来的对象,只是对象next值变化了。
pstart.next=pright;
//一次反转后需要重新设置pstart和pleft
//形参pleft,pstart指向了不同的对象,即与外部的pleft,pstart指向的不是同一个对象,所以这里对pleft,pstart的修改不会导致外部变量pleft,pstart对应对象的变化,所以在本方法调用后他们的pleft,pstart指向的对象与方法未调用前的值是一样的,即方法没有起效。
pleft=pstart;
pstart=pleft.next;
//小心常识:方法调用时传入对象即对象逃逸时如何返回需要的处理后的对象
HashMap<String, ListNode> hashMap=new HashMap<>();
hashMap.put("pleft", pleft);
hashMap.put("pstart", pstart);
return hashMap;
}
}
类比:这种调用方法是可以的,原因如上面所说。
public class KInverse {
public ListNode inverse(ListNode head, int K) {
if (K < 2) {
return head;
}
ListNode cur = head;
ListNode start = null;
ListNode pre = null;
ListNode next = null;
int count = 1;
while (cur != null) {
next = cur.next;
if (count == K) {
start = pre == null ? head : pre.next;
head = pre == null ? cur : head;
resign(pre, start, cur, next);
pre = start;
count = 0;
}
count++;
cur = next;
}
return head;
}
public void resign(ListNode left, ListNode start, ListNode end,
ListNode right) {
ListNode pre = start;
ListNode cur = start.next;
ListNode next = null;
while (cur != right) {
next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
if (left != null) {
left.next = end; //只是修改对象的属性,对象还是原来的那个对象
}
start.next = right;
}
}