Skip to content

Commit

Permalink
Day 4 - Stack and Queue
Browse files Browse the repository at this point in the history
  • Loading branch information
@xckomorebi
xckomorebi committed Aug 20, 2022
1 parent f0f5f85 commit 568b1eb
Showing 1 changed file with 306 additions and 0 deletions.
306 changes: 306 additions & 0 deletions StackAndQueue.java
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,306 @@
import java.util.ArrayDeque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Deque;

public class StackAndQueue {
public static void main(String[] args) {
DequeByThreeStacks d = new StackAndQueue().new DequeByThreeStacks();
d.offerLast(227);
d.offerFirst(32);
d.pollFirst();
d.peekFirst();
}

/**
* Sort With 2 Stacks
* <p>
* Given an array that is initially stored in one stack, sort it with one
* additional stacks (total 2 stacks). After sorting the original stack should
* contain the sorted integers and from top to bottom the integers are sorted in
* ascending order.
*/
public void sort(LinkedList<Integer> s1) {
if (s1.isEmpty()) {
return;
}
LinkedList<Integer> s2 = new LinkedList<>();
int prevMin = Integer.MIN_VALUE;
int count = 0;

while (s1.peekLast() > prevMin) {
int min = Integer.MAX_VALUE;
while (!s1.isEmpty() && s1.peekLast() > prevMin) {
int val = s1.pollLast();
if (val < min) {
min = val;
count = 1;
} else if (val == min) {
count++;
}
s2.offerLast(val);
}
while (count-- >= 0) {
s1.offerLast(min);
}
while (!s2.isEmpty()) {
int val = s2.pollLast();
if (val != min) {
s1.offerLast(val);
}
}
prevMin = min;
}
}

/**
* Queue By Two Stacks Java: Implement a queue by using two stacks
* <p>
* The queue should provide size(), isEmpty(), offer(), poll() and peek()
* operations. When the queue is empty, poll() and peek() should return null.
*/
public class QueueByTwoStacks {
private LinkedList<Integer> in;
private LinkedList<Integer> out;

public QueueByTwoStacks() {
in = new LinkedList<Integer>();
out = new LinkedList<Integer>();
}

public Integer poll() {
if (isEmpty()) {
return null;
}
shuffle();
return out.pollLast();
}

public void offer(int element) {
in.offerLast(element);
}

public Integer peek() {
shuffle();
return out.peekLast();
}

public int size() {
return in.size() + out.size();
}

public boolean isEmpty() {
return in.isEmpty() && out.isEmpty();
}

private void shuffle() {
if (out.isEmpty()) {
while (!in.isEmpty()) {
out.offerLast(in.pollLast());
}
}
}
}

/**
* Stack With min()
* <p>
* Enhance the stack implementation to support min() operation. min() should
* return the current minimum value in the stack. If the stack is empty, min()
* should return -1.
*/
public class StackWithMin {
private LinkedList<Integer> stack;
private LinkedList<Integer> minStack;

public StackWithMin() {
stack = new LinkedList<>();
minStack = new LinkedList<>();
}

public int pop() {
if (stack.isEmpty()) {
return -1;
}
minStack.pollLast();
return stack.pollLast();
}

public void push(int element) {
stack.offerLast(element);
if (minStack.isEmpty()) {
minStack.offerLast(element);
return;
}
int curMin = minStack.peekLast();
minStack.offerLast(Math.min(curMin, element));
}

public int top() {
if (stack.isEmpty()) {
return -1;
}
return stack.peekLast();
}

public int min() {
if (stack.isEmpty()) {
return -1;
}
return minStack.peekLast();
}
}

/**
* Stack by Queue(s)
* <p>
* Implement a stack containing integers using queue(s). The stack should
* provide push(x), pop(), top() and isEmpty() operations.
*/
public class StackByQueue {
private Queue<Integer> queue;

public StackByQueue() {
queue = new ArrayDeque<>();
}

public void push(int x) {
queue.offer(x);
}

public Integer pop() {
if (queue.isEmpty()) {
return null;
}

int size = queue.size();
while (--size > 0) {
queue.offer(queue.poll());
}
return queue.poll();
}

public Integer top() {
if (queue.isEmpty()) {
return null;
}

int val = pop();
push(val);
return val;
}

public boolean isEmpty() {
return queue.isEmpty();
}
}

/**
* Deque By Three Stacks
* <p>
* Java: Implement a deque by using three stacks. The queue should provide
* size(), isEmpty(), offerFirst(), offerLast(), pollFirst(), pollLast(),
* peekFirst() and peekLast() operations. When the queue is empty, pollFirst(),
* pollLast(), peekFirst() and peek() should return null.
*/
public class DequeByThreeStacks {
private Deque<Integer> stack1;
private Deque<Integer> stack2;
private Deque<Integer> stack3;

private void shuffle() {
if (!stack1.isEmpty() && !stack2.isEmpty()) {
return;
}
if (size() == 0) {
return;
}

if (stack1.isEmpty()) {
int size = size() / 2;
while (size-- > 0) {
stack3.offerLast(stack2.pollLast());
}
while (!stack2.isEmpty()) {
stack1.offerLast(stack2.pollLast());
}
while (!stack3.isEmpty()) {
stack2.offerLast(stack3.pollLast());
}
return;
}
if (stack2.isEmpty()) {
int size = size() / 2;
while (size-- > 0) {
stack3.offerLast(stack1.pollLast());
}
while (!stack1.isEmpty()) {
stack2.offerLast(stack1.pollLast());
}
while (!stack3.isEmpty()) {
stack1.offerLast(stack3.pollLast());
}
}
}

public DequeByThreeStacks() {
stack1 = new ArrayDeque<>();
stack2 = new ArrayDeque<>();
stack3 = new ArrayDeque<>();
}

public void offerFirst(int element) {
stack1.offerLast(element);
}

public void offerLast(int element) {
stack2.offerLast(element);
}

public Integer pollFirst() {
if (isEmpty()) {
return null;
}
if (stack1.isEmpty()) {
shuffle();
}
return stack1.pollLast();
}

public Integer pollLast() {
if (isEmpty()) {
return null;
}
if (stack2.isEmpty()) {
shuffle();
}
return stack2.pollLast();
}

public Integer peekFirst() {
Integer result = pollFirst();
if (result == null) {
return null;
}
offerFirst(result);
return result;
}

public Integer peekLast() {
Integer result = pollLast();
if (result == null) {
return null;
}
offerLast(result);
return result;
}

public int size() {
return stack1.size() + stack2.size();
}

public boolean isEmpty() {
return size() == 0;
}
}
}

0 comments on commit 568b1eb

Please sign in to comment.