Add 3 problems

Author: ex01tus

README.md

@@ -2,14 +2,14 @@
 
 ![DSA Learning](https://img.shields.io/badge/DSA-Learning-blue?style=for-the-badge&logo=leetcode)
 
-This repository contains solutions for 590 DSA problems from the [LeetCode](https://leetcode.com/)
+This repository contains solutions for 593 DSA problems from the [LeetCode](https://leetcode.com/)
 website.
 
 Problems are separated into 20 topics:
 
 |    | Topic               | Package                                        | Problems |
 |---:|:--------------------|:-----------------------------------------------|---------:|
-|  1 | Array               | [array](src/array)                             |       83 |
+|  1 | Array               | [array](src/array)                             |       84 |
 |  2 | Binary              | [binary](src/binary)                           |       13 |
 |  3 | Binary Search       | [binary_search](src/binary_search)             |       19 |
 |  4 | Binary Search Tree  | [binary_search_tree](src/binary_search_tree)   |       16 |
@@ -20,13 +20,13 @@ Problems are separated into 20 topics:
 |  9 | Greedy Algorithms   | [greedy](src/greedy)                           |       21 |
 | 10 | Heap                | [heap](src/heap)                               |       22 |
 | 11 | Interval            | [interval](src/interval)                       |       12 |
-| 12 | Linked List         | [linked_list](src/linked_list)                 |       34 |
+| 12 | Linked List         | [linked_list](src/linked_list)                 |       35 |
 | 13 | Math                | [math](src/math)                               |       23 |
 | 14 | Matrix              | [matrix](src/matrix)                           |       20 |
 | 15 | Quad Tree           | [quad_tree](src/quad_tree)                     |        1 |
 | 16 | Recursion           | [recursion](src/recursion)                     |       24 |
 | 17 | SQL                 | [sql](src/sql)                                 |       28 |
-| 18 | Stack               | [stack](src/stack)                             |       25 |
+| 18 | Stack               | [stack](src/stack)                             |       26 |
 | 19 | String              | [string](src/string)                           |       62 |
 | 20 | Trie                | [trie](src/trie)                               |        4 |
 

src/array/RearrangeArrayElementsBySign.java

@@ -0,0 +1,28 @@
+package array;
+
+/**
+ * Description: https://leetcode.com/problems/rearrange-array-elements-by-sign
+ * Difficulty: Medium
+ * Time complexity: O(n(
+ * Space complexity: O(n)
+ */
+public class RearrangeArrayElementsBySign {
+
+    public int[] rearrangeArray(int[] nums) {
+        int[] rearranged = new int[nums.length];
+        int positivePointer = 0;
+        int negativePointer = 1;
+
+        for (int num : nums) {
+            if (num > 0) {
+                rearranged[positivePointer] = num;
+                positivePointer += 2;
+            } else {
+                rearranged[negativePointer] = num;
+                negativePointer += 2;
+            }
+        }
+
+        return rearranged;
+    }
+}

src/linked_list/FindGreatestCommonDivisorsInLinkedList.java

@@ -0,0 +1,39 @@
+package linked_list;
+
+/**
+ * Description: https://www.baeldung.com/java-greatest-common-divisor
+ * Difficulty: Medium
+ * Time complexity: O(n * log v)
+ * Space complexity: O(1)
+ */
+public class FindGreatestCommonDivisorsInLinkedList {
+
+    public ListNode insertGreatestCommonDivisors(ListNode head) {
+        ListNode current = head;
+        while (current != null && current.next != null) {
+            int gcd = findGCDViaEuclidAlgo(current.val, current.next.val);
+
+            ListNode next = current.next;
+            current.next = new ListNode(gcd, next);
+
+            current = next;
+        }
+
+        return head;
+    }
+
+    private int findGCDViaEuclidAlgo(int a, int b) {
+        if (b == 0) return a;
+        return findGCDViaEuclidAlgo(b, a % b);
+    }
+
+    private static class ListNode {
+        int val;
+        ListNode next;
+
+        public ListNode(int val, ListNode next) {
+            this.val = val;
+            this.next = next;
+        }
+    }
+}

src/stack/ImplementStackUsingQueues.java

@@ -0,0 +1,52 @@
+package stack;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/implement-stack-using-queues
+ * Difficulty: Easy
+ * Time complexity: O(1) for push() and peek(), O(n) for pop()
+ * Space complexity: O(n)
+ */
+public class ImplementStackUsingQueues {
+
+    private static class MyStack {
+
+        private Queue<Integer> main;
+        private Queue<Integer> tmp;
+        private int top;
+
+        public MyStack() {
+            this.main = new LinkedList<>();
+            this.tmp = new LinkedList<>();
+            this.top = -1;
+        }
+
+        public void push(int x) {
+            top = x;
+            main.offer(x);
+        }
+
+        public int pop() {
+            while (main.size() > 1) {
+                top = main.poll();
+                tmp.offer(top);
+            }
+
+            Queue<Integer> swap = main;
+            main = tmp;
+            tmp = swap;
+
+            return tmp.poll();
+        }
+
+        public int top() {
+            return top;
+        }
+
+        public boolean empty() {
+            return main.isEmpty();
+        }
+    }
+}