Added Queue , Deque , DLinkedList , SLinkedList , Stack , ArrayStack and

Node Stack

Signed-off-by: Georgi Eftimov <[email protected]>

src/main/java/com/eftimoff/algorithms/Collections.java

@@ -0,0 +1,16 @@
+package com.eftimoff.algorithms;
+
+import com.eftimoff.algorithms.stack.ArrayStack;
+import com.eftimoff.algorithms.stack.Stack;
+
+public class Collections {
+ public static <T> void reverse(T[] a) {
+ Stack<T> stack = new ArrayStack<T>();
+ for (int i = 0; i < a.length; i++) {
+ stack.push(a[i]);
+ }
+ for (int i = 0; i < a.length; i++) {
+ stack.pop();
+ }
+ }
+}

src/main/java/com/eftimoff/algorithms/Main.java

@@ -0,0 +1,25 @@
+package com.eftimoff.algorithms;
+
+import com.eftimoff.algorithms.deque.Deque;
+import com.eftimoff.algorithms.deque.NodeDeque;
+import com.eftimoff.algorithms.queue.NodeQueue;
+import com.eftimoff.algorithms.queue.Queue;
+
+public class Main {
+ public static void main(String[] args) {
+ Deque<String> stack = new NodeDeque<String>();
+ System.out.println(stack.size());
+ stack.addFirst("edno");
+ System.out.println(stack.size());
+ stack.addFirst("dve");
+ stack.addFirst("tri");
+ stack.addFirst("chetiri");
+ System.out.println(stack.size());
+ System.out.println(stack.removeFirst());
+ System.out.println(stack.removeFirst());
+ System.out.println(stack.removeLast());
+ System.out.println(stack.removeLast());
+ System.out.println(stack.size());
+ }
+
+}

src/main/java/com/eftimoff/algorithms/deque/Deque.java

@@ -0,0 +1,21 @@
+package com.eftimoff.algorithms.deque;
+
+public interface Deque<T> {
+
+ int size();
+
+ boolean isEmpty();
+
+ T getFirst() throws EmptyDequeException;
+
+ T getLast() throws EmptyDequeException;
+
+ void addFirst(T element);
+
+ void addLast(T element);
+
+ T removeFirst() throws EmptyDequeException;
+
+ T removeLast() throws EmptyDequeException;
+
+}

src/main/java/com/eftimoff/algorithms/deque/EmptyDequeException.java

@@ -0,0 +1,10 @@
+package com.eftimoff.algorithms.deque;
+
+public class EmptyDequeException extends RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ public EmptyDequeException(String err) {
+ super(err);
+ }
+}

src/main/java/com/eftimoff/algorithms/deque/NodeDeque.java

@@ -0,0 +1,137 @@
+package com.eftimoff.algorithms.deque;
+
+public class NodeDeque<T> implements Deque<T> {
+
+ private DNode<T> header;
+ private DNode<T> trailer;
+ private int size;
+
+ public NodeDeque() {
+ this.header = new DNode<T>();
+ this.trailer = new DNode<T>();
+ this.header.setNext(this.trailer);
+ this.trailer.setPrev(this.header);
+ this.size = 0;
+ }
+
+ @Override
+ public int size() {
+ return this.size;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return size == 0;
+ }
+
+ @Override
+ public T getFirst() throws EmptyDequeException {
+ if (isEmpty()) {
+ throw new EmptyDequeException("Deque is empty.");
+ }
+ return this.header.getNext().getElement();
+ }
+
+ @Override
+ public T getLast() throws EmptyDequeException {
+ if (isEmpty()) {
+ throw new EmptyDequeException("Deque is empty.");
+ }
+ return this.trailer.getNext().getElement();
+ }
+
+ @Override
+ public void addFirst(T element) {
+ final DNode<T> node = new DNode<T>(element);
+ DNode<T> next = this.header.getNext();
+ node.setNext(next);
+ this.header = new DNode<T>();
+ this.header.setNext(node);
+ node.setPrev(this.header);
+ next.setPrev(node);
+ size += 1;
+ }
+
+ @Override
+ public void addLast(T element) {
+ final DNode<T> node = new DNode<T>(element);
+ DNode<T> prev = this.trailer.getPrev();
+ node.setNext(this.trailer);
+ node.setPrev(prev);
+ this.trailer = new DNode<T>();
+ this.trailer.setPrev(node);
+ prev.setNext(node);
+ size += 1;
+ }
+
+ @Override
+ public T removeFirst() throws EmptyDequeException {
+ if (size == 0) {
+ throw new AssertionError("Deque is empty.");
+ }
+ T element = this.header.getNext().getElement();
+ final DNode<T> preNext = this.header.getNext().getNext();
+ this.header.setNext(preNext);
+ preNext.setPrev(this.header);
+ size -= 1;
+ return element;
+ }
+
+ @Override
+ public T removeLast() throws EmptyDequeException {
+ if (size == 0) {
+ throw new AssertionError("Deque is empty.");
+ }
+ T element = this.trailer.getPrev().getElement();
+ final DNode<T> prePrev = this.trailer.getPrev().getPrev();
+ this.trailer.setPrev(prePrev);
+ prePrev.setNext(this.trailer);
+ size -= 1;
+ return element;
+ }
+
+ public static class DNode<T> {
+ private T element;
+ private DNode<T> next;
+ private DNode<T> prev;
+
+ public DNode() {
+ this(null, null, null);
+ }
+
+ public DNode(T element) {
+ this(element, null, null);
+ }
+
+ public DNode(T element, DNode<T> next, DNode<T> prev) {
+ this.element = element;
+ this.next = next;
+ this.prev = prev;
+ }
+
+ public T getElement() {
+ return element;
+ }
+
+ public DNode<T> getNext() {
+ return next;
+ }
+
+ public DNode<T> getPrev() {
+ return prev;
+ }
+
+ public void setElement(T element) {
+ this.element = element;
+ }
+
+ public void setNext(DNode<T> next) {
+ this.next = next;
+ }
+
+ public void setPrev(DNode<T> prev) {
+ this.prev = prev;
+ }
+ }
+
+}

