refactor: groups all data structures

data_structures/hashing/hash_map.ts

@@ -1,4 +1,4 @@
-import { Map } from "../map";
+import { Map } from "../map/map";
 
 /**
  * Represents a hash map.

data_structures/hashing/hash_map_set.ts

@@ -1,4 +1,4 @@
-import { Map } from "../map";
+import { Map } from "../map/map";
 import { MapSet } from "../map_set";
 import { HashMap } from "./hash_map";
 

data_structures/list/test/doubly_linked_list.test.ts

@@ -0,0 +1,24 @@
+import { DoublyLinkedList } from "../doubly_linked_list";
+import { testLinkedList } from "./linked_list";
+
+describe("DoublyLinkedList", () => {
+    testLinkedList(DoublyLinkedList);
+
+    it("should reverse the list", () => {
+        const list: DoublyLinkedList<number> = new DoublyLinkedList<number>();
+
+        list.append(1);
+        list.append(2);
+        list.append(3);
+        list.reverse();
+
+        expect(list.get(0)).toBe(3);
+        expect(list.get(1)).toBe(2);
+    });
+
+    it("should return null for reverse when list is empty", () => {
+        const list: DoublyLinkedList<number> = new DoublyLinkedList<number>();
+
+        expect(list.reverse()).toBeNull();
+    });
+});

data_structures/map.ts → data_structures/map/map.ts

@@ -1,4 +1,4 @@
-import { HashMapEntry } from "./hashing/hash_map";
+import { HashMapEntry } from "../hashing/hash_map";
 
 /**
  * This interface is a representation of the Map data structure.

data_structures/stack_queue.ts → data_structures/queue/stack_queue.ts

@@ -1,17 +1,16 @@
 /**
- * A Stack Based Queue Implementation. 
- * The Queue data structure which follows the FIFO (First in First Out) rule. 
- * The dequeue operation in a normal stack based queue would be o(n), as the entire has to be shifted 
- * With the help of two stacks, the time complexity of this can be brought down to amortized-O(1). 
- * Here, one stack acts as an Enqueue stack where elements are added. 
+ * A Stack Based Queue Implementation.
+ * The Queue data structure which follows the FIFO (First in First Out) rule.
+ * The dequeue operation in a normal stack based queue would be o(n), as the entire has to be shifted
+ * With the help of two stacks, the time complexity of this can be brought down to amortized-O(1).
+ * Here, one stack acts as an Enqueue stack where elements are added.
  * The other stack acts as a dequeue stack which helps in dequeuing the elements
  */
 
-import { Queue } from './queue';
-import { Stack } from './stack';
-
-export class StackQueue<T> implements Queue<T>{
+import { Stack } from "../stack/stack";
+import { Queue } from "./queue";
 
+export class StackQueue<T> implements Queue<T> {
     private enqueueStack: Stack<T> = new Stack<T>();
     private dequeueStack: Stack<T> = new Stack<T>();
 
@@ -44,7 +43,7 @@ export class StackQueue<T> implements Queue<T>{
 
     /**
      * Shifts the elements from the enqueueStack to the dequeueStack
-     * In the worst case, all the elements from the enqueue stack needs to shifted, which needs O(n) time. 
+     * In the worst case, all the elements from the enqueue stack needs to shifted, which needs O(n) time.
      * However, after the shift, elements can de dequeued at O(1).
      * This helps in dequeuing the elements in amortized O(1) time.
      */

data_structures/test/queue.ts → data_structures/queue/test/queue.ts

@@ -1,4 +1,5 @@
 import { Queue } from '../queue';
+
 type QueueConstructor = new <T>() => Queue<T>
 export function testQueue(Queue: QueueConstructor) {
 	it("enqueue should add a new element to the queue", () => {

data_structures/linked_list_stack.ts → data_structures/stack/linked_list_stack.ts

@@ -1,4 +1,4 @@
-import { SinglyLinkedList } from "./singly_linked_list";
+import { SinglyLinkedList } from "../list/singly_linked_list";
 
 /**
  * This is an implementation of a stack, based on a linked list.