@@ -1,14 +1,35 @@
+import java.util.NoSuchElementException;
+import java.util.Iterator;
+
 /**
  * Очередь: FIFO = First Input First Output
  */
-public class Queue<T> {
+public class Queue<T>  implements Iterable<T>{
+    /**
+     * head - начало списка
+     * tail - конец списка
+     */
+    Element<T> head=null, tail=null;
+
+    public Iterator<T> iterator() {
+        return new MyIterator();
+    }
+
     /**
      * Добавить в конец очереди
      *
      * @param v значение
      */
-    public void put(T v) {
+    public void put(T value) {
         // TODO: реализовать
+        Element<T> newElement = new Element<T>(value);
+
+        if (tail==null) {
+            head=tail=newElement;
+            return;
+        }
+        tail.next=newElement;
+        tail=newElement;
     }
 
     /**
@@ -18,14 +39,44 @@ public void put(T v) {
      */
     public T get() {
         // TODO: реализовать
-        return null;
+
+        if (head!=null) {
+            Element<T> newElement = head;
+            head=head.next;
+            return newElement.value;}
+        throw new NoSuchElementException("Пустая очередь");
     }
 
+
     /**
      * Элемент очереди
      */
-    class Element {
+   public static class Element<T> {
         T value;
-        Element next;
+        Element next=null;
+
+        public Element(T value) {
+            this.value = value;
+        }
+    }
+
+    public class MyIterator implements Iterator<T> {
+        private Element<T> cur;
+
+        public MyIterator() {
+            this.cur=head;
+        }
+
+        public boolean hasNext() {
+            return cur!=null;
+        }
+
+        public T next() {
+            if (cur == null)
+                throw new IndexOutOfBoundsException("Список кончился");
+            T value = cur.value;
+            cur = cur.next;
+            return value;
+        }
     }
 }
@@ -1,14 +1,26 @@
+import java.util.EmptyStackException;
 /**
  * Стек: LIFO = Last Input First Output
  */
 public class Stack<T> {
+/**
+ *
+ */
+Element<T> head = null;
+
     /**
      * Добавить на вершину стека
      *
      * @param v значение
      */
-    public void push(T v) {
+    public void push(T value) {
         // TODO: реализовать
+        Element<T> cur = new Element<T>(value);
+        if (head==null) {
+            head=cur; return;}
+        cur.next=head;
+        head=cur;
+        return;
     }
 
     /**
@@ -17,15 +29,26 @@ public void push(T v) {
      * @return значение
      */
     public T pop() {
+        if (head!=null)
+        {
+            Element<T> cur;
+            cur=head;
+            head=head.next;
+            return cur.value;
+        }
         // TODO: реализовать
-        return null;
+        throw new EmptyStackException();
     }
 
     /**
      * Элемент стека
      */
-    class Element {
+    class Element<T> {
         T value;
-        Element next;
+        Element<T> next=null;
+
+        public Element(T value){
+            this.value=value;
+        }
     }
 }
@@ -14,7 +14,7 @@ public class QueueTest {
      */
     @Test
     public void testStringQueue() {
-        Queue<String> queue = new Queue<>();
+        Queue<String> queue = new Queue<String>();
         queue.put("Hello");
         queue.put("world");
         assertEquals("Hello", queue.get());
@@ -28,7 +28,7 @@ public void testStringQueue() {
     public void testEmptyQueue() {
         class MyClass {
         }
-        Queue<MyClass> queue = new Queue<>();
+        Queue<MyClass> queue = new Queue<MyClass>();
         queue.get();
     }
 }
@@ -14,7 +14,7 @@ public class StackTest {
      */
     @Test
     public void testIntStack() {
-        Stack<Integer> stack = new Stack<>();
+        Stack<Integer> stack = new Stack<Integer>();
         stack.push(1);
         stack.push(2);
         stack.push(3);
@@ -28,7 +28,7 @@ public void testIntStack() {
      */
     @Test
     public void testStringStack() {
-        Stack<String> stack = new Stack<>();
+        Stack<String> stack = new Stack<String>();
         stack.push("Hello");
         stack.push("world");
         assertEquals("world", stack.pop());
@@ -42,7 +42,7 @@ public void testStringStack() {
     public void testEmptyStack() {
         class MyClass {
         }
-        Stack<MyClass> stack = new Stack<>();
+        Stack<MyClass> stack = new Stack<MyClass>();
         stack.pop();
     }
 }
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public class QueueTest {`
`14`	`14`	`*/`
`15`	`15`	`@Test`
`16`	`16`	`public void testStringQueue() {`
`17`		`- Queue<String> queue = new Queue<>();`
	`17`	`+ Queue<String> queue = new Queue<String>();`
`18`	`18`	`queue.put("Hello");`
`19`	`19`	`queue.put("world");`
`20`	`20`	`assertEquals("Hello", queue.get());`
`@@ -28,7 +28,7 @@ public void testStringQueue() {`
`28`	`28`	`public void testEmptyQueue() {`
`29`	`29`	`class MyClass {`
`30`	`30`	`}`
`31`		`- Queue<MyClass> queue = new Queue<>();`
	`31`	`+ Queue<MyClass> queue = new Queue<MyClass>();`
`32`	`32`	`queue.get();`
`33`	`33`	`}`
`34`	`34`	`}`