Lesson3 hw

Java4L3HW/src/main/java/queue/DequeImplement.java

@@ -0,0 +1,71 @@
+package queue;
+
+public class DequeImplement<E extends Object > extends QueueImplement<E> {
+
+    public static final int DEFAULT_REAR = -1;
+    public static final int DEFAULT_FRONT = 0;
+
+    private int rear;
+    private int front;
+
+    protected int size;
+    protected E[] data;
+
+    public DequeImplement(int maxSize) {
+        super(maxSize);
+        this.size=0;
+        this.data=(E[]) new Object[maxSize];
+        this.front = DEFAULT_FRONT;
+        this.rear = DEFAULT_REAR;
+    }
+
+    public void insertLeft(E value) {
+        if (front==0)
+            front=data.length;
+        data[--front]=value;
+        size++;
+    }
+
+    public void insertRight(E value) {
+        if (rear==data.length-1)
+            rear=DEFAULT_REAR;
+        data[++rear]=value;
+        size++;
+    }
+
+    public E removeLeft() {
+        E value = data[front++];
+        if (front==data.length)
+            front=DEFAULT_FRONT;
+        size--;
+        return value;
+    }
+
+    public E removeRight() {
+        E value = data[rear--];
+        if (rear==DEFAULT_REAR)
+            rear=data.length-1;
+        size--;
+        return value;
+    }
+
+    public E peekLeft() {
+        return data[front];
+    }
+
+    public E peekRight() {
+        return data[rear];
+    }
+
+    public boolean isEmpty() {
+        return size==0;
+    }
+
+    public boolean isFull() {
+        return size==data.length;
+    }
+
+    public int size() {
+        return size;
+    }
+}

Java4L3HW/src/main/java/queue/MainApp.java

@@ -0,0 +1,78 @@
+package queue;
+
+import java.io.DataOutputStream;
+
+public class MainApp {
+    public static void main(String[] args) {
+//        Queue<Integer> queue = new QueuePriority<Integer>(5);
+//        insert(queue, 2);
+//        insert(queue, 1);
+//        insert(queue, 4);
+//        insert(queue, 5);
+//        insert(queue, 3);
+//        insert(queue, 222);
+//
+//        System.out.println("Size: " + queue.size());
+//        System.out.println("Peek: " + queue.peek());
+//
+//        while (!queue.isEmpty()) {
+//            System.out.println(remove(queue));
+//        }
+
+
+        DequeImplement<Integer> dec = new DequeImplement<Integer>(5);
+
+        insertLeft(dec,1);
+        insertLeft(dec,2);
+        insertLeft(dec,3);
+        insertRight(dec,4);
+        insertRight(dec,5);
+        while (!dec.isEmpty()) {
+            System.out.println(removeRight(dec));
+        }
+
+        System.out.println("");
+
+        insertLeft(dec,1);
+        insertLeft(dec,2);
+        insertLeft(dec,3);
+        insertRight(dec,4);
+        insertRight(dec,5);
+        while (!dec.isEmpty()) {
+            System.out.println(removeLeft(dec));
+        }
+    }
+
+    private static <E> E remove(Queue<E> queue) {
+        if (!queue.isEmpty())
+            return queue.remove();
+        return null;
+    }
+
+    private static <E> void insert(Queue<E> queue, E value) {
+        if (!queue.isFull())
+            queue.insert(value);
+    }
+
+    private static <E> E removeRight(DequeImplement<E> dec) {
+        if (!dec.isEmpty())
+            return dec.removeRight();
+        return null;
+    }
+
+    private static <E> void insertRight(DequeImplement<E> dec, E value) {
+        if (!dec.isFull())
+            dec.insertRight(value);
+    }
+
+    private static <E> E removeLeft(DequeImplement<E> dec) {
+        if (!dec.isEmpty())
+            return dec.removeLeft();
+        return null;
+    }
+
+    private static <E> void insertLeft(DequeImplement<E> dec, E value) {
+        if (!dec.isFull())
+            dec.insertLeft(value);
+    }
+}

Java4L3HW/src/main/java/queue/Queue.java

