Alexparub list2

OWNER.md

@@ -0,0 +1 @@
+Парубченко Александр Сергеевич

src/main/java/track/lessons/lesson1/HelloWorld.java

@@ -7,8 +7,12 @@ public class HelloWorld {
 
     public static void main(String[] args) {
         System.out.println("Hello");
-        for (int i = 0; i < args.length; i++) {
+        System.out.println("Test");
+        /*for (int i = 0; i < args.length; i++) {
             System.out.println("arg[" + i + "]=" + args[i]);
+        }*/
+        for (int i = 0; i < args.length; i++){
+            System.out.println(args[i]);
         }
     }
 }

src/main/java/track/lessons/lesson3/DynamicList.java

@@ -3,5 +3,65 @@
 /**
  *
  */
-public class DynamicList {
+public class DynamicList extends List{
+
+    private int[] array;
+    public DynamicList(int length)
+    {
+        this.array = new int[length];
+        this.size = 0;
+    }
+
+    @Override
+    void add(int item)
+    {
+        if(size == array.length)
+        {
+            realloc();
+        }
+        array[size++] = item;
+    }
+
+    @Override
+    int remove(int idx) {
+        isValid(idx);
+
+        int item = array[idx];
+        System.arraycopy(array, idx + 1, array, idx, size-- - idx);
+        return item;
+
+    }
+
+    @Override
+    int get(int idx) {
+        isValid(idx);
+        return array[idx];
+    }
+
+    @Override
+    int size() {
+        return super.size();
+    }
+
+    @Override
+    void print() {
+        if(this.size == 0){
+            System.out.print("List is empty\n");
+        }
+        for(int i = 0; i < this.size; i++){
+            System.out.println(this.array[i]);
+        }
+    }
+
+    @Override
+    boolean isValid(int idx) {
+        return super.isValid(idx);
+    }
+
+    private void realloc()
+    {
+        int[] array2 = new int[2 * size];
+        System.arraycopy(array, 0, array2, 0, size);
+        this.array = array2;
+    }
 }

src/main/java/track/lessons/lesson3/LinkedList.java

@@ -3,5 +3,165 @@
 /**
  *
  */
-public class LinkedList {
+
+
+public class LinkedList extends List implements Queue, Stack {
+
+    @Override
+    public void push(int item) {
+        this.add(item);
+    }
+
+    @Override
+    public int pop() {
+        return this.remove(this.size - 1);
+    }
+
+    @Override
+    public void enqueue(int item) {
+        this.add(item);
+    }
+
+    @Override
+    public int dequeue() {
+        return this.remove(0);
+    }
+
+    private class Node {
+        private Node next;
+        private Node prev;
+        private int value;
+
+        public Node(Node next, Node prev, int value) {
+            this.next = next;
+            this.prev = prev;
+            this.value = value;
+        }
+
+        public Node() {
+        }
+    }
+
+    private Node start;
+    private Node end;
+
+    public LinkedList() {
+        this.start = null;
+        this.end = null;
+        this.size = 0;
+    }
+
+    @Override
+    void add(int item) {
+        if (isEmpty()) {
+            Node newNode = new Node(null, null, item);
+            this.start = newNode;
+            this.end = newNode;
+        } else {
+            Node newNode = new Node(null, this.end, item);
+            this.end.next = newNode;
+            this.end = newNode;
+        }
+        this.size++;
+
+    }
+
+    private boolean isEmpty() {
+        if (this.size > 0) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    @Override
+    int remove(int idx) {
+        isValid(idx);
+        if (this.size == 1) {
+            int currvalue = this.start.value;
+            this.start = null;
+            this.end = null;
+            this.size--;
+            return currvalue;
+        } else if (idx == 0) {
+            return removeStart();
+        } else if (idx == this.size - 1) {
+            return removeEnd();
+        } else {
+            Node iter = new Node();
+            iter = this.start;
+            for (int i = 0; i < idx; i++) {
+                iter = iter.next;
+            }
+            int currvalue = iter.value;
+            Node nextForDeleted = new Node();
+            nextForDeleted = iter.next;
+            iter.prev.next = nextForDeleted.next;
+            nextForDeleted.prev = iter.prev;
+            this.size--;
+            return currvalue;
+        }
+    }
+
+    private int removeEnd() {
+        int currvalue = this.end.value;
+        if (this.end.prev != null) {
+            this.end = this.end.prev;
+            this.end.next = null;
+        } else {
+            this.end = null;
+        }
+        this.size--;
+        return currvalue;
+    }
+
+    private int removeStart() {
+        int currvalue = this.start.value;
+        if (!(this.start.next == null)) {
+            this.start = this.start.next;
+            this.start.prev = null;
+        } else {
+            this.start = null;
+        }
+        this.size--;
+        return currvalue;
+    }
+
+    @Override
+    int get(int idx) {
+        isValid(idx);
+        if (idx == 0) {
+            return this.start.value;
+        } else if (idx == size - 1) {
+            return this.end.value;
+        } else {
+            Node iter = new Node();
+            iter = this.start;
+            for (int i = 0; i < idx; i++) {
+                iter = iter.next;
+            }
+            return iter.value;
+        }
+    }
+
+
+    @Override
+    int size() {
+        return super.size();
+    }
+
+    @Override
+    void print() {
+        if (this.size == 0) {
+            System.out.print("List is empty\n");
+        }
+        for (int i = 0; i < this.size; i++) {
+            System.out.println(this.get(i));
+        }
+    }
+
+    @Override
+    boolean isValid(int idx) {
+        return super.isValid(idx);
+    }
 }

src/main/java/track/lessons/lesson3/List.java

@@ -3,5 +3,27 @@
 /**
  *
  */
-public class List {
+public abstract class List {
+    int size;
+    // добавить элемент в конец списка
+    abstract void add(int item);
+    // удалить элемент по индексу idx, если idx некорректный напечатать ошибку, если ок - вернуть удаленный элемент
+    abstract int remove(int idx);
+    // получить элемент по индексу
+    abstract int get(int idx);
+    //распечать список
+    abstract void print();
+    // сколько элементов в данный момент в списке
+    int size()
+    {
+        return size;
+    }
+    boolean isValid(int idx)
+    {
+        if(idx < 0 || idx >= size)
+        {
+            throw new IndexOutOfBoundsException("Error: Index is unavailable");
+        }
+        return true;
+    }
 }

src/main/java/track/lessons/lesson3/ListMain.java

@@ -8,11 +8,55 @@ public class ListMain {
     public static void main(String[] args) {
 
 
-//        List list = new DynamicList();
-//        list.add(1);
-//        list.add(2);
-//        list.add(10);
-//        int first = list.remove(0);
+        List list = new DynamicList(5);
+        list.add(1);
+        list.add(2);
+        list.add(10);
+        list.print();
+        int first = list.remove(0);
+        int second = list.get(1);
+        System.out.println(list.size());
+        list.print();
+        list.remove(1);
+        list.remove(0);
+        list.print();
+        for(int i = 0; i < 25; i++)
+        {
+            list.add(i);
+        }
+        list.print();
 
+        List list1 = new LinkedList();
+        list1.add(5);
+        list1.add(8);
+        list1.add(13);
+        System.out.println(list1.size());
+        list1.print();
+        System.out.println(list1.get(2));
+        list1.remove(1);
+        list1.print();
+        list1.remove(1);
+        list1.print();
+        list1.remove(0);
+        list1.print();
+        System.out.println(list1.size());
+
+        LinkedList list2 = new LinkedList();
+        list2.push(5);
+        list2.push(4);
+        System.out.println(list2.pop());
+        list2.print();
+        System.out.println("\n");
+        LinkedList list3 = new LinkedList();
+        list3.enqueue(67);
+        list3.enqueue(23);
+        list3.print();
+        System.out.println(list3.dequeue());
+        System.out.println("\n");
+        list3.print();
+        /*list1.add(13);
+        System.out.println(list1.size());
+
+        System.out.println(list1.get(0));*/
     }
 }

src/main/java/track/lessons/lesson3/Queue.java

@@ -0,0 +1,9 @@
+package track.lessons.lesson3;
+
+/**
+ * Created by alexparub on 13.10.16.
+ */
+interface Queue {
+    void  enqueue(int item);
+    int dequeue();
+}

src/main/java/track/lessons/lesson3/Stack.java

@@ -0,0 +1,9 @@
+package track.lessons.lesson3;
+
+/**
+ * Created by alexparub on 13.10.16.
+ */
+interface Stack {
+    void push(int item);
+    int pop();
+}