Solutions - Please Review !

MyHashSet.java

@@ -0,0 +1,22 @@
+class MyHashSet {
+
+  boolean[] map;
+  /** Initialize your data structure here. */
+  public MyHashSet() {
+      map = new boolean[1000001];
+      Arrays.fill(map, false);
+  }
+
+  public void add(int key) {
+      map[key] = true;
+  }
+
+  public void remove(int key) {
+      map[key] = false;
+  }
+
+  /** Returns true if this set contains the specified element */
+  public boolean contains(int key) {
+      return map[key];
+  }
+}

MyQueue.java

@@ -0,0 +1,53 @@
+class MyQueue {
+
+  Stack<Integer> mStack;
+  Stack<Integer> aStack;
+
+  /** Initialize your data structure here. */
+  public MyQueue() {
+      this.mStack = new Stack<>();
+      this.aStack = new Stack<>();
+  }
+
+  /** Push element x to the back of queue. */
+  public void push(int x) {
+      if(mStack.isEmpty()) {
+          mStack.push(x);
+      } else {
+          while(!mStack.isEmpty()) {
+              aStack.push(mStack.pop());
+          }
+
+          mStack.push(x);
+
+          while(!aStack.isEmpty()) {
+              mStack.push(aStack.pop());
+          }
+      }
+  }
+
+  /** Removes the element from in front of queue and returns that element. */
+  public int pop() {
+      return mStack.pop();
+  }
+
+  /** Get the front element. */
+  public int peek() {
+      return mStack.peek();
+  }
+
+  /** Returns whether the queue is empty. */
+  public boolean empty() {
+      return mStack.isEmpty();   
+  }
+}
+
+
+// Three Line Algo Explanation
+/* -> In this approach we are using two stacks, whenever a new element is pushed on the stack we populate the auxillary stack by popping elements from main stack
+and then when new element is pushed on to the main stack, we move elements from aux stack to main stack, thus getting a Queue like structure. Rest all operations 
+are mirrioring regular stack operation */
+
+// Time and Space Complexity Analysis
+// Time Complexity: Push -> O(n), rest all others operations: O(1)
+// Space Complexity: Push -> O(n), rest of the operations: O(1)

MyQueue_Alt_Sol.java

@@ -0,0 +1,55 @@
+class MyQueue {
+
+  private int front;
+  Stack<Integer> mStack;
+  Stack<Integer> aStack;
+
+
+
+  /** Initialize your data structure here. */
+  public MyQueue() {
+      mStack = new Stack<>();
+      aStack = new Stack<>();
+  }
+
+  /** Push element x to the back of queue. */
+  public void push(int x) {
+      if (mStack.isEmpty()) {
+          front = x;
+      }
+      mStack.push(x);
+  }
+
+  /** Removes the element from in front of queue and returns that element. */
+  public int pop() {
+      if (!aStack.isEmpty()){
+          return aStack.pop();
+      } else {
+          while(!mStack.isEmpty()) {
+              aStack.push(mStack.pop());
+          }
+      }
+
+      return aStack.pop();
+  }
+
+  /** Get the front element. */
+  public int peek() {
+      if(!aStack.isEmpty()) {
+          return aStack.peek();
+      } 
+      return front;
+  }
+
+  /** Returns whether the queue is empty. */
+  public boolean empty() {
+      return mStack.isEmpty() && aStack.isEmpty();
+  }
+}
+
+/* This is Also a Two Stack Approach but here, we use "Front" to store the first element of queue, when we need to pop and element from Queue, we use the second stack 
+to reverse the first stack and pop fron there untill it is empty. All push operations are perfromed on first stack. */
+
+// Time and Space Complexity Analysis
+// Time Complexity: All Operations -> O(1), Pop -> O(n) [Worst Case]
+// Space Complexity: Push -> O(n) [For Queue Elements], Other operations -> O(1)