public ListNode mergeKLists(ArrayList<ListNode> lists) { if (lists.size() == 0) return null; PriorityQueue<ListNode> q = new PriorityQueue<ListNode>( lists.size(), new Comparator<ListNode>() { public int compare(ListNode a, ListNode b) { if (a.val > b.val) return 1; else if (a.val == b.val) return 0; else return -1; } }); for (ListNode i : lists) if (i != null) q.add(i); ListNode head = new ListNode(-1); ListNode pre = head; while (q.size() != 0) { ListNode temp = q.poll(); pre.next = temp; if (temp.next != null) q.add(temp.next); pre = pre.next; } return head.next; }
public ListNode mergeKLists(ArrayList<ListNode> lists) { if (lists == null || lists.isEmpty()) return null; ListNode head = new ListNode(0); ListNode p = head; PriorityQueue<ListNode> queue = new PriorityQueue<ListNode>( lists.size(), new Comparator<ListNode>() { @Override public int compare(ListNode o1, ListNode o2) { return o1.val - o2.val; } }); for (ListNode n : lists) { if (n != null) { queue.offer(n); } } while (!queue.isEmpty()) { ListNode n = queue.poll(); p.next = n; p = p.next; if (n.next != null) { queue.offer(n.next); } } return head.next; }
public ListNode removeNthFromEnd(ListNode head, int n) { // Start typing your Java solution below // DO NOT write main() function if (head == null) { return null; } ListNode tail = head; int i = 0; for (; i < n && tail != null; ++i) { tail = tail.next; } if (tail == null && i < n) { return null; } ListNode nth = head; ListNode pHead = new ListNode(0); pHead.next = head; ListNode prev = pHead; while (tail != null) { prev = nth; nth = nth.next; tail = tail.next; } // remove nth from end prev.next = nth.next; return pHead.next; }
public ListNode deleteDuplicates(ListNode head) { if (head == null) { return null; } Set<Integer> valToRemove = new HashSet<Integer>(); ListNode cur = head; while (cur != null) { if (cur.next != null && cur.val == cur.next.val) { valToRemove.add(cur.val); } cur = cur.next; } ListNode fake = new ListNode(0); fake.next = head; cur = fake; while (cur.next != null) { if (valToRemove.contains(cur.next.val)) { cur.next = cur.next.next; continue; } cur = cur.next; } return fake.next; }
public void padList(ListNode head, int len) { for (int i = 0; i < len; i++) { ListNode newNode = new ListNode(0); newNode.next = head; head = newNode; } }
public static ListNode reverseKGroup(ListNode head, int k) { if (head == null || head.next == null || k < 2) { return head; } LinkedList<ListNode> l = new LinkedList<ListNode>(); int count = 0; ListNode pre = new ListNode(0); ListNode temp = pre; while (head != null) { if (count++ < k) { ListNode t = new ListNode(head.val); l.push(t); head = head.next; } if (count >= k) { count = 0; while (!l.isEmpty()) { temp.next = l.pop(); temp = temp.next; } } } while (!l.isEmpty()) { temp.next = l.pollLast(); temp = temp.next; } return pre.next; }
public static ListNode NAfterMMore(ListNode head, int m, int n) { if (head == null || head.next == null || n == 0) return head; ListNode p = head, previous = null; int count = 0; while (p != null) { count = 0; while (count < m) { count++; previous = p; p = p.next; } count = 0; while (count < n && p != null) { count++; p = p.next; } previous.next = p; previous = previous.next; // p = p == null ? null : p.next; } return head; }
public ListNode deleteDuplicates(ListNode a) { ListNode temp = a; LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>(); int i = 0; while (temp != null) { if (map.get(temp.val) == null) { map.put(temp.val, 1); } else { map.put(temp.val, map.get(temp.val) + 1); } temp = temp.next; } System.out.println(map); Iterator<Integer> it = map.keySet().iterator(); ListNode root = null; ListNode root1 = null; while (it.hasNext()) { int x = it.next(); if (map.get(x) == 1) { if (root == null) { root = new ListNode(x); root1 = root; } else { ListNode node = new ListNode(x); root1.next = node; root1 = node; } } } return root; }
public ListNode mergeList(ListNode head1, ListNode head2) { if (head1 == null) return head2; if (head2 == null) return head1; ListNode dummy = new ListNode(-1); ListNode p = dummy; ListNode p1 = head1; ListNode p2 = head2; while (p1 != null && p2 != null) { p.next = p1; p1 = p1.next; p = p.next; p.next = p2; p2 = p2.next; p = p.next; } if (p1 == null) { p.next = p2; } if (p2 == null) { p.next = p1; } return dummy.next; }
/* Helpers */ private static InputArgs input() throws IOException { System.out.println("2.2 Return Kth to Last"); // read K System.out.print("Please input K: "); Scanner sc = new Scanner(System.in); int k = sc.nextInt(); // read number of nodes System.out.println(); System.out.print("Please input the number of nodes in the linked list: "); int n = sc.nextInt(); // read linked list System.out.println(); System.out.print("Please input value of nodes (seperate by space, e.g., 1 2 3): "); ListNode dummy = new ListNode(0); ListNode pre = dummy; for (int i = 0; i < n; i++) { ListNode cur = new ListNode(sc.nextInt()); pre.next = cur; pre = cur; } return new InputArgs(k, dummy.next); }
/** * @param head: The first node of linked list. * @return: a tree node */ public TreeNode sortedListToBST(ListNode head) { // write your code here if (head == null) { return null; } ListNode current = head; int count = 0; while (current != null) { // 遍历单链表 count++; current = current.next; } ListNode middle = head, prev = null; for (int i = 0; i < count / 2; i++) { prev = middle; middle = middle.next; } TreeNode root = new TreeNode(middle.val); if (middle == head) { // 说明链表长度为1,直接输出 return root; } prev.next = null; root.left = sortedListToBST(head); root.right = sortedListToBST(middle.next); return root; }
public ListNode addTwoNumbers(ListNode l1, ListNode l2) { addNode = new ListNode(l1.val + l2.val); ListNode travel = addNode; ListNode l1Travel = l1; ListNode l2Travel = l2; int a; int b; int over = 0; while ((l1Travel.next != null) || (l2Travel.next != null) || over != 0) { a = l1Travel.next == null ? 0 : l1Travel.next.val; b = l2Travel.next == null ? 0 : l2Travel.next.val; over = over + a + b; travel.next = new ListNode((over) % 10); travel = travel.next; over = (over) / 10; if (l1Travel.next != null) { l1Travel = l1Travel.next; } if (l2Travel.next != null) { l2Travel = l2Travel.next; } } travel.next = null; return addNode; }
public ListNode swapPairs(ListNode head) { if ((head == null) || (head.next == null)) return head; ListNode n = head.next; head.next = swapPairs(head.next.next); n.next = head; return n; }
public ListNode rotateRight(ListNode head, int k) { // corner case if (head == null || head.next == null) { return head; } // get length and move one pointer to the end of the list int count = 1; ListNode node = head; while (node != null && node.next != null) { count++; node = node.next; } k = k % count; int step = count - k - 1; ListNode temp = head; for (int i = 0; i < step; i++) { temp = temp.next; } // System.out.println(right.val); // System.out.println(right.next); node.next = head; // System.out.println(right.next); // ListNode right = temp.next; ListNode right = temp.next; temp.next = null; return right; }
public ListNode rotateRight(ListNode head, int k) { if (head == null || head.next == null || k == 0) return head; ListNode p = new ListNode(-1); ListNode p1 = head; ListNode p2 = head; ListNode temp = head; int len = 0; while (temp != null) { len++; temp = temp.next; } k %= len; if (k == 0) return head; for (int i = 0; i < k; i++) { p1 = p1.next; } while (p1.next != null) { p1 = p1.next; p2 = p2.next; } p = p2.next; p1.next = head; p2.next = null; return p; }
public ListNode mergeKLists(ListNode[] lists) { ListNode sentinel = new ListNode(0); ListNode current = sentinel; PriorityQueue<ListNode> heap = new PriorityQueue<>( (e1, e2) -> { if (e1.val > e2.val) { return 1; } else if (e1.val < e2.val) { return -1; } else { return 0; } }); for (ListNode node : lists) { if (node != null) { heap.add(node); } } while (heap.isEmpty() == false) { ListNode nodeWithMinValue = heap.poll(); current.next = nodeWithMinValue; nodeWithMinValue = nodeWithMinValue.next; if (nodeWithMinValue != null) { heap.add(nodeWithMinValue); } } return sentinel.next; }
public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode l1c = l1; ListNode l2c = l2; ListNode head = new ListNode(-100); ListNode r = head; while (l1c != null && l2c != null) { if (l1c.val > l2c.val) { head.next = l2c; l2c = l2c.next; head = head.next; } else { head.next = l1c; l1c = l1c.next; head = head.next; } } if (l1c == null) { head.next = l2c; } if (l2c == null) { head.next = l1c; } return r.next; }
public static ListNode[] SecondTry(ListNode l1, ListNode l2) { if (l1 == null || l2 == null) { return new ListNode[] {l1 == null ? l2 : l1, l1 == null ? l2 : l1}; } ListNode[] res = new ListNode[2]; ListNode newHead = new ListNode(), head1 = new ListNode(), head2 = new ListNode(); ListNode p = newHead, p1 = l1, p2 = l2; head1.next = p1; head2.next = p2; while (p1 != null && p2 != null) { p.next = p1; p = p.next; head1.next = p1.next; p1 = p1.next; p.next = p2; p = p.next; head2.next = p2.next; p2 = p2.next; } p.next = null; res[0] = newHead.next; res[1] = head2.next; return res; }
/** * @param ListNode head is the head of the linked list * @return: ListNode head of the linked list */ public static ListNode deleteDuplicates(ListNode head) { // write your code here if (head == null || head.next == null) { return head; } ListNode curt = new ListNode(0); ListNode ret = curt; while (head != null && head.next != null) { if (head.val != head.next.val) { curt.next = new ListNode(head.val); curt = curt.next; head = head.next; } else { while (head.next != null && head.val == head.next.val) { head = head.next; } head = head.next; } } if (head != null) { curt.next = new ListNode(head.val); } return ret.next; }
private ListNode removeNode(ListNode head, int pos) { if (pos == 0) { return head.next; } if (pos == 1) { return head.next; } else { int count = 1; ListNode previous = head; ListNode next = head.next; while (next != null && count < pos - 1) { previous = next; next = next.next; count++; } if (next == null) { previous.next = null; } else { previous.next = next.next; } return head; } }
public ListNode deleteDuplicates(ListNode head) { if (head == null) { return head; } ListNode dummy = new ListNode(0); dummy.next = head; ListNode prev = dummy; boolean dup = false; while (head != null) { if (head.next != null && head.val == head.next.val) { head = head.next; dup = true; } else if (head.next == null) { if (dup) { prev.next = null; } head = head.next; } else if (head.val != head.next.val) { if (dup) { head = head.next; prev.next = head; dup = false; } else { prev = head; head = head.next; } } } return dummy.next; }
public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode dummy = new ListNode(0); ListNode cur = dummy; while (l1 != null || l2 != null) { if (l1 != null && l2 != null) { if (l1.val <= l2.val) { cur.next = l1; l1 = l1.next; } else { cur.next = l2; l2 = l2.next; } cur = cur.next; } else if (l1 == null && l2 != null) { cur.next = l2; l2 = l2.next; cur = cur.next; } else if (l1 != null && l2 == null) { cur.next = l1; l1 = l1.next; cur = cur.next; } } return dummy.next; }
public static ListNode reverseKNodes(ListNode head, int k) { // Start with head ListNode current = head; // last node after reverse ListNode prevTail = null; // first node before reverse ListNode prevCurrent = head; while (current != null) { // loop for reversing K nodes int count = k; ListNode tail = null; while (current != null && count > 0) { ListNode next = current.getNext(); current.setNext(tail); tail = current; current = next; count--; } // reversed K Nodes if (prevTail != null) { // Link this set and previous set prevTail.setNext(tail); } else { // We just reversed first set of K nodes, update head point to the Kth Node head = tail; } // save the last node after reverse since we need to connect to the next set. prevTail = prevCurrent; // Save the current node, which will become the last node after reverse prevCurrent = current; } return head; }
// fail to solve the problem // This is very basic and important! public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // only one statement is enough to solve 3 condition // cause linklist is connected, I don't need to insert rest of the node anymore if (l1 == null || l2 == null) return l1 == null ? l2 : l1; // the head node is specil, need seperate initiate. ListNode head = null; if (l1.val <= l2.val) { head = l1; l1 = l1.next; } else { head = l2; l2 = l2.next; } ListNode temp = head; // in while loop, temp.next = smallvalue; l1 = l1.next; temp = temp.next; while (l1 != null && l2 != null) { if (l1.val <= l2.val) { temp.next = l1; l1 = l1.next; } else { temp.next = l2; l2 = l2.next; } ; temp = temp.next; } // finally, we find the non-null node add it to the rear of l3 // cause linklist is connected, I don't need to insert rest of the node anymore temp.next = l1 == null ? l2 : l1; return head; }
public ListNode mergeKLists(ArrayList<ListNode> lists) { if (lists == null || lists.isEmpty()) return null; PriorityQueue<ListNode> heap = new PriorityQueue<ListNode>( lists.size(), new Comparator<ListNode>() { public int compare(ListNode o1, ListNode o2) { return o1.data > o2.data ? 1 : (o1.data < o2.data ? -1 : 0); } }); for (ListNode node : lists) { if (node != null) { heap.add(node); } } ListNode head = null, cur = null; while (!heap.isEmpty()) { if (head == null) { head = heap.poll(); cur = head; } else { cur.next = heap.poll(); cur = cur.next; } if (cur.next != null) { heap.add(cur.next); } } return head; }
public void reorderList(ListNode head) { if (head == null || head.next == null || head.next.next == null) { return; } ListNode oneStep = head; ListNode twoStep = head; while (twoStep != null && twoStep.next != null) { twoStep = twoStep.next.next; oneStep = oneStep.next; } ListNode half = oneStep.next; oneStep.next = null; Stack<ListNode> stack = new Stack<ListNode>(); while (half != null) { stack.push(half); half = half.next; } ListNode tmp = head; while (head != null) { ListNode oldRight = head.next; if (stack.empty()) { break; } head.next = stack.pop(); head.next.next = oldRight; head = oldRight; } head = tmp; }
public static boolean isPalindrome_good(ListNode head) { if (head == null || head.next == null) { return true; } ListNode fast = head; ListNode slow = head; while (fast.next != null && fast.next.next != null) { slow = slow.next; fast = fast.next.next; } ListNode newhead = slow.next; ListNode pre = null; while (newhead != null) { ListNode temp = newhead.next; newhead.next = pre; pre = newhead; newhead = temp; } while (pre != null) { if (pre.val != head.val) { return false; } pre = pre.next; head = head.next; } return true; }
/* Solution 2 Did not use additional space, each time encounter the first unique value node, traversal the rest of the list to delete the same value's nodes. Assumption: None. Time complexity: O(n^2) Space Complexity: O(1) */ private static ListNode RemoveDups2(ListNode head) { if (head == null) return head; ListNode pre = head; while (pre != null) { ListNode pre2 = pre; ListNode cur = pre.next; int target = pre.val; while (cur != null) { // delete the dups in the rest of the list if (cur.val == target) { pre2.next = cur.next; cur = cur.next; } else { pre2 = cur; cur = cur.next; } } // move to next different value's node pre = pre.next; } return head; }
/** * @param ListNode l1 is the head of the linked list * @param ListNode l2 is the head of the linked list * @return: ListNode head of linked list */ public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // write your code here if (l1 == null && l2 == null) { return null; } ListNode fakeHead = new ListNode(0); ListNode curr = fakeHead; while (l1 != null && l2 != null) { if (l1.val <= l2.val) { curr.next = l1; l1 = l1.next; } else { curr.next = l2; l2 = l2.next; } curr = curr.next; } if (l1 != null) { curr.next = l1; } if (l2 != null) { curr.next = l2; } return fakeHead.next; }
public ListNode removeNthFromEnd(ListNode head, int n) { if (head == null || head.next == null) { return null; } ListNode first = head; ListNode second = head; for (int i = 0; i < n; i++) { first = first.next; if (first == null) { return head.next; } } while (first.next != null) { first = first.next; second = second.next; } second.next = second.next.next; return head; }