diff --git a/src/main/java/com/ordestiny/tdd/interview/linkedlist/LinkedListNode.java b/src/main/java/com/ordestiny/tdd/interview/linkedlist/LinkedListNode.java
new file mode 100644
index 0000000..fb5a68b
--- /dev/null
+++ b/src/main/java/com/ordestiny/tdd/interview/linkedlist/LinkedListNode.java
@@ -0,0 +1,18 @@
+package com.ordestiny.tdd.interview.linkedlist;
+
+import lombok.Builder;
+
+@Builder
+public class LinkedListNode<E> {
+    LinkedListNode<E> next;
+    private E data;
+
+    public boolean hasNext() {
+        return next != null;
+    }
+
+    public E getData() {
+        return data;
+    }
+
+}
diff --git a/src/main/java/com/ordestiny/tdd/interview/linkedlist/LinkedListNodeUtil.java b/src/main/java/com/ordestiny/tdd/interview/linkedlist/LinkedListNodeUtil.java
new file mode 100644
index 0000000..8b41139
--- /dev/null
+++ b/src/main/java/com/ordestiny/tdd/interview/linkedlist/LinkedListNodeUtil.java
@@ -0,0 +1,64 @@
+package com.ordestiny.tdd.interview.linkedlist;
+
+public class LinkedListNodeUtil {
+
+    /**
+     * interview Question:
+     * A LinkedListNode, with N elements,
+     * each element has its value(integer)
+     *
+     * given a partition value x, all the values in LinkedListNode must be separated into two parts,
+     * values below x in left part, values above x must be in right part, then concatenate them
+     * ex,
+     * Given
+     * When LinkedListNode 3-> 5->8 ->5->10->2->1 , and partition = 5
+     * Expect 3-> 2->1 ->5->8->5->10
+     *
+     * @param node
+     * @param x
+     * @return
+     */
+    public static LinkedListNode partition(LinkedListNode node , int x) {
+        if (node == null || node.next == null)
+            return node;
+        LinkedListNode leftCurrentNode = null;
+        LinkedListNode leftNodeHead = null;
+        LinkedListNode rightCurrentNode = null;
+        LinkedListNode rightNodeHead = null;
+        LinkedListNode currentNode = null;
+        do {
+            if (currentNode == null)
+                currentNode = node;
+            else
+                currentNode = currentNode.next;
+            int nodeValue = (int) currentNode.getData();
+            LinkedListNode newNode = LinkedListNode.builder().data(nodeValue).build();
+            if ( nodeValue < x) {
+                if (leftNodeHead == null) {
+                    leftNodeHead = newNode;
+                    leftCurrentNode = leftNodeHead;
+                } else {
+                    leftCurrentNode.next = newNode;
+                    leftCurrentNode = leftCurrentNode.next;
+                }
+
+            } else {
+                if (rightNodeHead == null) {
+                    rightNodeHead = newNode;
+                    rightCurrentNode = rightNodeHead;
+                } else {
+                    rightCurrentNode.next = newNode;
+                    rightCurrentNode = rightCurrentNode.next;
+                }
+            }
+        } while(currentNode.hasNext());
+
+        if (leftNodeHead == null)
+            return rightNodeHead;
+        if (rightNodeHead == null)
+            return leftNodeHead;
+        leftCurrentNode.next = rightNodeHead;
+
+        return leftNodeHead;
+    }
+}
diff --git a/src/test/java/com/ordestiny/tdd/interview/linkedlist/LinkedListNodeUtilTest.java b/src/test/java/com/ordestiny/tdd/interview/linkedlist/LinkedListNodeUtilTest.java
new file mode 100644
index 0000000..9844411
--- /dev/null
+++ b/src/test/java/com/ordestiny/tdd/interview/linkedlist/LinkedListNodeUtilTest.java
@@ -0,0 +1,57 @@
+package com.ordestiny.tdd.interview.linkedlist;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+public class LinkedListNodeUtilTest {
+    LinkedListNodeUtil util = new LinkedListNodeUtil();
+
+    @ParameterizedTest
+    @MethodSource("partitionArguments")
+    void partition(LinkedListNode<Integer> node, int x, LinkedListNode<Integer> expectedNode) {
+        LinkedListNode<Integer> currentNode = util.partition(node, x);
+
+        do {
+            Assertions.assertEquals(expectedNode.getData(), currentNode.getData());
+            if (currentNode.hasNext()) {
+                currentNode = currentNode.next;
+                expectedNode = expectedNode.next;
+            }
+
+        } while (currentNode.hasNext());
+    }
+
+    @Test
+    void partition_withNullNode_expectNull() {
+        LinkedListNode<Integer> currentNode = util.partition(null, 5);
+
+        Assertions.assertEquals(null, currentNode);
+    }
+
+    private static Stream<Arguments> partitionArguments() {
+        return Stream.of(
+                Arguments.of(generate(3, 5, 8, 5, 10, 2, 1), 5, generate(3, 2, 1, 5, 8, 5, 10)),
+                Arguments.of(generate(3, 11, 20, 7, 9, 10), 9, generate(3, 7, 11, 20, 9, 10)),
+                Arguments.of(generate(20, 19, 23, 13, 6, 5, 0), 0, generate(20, 19, 23, 13, 6, 5, 0)),
+                Arguments.of(generate(20, 19, 23, 13, 6, 5, 0), 25, generate(20, 19, 23, 13, 6, 5, 0)),
+                Arguments.of(generate(20), 22, generate(20))
+        );
+    }
+
+    private static LinkedListNode generate(int... nodeValues) {
+        LinkedListNode node = null;
+        for (int i= nodeValues.length-1;i>=0;i--) {
+            if (node == null)
+                node = LinkedListNode.builder().data(nodeValues[i]).build();
+            else
+                node = LinkedListNode.builder().data(nodeValues[i]).next(node).build();
+        }
+        return node;
+    }
+
+}