src/main/java/com/eftimoff/algorithms/dlinkedlist/DLinkedList.java

@@ -0,0 +1,185 @@
+package com.eftimoff.algorithms.dlinkedlist;
+
+
+public class DLinkedList<T> {
+ private DNode<T> header;
+ private DNode<T> trailer;
+ private long size;
+
+ public DLinkedList() {
+ this.header = new DNode<T>();
+ this.trailer = new DNode<T>();
+ this.header.setNext(this.trailer);
+ this.trailer.setPrev(this.header);
+ this.size = 0;
+ }
+
+ public void addFirst(final T element) {
+ final DNode<T> node = new DNode<T>(element);
+ DNode<T> next = this.header.getNext();
+ node.setNext(next);
+ this.header = new DNode<T>();
+ this.header.setNext(node);
+ node.setPrev(this.header);
+ next.setPrev(node);
+ size += 1;
+ }
+
+ public void addAfter(final T destination, final T node) {
+ final DNode<T> desireNode = new DNode<T>(node);
+ DNode<T> loopNode = this.header;
+ while (loopNode.hasNext()) {
+ DNode<T> next = loopNode.getNext();
+ if (next.getElement().equals(destination)) {
+ DNode<T> next2 = next.getNext();
+ next2.setPrev(desireNode);
+ next.setNext(desireNode);
+ desireNode.setNext(next2);
+ desireNode.setPrev(next);
+ size += 1;
+ return;
+ } else {
+ loopNode = loopNode.getNext();
+ }
+ }
+ }
+
+ public void remove(final T node) {
+ DNode<T> loopNode = this.header;
+ while (loopNode.hasNext()) {
+ DNode<T> next = loopNode.getNext();
+ if (next.getElement().equals(node)) {
+ DNode<T> prev = next.getPrev();
+ DNode<T> next2 = next.getNext();
+ prev.setNext(next2);
+ next2.setPrev(prev);
+ size -= 1;
+ return;
+ } else {
+ loopNode = loopNode.getNext();
+ }
+ }
+ }
+
+ public void addLast(final T element) {
+ final DNode<T> node = new DNode<T>(element);
+ DNode<T> prev = this.trailer.getPrev();
+ node.setNext(this.trailer);
+ node.setPrev(prev);
+ this.trailer = new DNode<T>();
+ this.trailer.setPrev(node);
+ prev.setNext(node);
+ size += 1;
+ }
+
+ public void removeFirst() {
+ if (size == 0) {
+ throw new AssertionError("List is empty.");
+ }
+ final DNode<T> preNext = this.header.getNext().getNext();
+ this.header.setNext(preNext);
+ preNext.setPrev(this.header);
+ size -= 1;
+ }
+
+ public void removeLast() {
+ if (size == 0) {
+ throw new AssertionError("List is empty.");
+ }
+ final DNode<T> prePrev = this.trailer.getPrev().getPrev();
+ this.trailer.setPrev(prePrev);
+ prePrev.setNext(this.trailer);
+ size -= 1;
+ }
+
+ public static class DNode<T> {
+ private T element;
+ private DNode<T> next;
+ private DNode<T> prev;
+
+ public DNode() {
+ }
+
+ public DNode(T element) {
+ this.element = element;
+ }
+
+ public T getElement() {
+ return element;
+ }
+
+ public DNode<T> getNext() {
+ return next;
+ }
+
+ public DNode<T> getPrev() {
+ return prev;
+ }
+
+ public void setElement(T element) {
+ this.element = element;
+ }
+
+ public void setNext(DNode<T> next) {
+ this.next = next;
+ }
+
+ public void setPrev(DNode<T> prev) {
+ this.prev = prev;
+ }
+
+ public boolean hasNext() {
+ boolean result = false;
+ if (getNext() != null) {
+ result = true;
+ }
+ return result;
+ }
+
+ public boolean hasPrev() {
+ boolean result = false;
+ if (getPrev() != null) {
+ result = true;
+ }
+ return result;
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result
+ + ((element == null) ? 0 : element.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ @SuppressWarnings("unchecked")
+ DNode<T> other = (DNode<T>) obj;
+ if (element == null) {
+ if (other.element != null)
+ return false;
+ } else if (!element.equals(other.element))
+ return false;
+ return true;
+ }
+ }
+
+ public long getSize() {
+ return this.size;
+ }
+
+ @Override
+ public String toString() {
+ return "DLinkedList [header=" + header.getNext().getElement()
+ + ", trailer=" + trailer.getPrev().getElement() + ", size="
+ + size + "]";
+ }
+}