单链表Node节点类
public class Node { public int val; public Node next; public Node(int val) { this.val = val; } }
双链表DoubleNode类
public class DoubleNode { public int val; public DoubleNode last; public DoubleNode next; public DoubleNode(int val) { this.val = val; } }
一、打印两个有序链表的公共部分
问题:给定两个有序链表head1和head2,打印两个链表的公共部分
解答:(1)如果head1的值小于head2,则head1向下移动。(2)如果head2的值小于head1的值,则head2向下移动。(3)如果head1的值等于head2的值,则打印这个值,然后head1和head2都往下移动。(4)head1或head2有任意一个移动到null,则整个过程停止
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public void printCommonPart(Node head1, Node head2) { while (head1 != null && head2 != null) { if (head1.val < head2.val) { head1 = head1.next; } else if (head1.val > head2.val) { head2 = head2.next; } else { System.out.print(head1.val + " "); head1 = head1.next; head2 = head2.next; } } System.out.println(); }
二、在单链表和双链表中删除倒数第K个节点
题目1:删除单链表中倒数第K个节点
在删除问题中,如果想要删除某一个节点,就必须定位到要删除节点的前一个节点。
解答:
(1)如果链表为空或者K值小于1,则直接返回即可。否则让链表从头开始走到尾,每移动一步,就让K值减1,链表走到结尾时,判断K值的大小
(2)如果K值大于0(1→2→3,K=4,K:3 2 1),说明链表没有倒数第K个节点,直接返回即可。
(3)如果K值等于0(1→2→3,K=3,K:2 1 0),说明倒数第K个节点就是头节点,直接删除头节点,返回head.next即可
(4)如果K值小于0(1→2→3,K=2,K:1 0 -1),此时,重新从头节点开始走,每移动一步,就让K的值加1,当K等于0时,移动停止,此时的节点就是要删除节点的前一个节点。(假设链表长度为N,那么倒数第K个节点的前一个节点就是第N-K个节点,第一次遍历后,K变为K-N,第二次遍历后,遍历到第N-K个节点时K为0)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public Node removeLastKthNode(Node head, int lastKth) { if (head == null || lastKth < 1) { return head; } Node cur = head; while (cur != null) { lastKth--; cur = cur.next; } if (lastKth == 0) { head = head.next; } if (lastKth < 0) { cur = head; while (++lastKth != 0) { cur = cur.next; } cur.next = cur.next.next; } return head; }
题目2:删除双链表中倒数第K个节点(和单链表同理,只是注意last指针的重连即可)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public DoubleNode removeLastKthNode(DoubleNode head, int lastKth) { if (head == null || lastKth < 1) { return head; } DoubleNode cur = head; while (cur != null) { lastKth--; cur = cur.next; } if (lastKth == 0) { head = head.next; head.last = null; } if (lastKth < 0) { cur = head; while (++lastKth != 0) { cur = cur.next; } DoubleNode newNext = cur.next.next; cur.next = newNext; if (newNext != null) { newNext.last = cur; } } return head; }
三、删除链表的中间节点和a/b处的节点
题目1:删除链表的中间节点,例如1→2删除节点1,1→2→3删除节点2,1→2→3→4删除节点2,1→2→3→4→5删除节点3
解答:如果链表为空或长度为1,则直接返回,如果链表长度为2,删除头节点即可,则3-2,4-2,5-3,6-3...,也就是长度每增加2,要删除的节点就后移一个节点。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public Node removeMidNode(Node head) { if (head == null || head.next == null) { return head; } if (head.next.next == null) { return head.next; } Node pre = head; Node cur = head.next.next; while (cur.next != null && cur.next.next != null) { pre = pre.next; cur = cur.next.next; } pre.next = pre.next.next; return head; }
题目2:删除位于a/b处节点,链表1→2→3→4→5,假设a/b=r,则r==0不删除任何节点,r在(0,1/5]上删除节点1,r在(1/5,2/5]删除节点2,如果r大于1,不删除任何节点
解答:根据链表长度n,以及a和b先计算出n*(a/b)的值,然后r向上取整就是要删除的节点的位置。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public Node removeByRatio(Node head, int a, int b) { if (a < 1 || a > b) { return head; } int n = 0; Node cur = head; while (cur != null) { n++; cur = cur.next; } n = (int)Math.ceil((double) (a * n) / (double)b); if (n == 1) { head = head.next; } if (n > 1) { cur = head; while (--n != 1) { cur = cur.next; } cur.next = cur.next.next; } return head; }
四、反转单向和双向链表
题目1:反转单向链表
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public Node reverseList(Node head) { Node pre = null; Node next = null; while (head != null) { next = head.next; head.next = pre; pre = head; head = next; } return pre; }
题目2:反转双向链表
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public DoubleNode reverseList(DoubleNode head) { DoubleNode pre = null; DoubleNode next = null; while (head != null) { next = head.next; head.next = pre; head.last = next; pre = head; head = next; } return pre; }
五、反转部分单向链表
题目:给定一个单链表和两个整数from和to,把第from个到第to个节点这一部分进行反转。例如1→2→3→4→5→null,from=2,to=4,则1→4→3→2→5→null
解答:
(1)如果1<=from<=to<=N不满足,返回原来的头节点
(2)找到第from-1个节点fPre和第to+1个节点tPos,把反转的部分先反转,然后正确连接fPre和tPos
(3)如果fPre为null,说明反转部分是包含头节点的,返回每反转以前反转部分的最后一个节点作为新的头节点,如果fPre不为null,返回旧的头节点。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public Node reversePart(Node head, int from, int to) { int len = 0; Node node1 = head; Node fPre = null; Node tPos = null; while (node1 != null) { len++; fPre = len == from - 1 ? node1 : fPre; tPos = len == to + 1 ? node1 : tPos; node1 = node1.next; } if (from > to || from < 1 || to > len) { return head; } node1 = fPre == null ? head : fPre.next; Node node2 = node1.next; node1.next = tPos; Node next = null; while (node2 != tPos) { next = node2.next; node2.next = node1; node1 = node2; node2 = next; } if (fPre != null) { fPre.next = node1; return head; } return node1; }
六、两个单链表生成相加链表
问题:9→3→7代表整数937,6→3代表整数63,将两个链表相加得到937+63=1000,返回1→0→0→0
思路:如果先分别算出各自链表所代表的整数,那么链表的长度很长,可以表示一个很大的数,转换成int时可能会异常
解法1:利用栈结构
(1)将两个链表从左到右遍历,并压入各自的栈中。因此s1:9 3 7,s2:6 3,
(2)将s1和s2同步弹出,然后相加链表即可,同时还需要关注是否有进位
(3)当s1和s2都为空时,如果进位信息为1,还要生成一个节点值为1的新结点
注意:两个整数相加与进位问题。1. n1 = s1.isEmpty() ? 0 : s1.pop();2.n = n1 + n2 + ca;3.node = new Node(n % 10);4.ca = n / 10;
注意:从后往前生成链表的过程。 pre = node; node = new Node(n % 10); node.next = pre;
public Node addLists1(Node head1, Node head2) { Stack<Integer> s1 = new Stack<>(); Stack<Integer> s2 = new Stack<>(); while (head1 != null) { s1.push(head1.val); head1 = head1.next; } while (head2 != null) { s2.push(head2.val); head2 = head2.next; } int ca = 0; int n1 = 0, n2 = 0; int n = 0; Node node = null; Node pre = null; while (!s1.isEmpty() || !s2.isEmpty()) { n1 = s1.isEmpty() ? 0 : s1.pop(); n2 = s2.isEmpty() ? 0 : s2.pop(); n = n1 + n2 + ca; pre = node; node = new Node(n % 10); node.next = pre; ca = n / 10; } if (ca == 1) { pre = node; node = new Node(1); node.next = pre; } return node; }
解法2:利用链表的逆序
(1)将两个链表逆序,依次得到从低位到高位的数字
(2)遍历两个逆序后的链表,过程和解法1类似
需要注意:1.1 = c1 != null ? c1.val : 0; 2.c1 = c1 != null ? c1.next : null; 3.完成后还需要reverseList(head1); reverseList(head2);将原来的链表返回原状。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public Node addList2(Node head1, Node head2) { head1 = reverseList(head1); head2 = reverseList(head2); int ca = 0, n1 = 0, n2 = 0, n = 0; Node c1 = head1; Node c2 = head2; Node node = null; Node pre = null; while (c1 != null || c2 != null) { n1 = c1 != null ? c1.val : 0; n2 = c2 != null ? c2.val : 0; n = n1 + n2 + ca; pre = node; node = new Node(n%10); node.next = pre; ca = n / 10; c1 = c1 != null ? c1.next : null; c2 = c2 != null ? c2.next : null; } if (ca == 1) { pre = node; node = new Node(1); node.next = pre; } reverseList(head1); reverseList(head2); return node; }
七、删除无序单链表中值重复出现的节点
问题:给定一个无序单链表,删除其中值重复出现的节点,例如1→2→3→3→4→4→2→1→1→null,返回1→2→3→4→null。
解法1:利用哈希表,但是时间复杂度为O(N),空间复杂度为O(N)
最近一个没有被删除的节点为pre,当前节点cur的值如果出现过,就令pre.next=cur.next;如果没出现过,就将cur的值加入到哈希表,同时令pre=cur。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public void removeRep1(Node head) { if (head == null) { return; } HashSet<Integer> set = new HashSet<>(); Node pre = head; Node cur = head.next; set.add(head.val); while (cur != null) { if (set.contains(cur.val)) { pre.next = cur.next; } else { set.add(cur.val); pre = cur; } cur = cur.next; } }
解法2:利用选择排序的过程,时间复杂度为O(N2),空间复杂度为O(1)(直接选择排序时间复杂度为O(N2))
例如1→2→3→3→4→4→2→1→1→null,(1)cur值为1,检查后面所有值为1的节点全部删除(2)cur值为2,检查后面值为2的节点全部删除...依次类推
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public void removeRep2(Node head) { Node cur = head; Node pre = null; Node next = null; while(cur != null) { pre = cur; next = cur.next; while (next != null) { if (cur.val == next.val) { pre.next = next.next; } else { pre = next; } next = next.next; } cur = cur.next; }
八、在单链表删除指定值的节点
题目:给定一个单链表和一个整数num,删除值为num的全部节点。例如:1→2→3→4→null,num=3,返回:1→2→4→null
方法1:O(N)+O(N)利用栈或者其他容器收集值不等于num的节点,收集完成后重新连接即可。最后返回栈底节点为新的头结点
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public Node removeValue1(Node head, int num) { Stack<Node> stack = new Stack<>(); while(head != null) { if (head.val != num) { stack.push(head); } head = head.next; } while (!stack.isEmpty()) { stack.peek().next = head; // head一开始为null head = stack.pop(); } return head; }
方法2:O(N)+O(1)不用任何容器直接调整。找到第一个不为num的节点作为新的头结点newHead,继续往后遍历,如果cur的值等于num,就将cur删除,即令最近一个值不等于num的pre.next=cur.next,如果不等于,就令pre=cur
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public Node removeValue2(Node head, int num) { while (head != null) { if (head.val != num) { break; } head = head.next; } Node pre = head; Node cur = head; while(cur != null) { if (cur.val == num) { pre.next = cur.next; } else { pre = cur; } cur = cur.next; } return head; }
九、单链表的选择排序
题目:给定一个无序单链表,实现单链表的选择排序,要求空间复杂度为O(1)
选择排序就是:从未排序的部分中找到最小值,然后放在排好序部分的尾部,逐渐将未排序的部分缩小,最后全部变成排好序的部分。
解法:O(N2)+O(1)
(1)找到最小值节点,将其设置成新的头节点newHead
(2)每次在未排序的部分中找到最小值的节点,然后把这个节点从未排序的链表中删除,同时连接删除节点的前后节点
(3)把删除的节点连接在排好序部分的链表尾部
public Node getSmallestPreNode(Node head) { Node smallPre = null; Node small = head; Node pre = head; Node cur = head.next; while (cur != null) { if (cur.val < small.val) { smallPre = pre; small = cur; } pre = cur; cur = cur.next; } return smallPre;// 返回以head为头结点的单链表中最小值节点的前一个节点 } public Node selectionSort(Node head) { Node tail = null; // 已排序部分尾部 Node cur = head; // 未排序部分头部 Node smallPre = null; // 最小节点的前一个节点 Node small = null; // 值最小的节点 while (cur != null) { small = cur; smallPre = getSmallestPreNode(cur); if (smallPre != null) { // small为未排序部分的最小值 small = smallPre.next; // 将最小值节点从未排序的部分删除 smallPre.next = small.next; } // smallPre为null时,说明当前节点cur已经是最小值,因此在原链表中删除头节点 cur = cur == small ? cur.next : cur; if (tail == null) { head = small; } else { tail.next = small; } tail = small; } return head; }
十、一种怪异的节点删除方式
问题:给定一个链表的节点node,但不给定整个整个链表的头节点,如何在链表中删除node?并分析出现的问题
思路:例如1→2→3→null,如果要删除节点2,那么在仅给定节点2的情况下,将节点2的值变成3,然后删除结点3即可。(在链表中删除节点的原则,必须定位到待删节点的上一个节点)
可能出现的问题:
(1)无法删除最后一个节点。因为如果要删除节点3,由于根本没有下一个节点来代替节点3被删除,那么只有让节点2的next指向null这一种办法,但是又根本找不到节点2,所以就无法正确删除节点3。
(2)这种删除方式在本质上根本不是删除了node节点,而是把node节点的值改变,然后删除node的下一个节点。在实际工程中,一个节点可能代表很复杂的结构,节点的复制会相当复杂,或者可能改变节点值这个操作都是被禁止的;或者工程上一节点代表提供服务的一个服务器,外界对每个节点都有很多依赖,例如,在删除节点2时,实际上影响了节点3对外提供的服务。
注意:异常的抛出,RuntimeException异常类不需要导包。
public void removeNodeWired(Node node) { if (node == null) { return; } Node next = node.next; if (next == null) { throw new RuntimeException("can not remove last node."); } node.val = next.val; node.next = next.next; }
十一、向有序的环形单链表中插入新节点
问题:一个环形单链表从头节点head开始不降序,同时由最后的节点指向头节点。给定一个环形单链表的头节点和一个整数num,生成节点值为num的新节点,并插入到这个环形链表中,保证调整后的链表依然有序。
解法:
(1)生成节点值为num的新节点,记为node
(2)如果链表为空,直接返回node
(3)令pre=head,cur=head.next,令pre和cur同步移动,如果pre的节点值小于或等于num,并且cur的节点值大于或等于num,说明node应该在pre和cur节点之间插入
(4)如果pre和cur转了一圈都没有发现插入位置,说明node应该插入到头节点的前面,此时是因为链表中每个节点都大于num或者都小于num。如果num比每个节点值都大,返回原来的头节点即可;如果num比每个节点的值都小,应该把node作为链表新的头节点返回。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public Node insertNum(Node head, int num) { Node node = new Node(num); if (head == null) { node.next = node; return node; } Node pre = head; Node cur = head.next; while (cur != head) { if (pre.val <= num && cur.val >= num) { break; } pre = cur; cur = cur.next; } pre.next = node; node.next = cur; return head.val < num ? head : node; }
十二、合并两个有序的单链表
题目:给定两个有序单链表head1和head2,返回合并后的链表。例如:0→2→3→7→null,1→3→5→7→9→null,返回0→1→2→3→3→5→7→7→9→null
解法:(O(M+N) + O(1))
(1)如果两个链表有一个为空,返回非空链表头节点
(2)head1和head2中小的节点就是新链表的头节点
(3)每次比较遍历到的值,根据大小关系作出调整,同时用一个变量pre表示上次比较时值较小的节点
链表1:1→5→6→null, 链表2:2→3→7→null
cur1=1,cur2=2,pre=null,cur1小于cur2,不作调整,pre=cur1
cur1=5,cur2=2,pre=1,cur2小于cur1,pre.next指向cur2,cur2.next指向cur1,pre=2,此时1→2→5→6→null,3→7→null,
cur1=5,cur2=3,pre=2,cur2小于cur1,pre.next指向cur2,cur2.next指向cur1,pre=3,此时1→2→3→5→6→null,7→null
cur1=5,cur2=7,pre=3,cur1小于cur2,不作调整,pre=5
cur1=6,cur2=7,pre=5,cur1小于cur2,不作调整,pre=6,
此时cur1=null,pre为链表1的最后一个节点,把pre.next指向cur2
(4)如果链表1先走完,此时cur1=null,pre为链表1的最后一个节点,那么就把pre的next指针指向链表2的当前节点,即cur2;如果链表2先走完,说明链表2的所有节点已经插入到链表1中,此时返回新的头节点即可。
注意:pre这个变量在这道题里面所起到的作用。 pre.next = cur1 == null ? cur2 : cur1;
public Node merge(Node head1, Node head2) { if (head1 == null || head2 == null) { return head1 != null ? head1 : head2; } Node head = head1.val < head2.val ? head1 : head2; Node cur1 = head == head1 ? head1 : head2; Node cur2 = head == head1 ? head2 : head1; Node pre = null; Node next = null; while (cur1 != null && cur2 != null) { if (cur1.val <= cur2.val) { pre = cur1; cur1 = cur1.next; } else { next = cur2.next; pre.next = cur2; cur2.next = cur1; pre = cur2; cur2 = next; } } pre.next = cur1 == null ? cur2 : cur1; return head; }
十三、按照左右半区的方式重新组合单链表
问题:给定一个长度为N的单链表,如果N为偶数,那么前N/2个节点为左半区,后N/2个节点为右半区;如果N为奇数,那么前N/2个节点算作左半区,后N/2+1个节点为右半区,将单链表调整成L1→R1→L2→R2..的形式。例如:1→2→3→4→null调整为1→3→2→4→null,1→2→3→4→5→null调整为1→3→2→4→5→null
解法:O(N)+O(1)
(1)如果链表为空或长度为1,则直接返回
(2)遍历一遍找到左半区的最后一个节点,记为mid,这里涉及到之前做过的题,求中间节点的方法:即从长度为2开始,长度每增加2,mid就向后移动一个节点。例如:12mid为1,123mid为1,1234mid为2,12345mid为2,123456mid为3...
(3)将左右半区分离成2个链表即mid.next=null,头结点分别为原来的head记为left,和mid.next记为right。
注意:1.mergeLR方法是将right链表的每一个节点依次插入到left的合适位置中。
2.求链表中间节点mid的方法: Node mid = head; Node right = head.next; while (right.next != null && right.next.next != null) { mid = mid.next; right = right.next.next; }
public void relocate(Node head) { if (head == null || head.next == null) { return; } Node mid = head; Node right = head.next; while (right.next != null && right.next.next != null) { mid = mid.next; right = right.next.next; } right = mid.next; mid.next = null; mergeLR(head, right); } public void mergeLR(Node left, Node right) { Node next = null; while (left.next != null) { next = right.next; right.next = left.next; left.next = right; left = right.next; right = next; } left.next = right; }