@@ -0,0 +1,12 @@
+package queue;
+
+public interface Queue<E> {
+
+    void insert(E value);
+    E remove();
+    E peek();
+
+    boolean isEmpty();
+    boolean isFull();
+    int size();
+}

Java4L3HW/src/main/java/queue/QueueImplement.java

@@ -0,0 +1,57 @@
+package queue;
+
+public class QueueImplement<E> implements Queue<E> {
+
+    public static final int DEFAULT_REAR = -1;
+    public static final int DEFAULT_FRONT = 0;
+
+    private int rear;
+    private int front;
+
+    protected int size;
+    protected E[] data;
+
+    public QueueImplement(int maxSize) {
+        this.size=0;
+        this.data=(E[]) new Object[maxSize];
+        this.front = DEFAULT_FRONT;
+        this.rear = DEFAULT_REAR;
+    }
+
+    @Override
+    public void insert(E value) {
+        if (rear==data.length-1)
+            rear=DEFAULT_REAR;
+        size++;
+        data[++rear]=value;
+    }
+
+    @Override
+    public E remove() {
+        E value = data[front++];
+        if (front==data.length)
+            front=DEFAULT_FRONT;
+        size--;
+        return value;
+    }
+
+    @Override
+    public E peek() {
+        return data[front];
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size==0;
+    }
+
+    @Override
+    public boolean isFull() {
+        return size==data.length;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+}

Java4L3HW/src/main/java/queue/QueuePriority.java

@@ -0,0 +1,36 @@
+package queue;
+
+public class QueuePriority<E extends Object & Comparable<? super E>> extends QueueImplement<E> {
+
+    public QueuePriority(int maxSize) {
+        super(maxSize);
+        this.data = (E[]) new Object[maxSize];
+    }
+
+    @Override
+    public void insert(E value) {
+        if (isEmpty()){
+            data[size++]=value;
+            return;
+        }
+        int index;
+        for (index=size-1;index>=0;index--){
+            if (value.compareTo(data[index])>0)
+                data[index+1]=data[index];
+            else
+                break;;
+        }
+        data[index+1]=value;
+        size++;
+    }
+
+    @Override
+    public E remove() {
+        return data[--size];
+    }
+
+    @Override
+    public E peek() {
+        return data[size-1];
+    }
+}

Java4L3HW/src/main/java/stack/MainApp.java

@@ -0,0 +1,12 @@
+package stack;
+
+public class MainApp {
+
+    public static void main(String[] args) {
+
+        String str = "public static void main(String[] args)";
+        Shifter shifter = new Shifter();
+        System.out.println(str);
+        System.out.println(shifter.shift(str));
+    }
+}

Java4L3HW/src/main/java/stack/Shifter.java

@@ -0,0 +1,15 @@
+package stack;
+
+public class Shifter {
+
+    public String shift(String inputStr){
+        Stack<Character> stack = new StackImplement<Character>(inputStr.length());
+        for (int i = 0; i < inputStr.length(); i++) {
+            stack.push(inputStr.charAt(i));
+        }
+        StringBuilder outputStr = new StringBuilder();
+        while (!stack.isEmpty())
+            outputStr.append(stack.pop());
+        return outputStr.toString();
+    }
+}

Java4L3HW/src/main/java/stack/Stack.java

@@ -0,0 +1,12 @@
+package stack;
+
+public interface Stack<E> {
+
+    void push(E value);
+    E pop();
+    E peek();
+
+    boolean isEmpty();
+    boolean isFool();
+    int size();
+}

Java4L3HW/src/main/java/stack/StackImplement.java

@@ -0,0 +1,41 @@
+package stack;
+
+public class StackImplement<E> implements Stack<E> {
+    private E[] data;
+    private int size;
+
+    public StackImplement(int maxSize) {
+        this.size=0;
+        this.data = (E[]) new Object[maxSize];
+    }
+
+    @Override
+    public void push(E value) {
+        data[size++]=value;
+    }
+
+    @Override
+    public E pop() {
+        return data[--size];
+    }
+
+    @Override
+    public E peek() {
+        return data[size-1];
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size==0;
+    }
+
+    @Override
+    public boolean isFool() {
+        return size==data.length;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+}