From 5edfe37a46501cbe8781193aa1f1fad4c88dafdc Mon Sep 17 00:00:00 2001 From: ehlxr Date: Wed, 4 May 2022 19:31:51 +0800 Subject: [PATCH] update at 2022-05-04 19:31:51 by ehlxr --- .../algorithm/linkedlist/ReverseKGroup.java | 92 +++++++++++++++++++ .../linkedlist/ReverseLinkedList.java | 62 +++++++++---- 2 files changed, 138 insertions(+), 16 deletions(-) create mode 100644 budd-common/src/main/java/io/github/ehlxr/algorithm/linkedlist/ReverseKGroup.java diff --git a/budd-common/src/main/java/io/github/ehlxr/algorithm/linkedlist/ReverseKGroup.java b/budd-common/src/main/java/io/github/ehlxr/algorithm/linkedlist/ReverseKGroup.java new file mode 100644 index 0000000..0367810 --- /dev/null +++ b/budd-common/src/main/java/io/github/ehlxr/algorithm/linkedlist/ReverseKGroup.java @@ -0,0 +1,92 @@ +/* + * The MIT License (MIT) + * + * Copyright © 2022 xrv + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package io.github.ehlxr.algorithm.linkedlist; + +/** + * @author ehlxr + * @since 2022-05-03 14:26. + */ +public class ReverseKGroup { + public static void main(String[] args) { + ListNode head = new ListNode(1); + head.next = new ListNode(2); + head.next.next = new ListNode(3); + head.next.next.next = new ListNode(4); + head.next.next.next.next = new ListNode(5); + System.out.println(head); + System.out.println(reverseKGroup(head, 2)); + } + + public static ListNode reverseKGroup(ListNode head, int k) { + ListNode p = head; + for (int i = 0; i < k; i++) { + if (p == null) { + return head; + } + p = p.next; + } + + ListNode r = reverseN(head, p); + head.next = reverseKGroup(p, k); + + return r; + } + + public static ListNode reverseN(ListNode head, ListNode n) { + ListNode cur = head, pre = null; + while (cur != n) { + ListNode next = cur.next; + cur.next = pre; + pre = cur; + cur = next; + } + return pre; + } + + public static class ListNode { + int val; + ListNode next; + + ListNode() { + } + + ListNode(int val) { + this.val = val; + } + + ListNode(int val, ListNode next) { + this.val = val; + this.next = next; + } + + @Override + public String toString() { + return "ListNode{" + + "val=" + val + + ", next=" + next + + '}'; + } + } +} diff --git a/budd-common/src/main/java/io/github/ehlxr/algorithm/linkedlist/ReverseLinkedList.java b/budd-common/src/main/java/io/github/ehlxr/algorithm/linkedlist/ReverseLinkedList.java index 0d6cf30..77cacbf 100644 --- a/budd-common/src/main/java/io/github/ehlxr/algorithm/linkedlist/ReverseLinkedList.java +++ b/budd-common/src/main/java/io/github/ehlxr/algorithm/linkedlist/ReverseLinkedList.java @@ -36,17 +36,53 @@ public class ReverseLinkedList { Node node4 = new Node(4, node5); Node node3 = new Node(3, node4); Node node2 = new Node(2, node3); - Node node1 = new Node(1, node2); - Node node0 = new Node(0, node1); - Node root = new Node(null, node0); + Node head = new Node(1, node2); - Node reverse = reverse(root); - // root.print(); + // Node reverse = reverse(root); + // reverse.print(); - reverse.print(); + // System.out.println(reverseToN(head, node3)); + // System.out.println(reverseToN(head, 2)); + System.out.println(reverseFm2N(head, 2, 4)); } + public static Node reverseToN(Node root, Node n) { + Node pre = null, cur = root, tmp = root; + while (cur != n) { + tmp = cur.next; + + cur.next = pre; + pre = cur; + cur = tmp; + } + + return pre; + + } + + static Node next = null; + + public static Node reverseToN(Node root, int n) { + if (n == 1) { + next = root.next; + return root; + } + + Node h = reverseToN(root.next, n - 1); + root.next.next = root; + root.next = next; + return h; + } + + public static Node reverseFm2N(Node root, int m, int n) { + if (m == 1) { + return reverseToN(root, n); + } + root.next = reverseFm2N(root.next, m - 1, n - 1); + return root; + } + public static Node reverse(Node root) { Node pre = null; @@ -73,17 +109,11 @@ class Node { this.value = value; } - public void print() { - System.out.println(this); - Node tmp = this.next; - while (tmp != null) { - System.out.println(tmp); - tmp = tmp.next; - } - } - @Override public String toString() { - return "Node[value=" + this.value + "]"; + return "Node{" + + "value=" + value + + ", next=" + next + + '}'; } }