leetcode

Author: ayoubzulfiqar

PartitionList/partition_list.dart

@@ -0,0 +1,123 @@
+/*
+
+-* 86. Partition List *-
+
+
+Given the head of a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.
+
+You should preserve the original relative order of the nodes in each of the two partitions.
+
+ 
+
+Example 1:
+
+
+Input: head = [1,4,3,2,5,2], x = 3
+Output: [1,2,2,4,3,5]
+Example 2:
+
+Input: head = [2,1], x = 2
+Output: [1,2]
+ 
+
+Constraints:
+
+The number of nodes in the list is in the range [0, 200].
+-100 <= Node.val <= 100
+-200 <= x <= 200
+
+
+
+*/
+
+// Definition for singly-linked list.
+class ListNode {
+  int val;
+  ListNode? next;
+  ListNode([this.val = 0, this.next]);
+}
+
+class Solution {
+  ListNode? partition(ListNode? head, int x) {
+    ListNode left = ListNode(0);
+    ListNode right = ListNode(0);
+    ListNode temp1 = left;
+    ListNode temp2 = right;
+
+    while (head != null) {
+      if (head.val < x) {
+        left.next = head;
+        left = left.next!;
+      } else {
+        right.next = head;
+        right = right.next!;
+      }
+      head = head.next;
+    }
+
+    left.next = temp2.next;
+    right.next = null;
+
+    return temp1.next;
+  }
+}
+
+class MERGESort {
+  ListNode? merge(ListNode? firstList, ListNode? secondList, int x) {
+    if (firstList == null) {
+      return secondList;
+    }
+    if (secondList == null) {
+      return firstList;
+    }
+
+    ListNode newHead = ListNode(-9);
+    ListNode temp = newHead;
+
+    while (firstList != null && secondList != null) {
+      if (firstList.val < x) {
+        temp.next = firstList;
+        firstList = firstList.next;
+      } else if (secondList.val < x) {
+        temp.next = secondList;
+        secondList = secondList.next;
+      } else {
+        break;
+      }
+      temp = temp.next!;
+    }
+
+    if (firstList != null) {
+      temp.next = firstList;
+      while (temp.next != null) {
+        temp = temp.next!;
+      }
+    }
+
+    if (secondList != null) {
+      temp.next = secondList;
+    }
+
+    return newHead.next;
+  }
+
+  ListNode? partition(ListNode? head, int x) {
+    if (head == null || head.next == null) {
+      return head;
+    }
+
+    ListNode? temp = head;
+    ListNode? slow = head.next;
+    ListNode? fast = slow?.next;
+
+    while (fast != null && fast.next != null) {
+      temp = slow;
+      slow = slow?.next;
+      fast = fast.next?.next;
+    }
+
+    temp?.next = null;
+
+    return merge(partition(head, x), partition(slow, x), x);
+  }
+}

PartitionList/partition_list.go

@@ -0,0 +1,64 @@
+package main
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func merge(firstList *ListNode, secondList *ListNode, x int) *ListNode {
+	if firstList == nil {
+		return secondList
+	}
+	if secondList == nil {
+		return firstList
+	}
+
+	newHead := &ListNode{Val: -9}
+	temp := newHead
+
+	for firstList != nil && secondList != nil {
+		if firstList.Val < x {
+			temp.Next = firstList
+			firstList = firstList.Next
+		} else if secondList.Val < x {
+			temp.Next = secondList
+			secondList = secondList.Next
+		} else {
+			break
+		}
+		temp = temp.Next
+	}
+
+	if firstList != nil {
+		temp.Next = firstList
+		for temp.Next != nil {
+			temp = temp.Next
+		}
+	}
+
+	if secondList != nil {
+		temp.Next = secondList
+	}
+
+	return newHead.Next
+}
+
+func partition(head *ListNode, x int) *ListNode {
+	if head == nil || head.Next == nil {
+		return head
+	}
+
+	temp := head
+	slow := head.Next
+	fast := slow.Next
+
+	for fast != nil && fast.Next != nil {
+		temp = slow
+		slow = slow.Next
+		fast = fast.Next.Next
+	}
+
+	temp.Next = nil
+
+	return merge(partition(head, x), partition(slow, x), x)
+}

PartitionList/partition_list.md

@@ -0,0 +1,5 @@
+# DOC
+
+[GO](https://leetcode.com/problems/partition-list/solutions/3911577/go-merge-sort-simple-fast-and-easy-with-explanation/)
+
+[DART](https://leetcode.com/problems/partition-list/solutions/3911626/binary-tree-merge-sort-simple-fast-and-easy-with-explanation/)