From 88b4bc07f4e4b2c4a439b8f9be4a59cea5df254a Mon Sep 17 00:00:00 2001 From: Fred Qin Date: Fri, 24 Feb 2017 00:57:53 -0800 Subject: [PATCH 1/2] complete coding except iterator --- group11/395443277/a1/.gitignore | 111 ++++++++++++++ .../a1/src/com/coding/basic/ArrayList.java | 64 ++++++++ .../src/com/coding/basic/ArrayListTest.java | 67 +++++++++ .../src/com/coding/basic/BinaryTreeNode.java | 75 ++++++++++ .../com/coding/basic/BinaryTreeNodeTest.java | 40 +++++ .../a1/src/com/coding/basic/Iterator.java | 7 + .../a1/src/com/coding/basic/LinkedList.java | 138 ++++++++++++++++++ .../src/com/coding/basic/LinkedListTest.java | 114 +++++++++++++++ .../a1/src/com/coding/basic/List.java | 9 ++ .../a1/src/com/coding/basic/Queue.java | 21 +++ .../a1/src/com/coding/basic/QueueTest.java | 29 ++++ .../a1/src/com/coding/basic/Stack.java | 23 +++ .../a1/src/com/coding/basic/StackTest.java | 45 ++++++ 13 files changed, 743 insertions(+) create mode 100644 group11/395443277/a1/.gitignore create mode 100644 group11/395443277/a1/src/com/coding/basic/ArrayList.java create mode 100644 group11/395443277/a1/src/com/coding/basic/ArrayListTest.java create mode 100644 group11/395443277/a1/src/com/coding/basic/BinaryTreeNode.java create mode 100644 group11/395443277/a1/src/com/coding/basic/BinaryTreeNodeTest.java create mode 100644 group11/395443277/a1/src/com/coding/basic/Iterator.java create mode 100644 group11/395443277/a1/src/com/coding/basic/LinkedList.java create mode 100644 group11/395443277/a1/src/com/coding/basic/LinkedListTest.java create mode 100644 group11/395443277/a1/src/com/coding/basic/List.java create mode 100644 group11/395443277/a1/src/com/coding/basic/Queue.java create mode 100644 group11/395443277/a1/src/com/coding/basic/QueueTest.java create mode 100644 group11/395443277/a1/src/com/coding/basic/Stack.java create mode 100644 group11/395443277/a1/src/com/coding/basic/StackTest.java diff --git a/group11/395443277/a1/.gitignore b/group11/395443277/a1/.gitignore new file mode 100644 index 0000000000..e02fdb6730 --- /dev/null +++ b/group11/395443277/a1/.gitignore @@ -0,0 +1,111 @@ + + +.metadata + +bin/ + +tmp/ + +*.tmp + +*.bak + +*.swp + +*~.nib + +local.properties + +.settings/ + +.loadpath + +.recommenders + + + +# Eclipse Core + +.project + + + +# External tool builders + +.externalToolBuilders/ + + + +# Locally stored "Eclipse launch configurations" + +*.launch + + + +# PyDev specific (Python IDE for Eclipse) + +*.pydevproject + + + +# CDT-specific (C/C++ Development Tooling) + +.cproject + + + +# JDT-specific (Eclipse Java Development Tools) + +.classpath + + + +# Java annotation processor (APT) + +.factorypath + + + +# PDT-specific (PHP Development Tools) + +.buildpath + + + +# sbteclipse plugin + +.target + + + +# Tern plugin + +.tern-project + + + +# TeXlipse plugin + +.texlipse + + + +# STS (Spring Tool Suite) + +.springBeans + + + +# Code Recommenders + +.recommenders/ + + + +# Scala IDE specific (Scala & Java development for Eclipse) + +.cache-main + +.scala_dependencies + +.worksheet \ No newline at end of file diff --git a/group11/395443277/a1/src/com/coding/basic/ArrayList.java b/group11/395443277/a1/src/com/coding/basic/ArrayList.java new file mode 100644 index 0000000000..4c6c92c42e --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/ArrayList.java @@ -0,0 +1,64 @@ +package com.coding.basic; + +import java.util.Arrays; + +public class ArrayList implements List { + + private int size = 0; + + private Object[] elementData = new Object[4]; + + public void add(Object o){ + if (size == elementData.length) { + // double size + doubleSize(); + } + + elementData[size] = o; + size++; + } + + private void doubleSize() { + elementData = Arrays.copyOf(elementData, elementData.length * 2); + } + + public void add(int index, Object o){ + // check size + if (size == elementData.length) { + doubleSize(); + } + + //shift and add element + System.arraycopy(elementData, index, elementData, index+1, size - index); + elementData[index] = o; + size++; + } + + public Object get(int index){ + return elementData[index]; + } + + public Object remove(int index){ + if (size == 0) { + return null; + } + + // remove element and shift + Object target = elementData[index]; + System.arraycopy(elementData, index+1, elementData, index, size - index - 1); + + // reset last element + elementData[size-1] = null; + size--; + return target; + } + + public int size(){ + return size; + } + + public Iterator iterator(){ + return null; + } + +} diff --git a/group11/395443277/a1/src/com/coding/basic/ArrayListTest.java b/group11/395443277/a1/src/com/coding/basic/ArrayListTest.java new file mode 100644 index 0000000000..3025b8e077 --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/ArrayListTest.java @@ -0,0 +1,67 @@ +package com.coding.basic; + +import static org.junit.Assert.*; + +import org.junit.Test; + +public class ArrayListTest { + + @Test + public void testAddObject() { + ArrayList list = new ArrayList(); + list.add(5); + assertEquals(5, list.get(0)); + + list.add(4); + list.add(3); + list.add(2); + list.add(1); + assertEquals(1, list.get(4)); + + // size equals to 5 + assertEquals(5, list.size()); + } + + @Test + public void testAddIntObject() { + ArrayList list = new ArrayList(); + list.add(5); + list.add(4); + list.add(3); + list.add(2); + list.add(1); + + // change position 2 element + list.add(2, 10); + + // pos 2 has 10 + assertEquals(10, list.get(2)); + + // last element is 1 + assertEquals(1, list.get(5)); + + // size is 6 + assertEquals(6, list.size()); + } + + @Test + public void testRemove() { + ArrayList list = new ArrayList(); + list.add(5); + list.add(4); + list.add(3); + list.add(2); + list.add(1); + + Object removed = list.remove(2); + assertEquals(removed, 3); + + assertEquals(2, list.get(2)); + assertEquals(4, list.size()); + assertEquals(null, list.get(4)); + + list.add(6); + assertEquals(6, list.get(4)); + } + +} diff --git a/group11/395443277/a1/src/com/coding/basic/BinaryTreeNode.java b/group11/395443277/a1/src/com/coding/basic/BinaryTreeNode.java new file mode 100644 index 0000000000..907fc23275 --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/BinaryTreeNode.java @@ -0,0 +1,75 @@ +package com.coding.basic; + +public class BinaryTreeNode implements Comparable{ + + private Object data; + private BinaryTreeNode left; + private BinaryTreeNode right; + + public Object getData() { + return data; + } + public void setData(Object data) { + this.data = data; + } + public BinaryTreeNode getLeft() { + return left; + } + public void setLeft(BinaryTreeNode left) { + this.left = left; + } + public BinaryTreeNode getRight() { + return right; + } + public void setRight(BinaryTreeNode right) { + this.right = right; + } + + public BinaryTreeNode insert(Object o){ + if (this.compareTo(o)==0) { + return null; + } else { + // current value less than inserted value + // go right + if (this.compareTo(o)<0) { + if (this.right == null) { + BinaryTreeNode nd = new BinaryTreeNode(); + nd.setData(o); + this.setRight(nd); + } else { + this.getRight().insert(o); + } + } + // greater than + // go left + else if(this.compareTo(o)>0) { + if (this.left == null) { + BinaryTreeNode nd = new BinaryTreeNode(); + nd.setData(o); + this.setLeft(nd); + } else { + this.getLeft().insert(o); + } + } + } + + return null; + } + + /** + * oversimplified implementation: only allows int and string + */ + @Override + public int compareTo(Object nd) throws ClassCastException{ + if (!(nd instanceof Object)) { + throw new ClassCastException("An object expected."); + } + + if (nd instanceof String) { + return ((String)this.data).compareTo((String) nd); + } else { + return ((int) this.data) -((int) nd); + } + } + +} diff --git a/group11/395443277/a1/src/com/coding/basic/BinaryTreeNodeTest.java b/group11/395443277/a1/src/com/coding/basic/BinaryTreeNodeTest.java new file mode 100644 index 0000000000..1c5c637ccd --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/BinaryTreeNodeTest.java @@ -0,0 +1,40 @@ +package com.coding.basic; + +import static org.junit.Assert.*; + +import org.junit.Test; + +public class BinaryTreeNodeTest { + + @Test + public void testInsert() { + BinaryTreeNode root = new BinaryTreeNode(); + root.setData(3); + + root.insert(2); + BinaryTreeNode left = root.getLeft(); + assertEquals(2,left.getData()); + + root.insert(5); + BinaryTreeNode right = root.getRight(); + assertEquals(5, right.getData()); + + root.insert(7); + BinaryTreeNode rr = right.getRight(); + assertEquals(7, rr.getData()); + } + + @Test + public void testCompareTo() { + BinaryTreeNode n1 = new BinaryTreeNode(); + n1.setData("abc"); + + assertEquals(true, n1.compareTo("cde")<0); + + BinaryTreeNode n3 = new BinaryTreeNode(); + n3.setData(1); + + assertEquals(true, n3.compareTo(2)<0); + } + +} diff --git a/group11/395443277/a1/src/com/coding/basic/Iterator.java b/group11/395443277/a1/src/com/coding/basic/Iterator.java new file mode 100644 index 0000000000..06ef6311b2 --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/Iterator.java @@ -0,0 +1,7 @@ +package com.coding.basic; + +public interface Iterator { + public boolean hasNext(); + public Object next(); + +} diff --git a/group11/395443277/a1/src/com/coding/basic/LinkedList.java b/group11/395443277/a1/src/com/coding/basic/LinkedList.java new file mode 100644 index 0000000000..e05f035eb2 --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/LinkedList.java @@ -0,0 +1,138 @@ +package com.coding.basic; + +public class LinkedList implements List { + + private Node head; + + public void add(Object o){ + Node newNode = new Node(); + newNode.data = o; + newNode.next = null; + + if (head == null) { + head = newNode; + } else { + Node curr = head; + while(curr.next != null) { + curr = curr.next; + } + curr.next = newNode; + } + } + public void add(int index , Object o){ + Node newNode = new Node(); + newNode.data = o; + newNode.next = null; + + if (head == null) { + head = newNode; + } else { + Node curr = head; + Node prev = curr; + while(index >0 && curr.next != null) { + prev = curr; + curr = curr.next; + index--; + } + + prev.next = newNode; + newNode.next = curr; + } + } + public Object get(int index){ + Node curr = head; + while(index > 0) { + curr = curr.next; + index--; + } + return curr.data; + } + public Object remove(int index){ + if (index ==0) { + return this.removeFirst(); + } + + Node curr = head; + Node prev = curr; + while(index >0 && curr.next != null) { + prev = curr; + curr = curr.next; + index--; + } + + Object target = curr.data; + prev.next = curr.next; + curr.next = null; + + return target; + } + public int size(){ + int size = 0; + Node curr = head; + while(curr != null) { + size++; + curr = curr.next; + } + return size; + } + public void addFirst(Object o){ + Node newNode = new Node(); + newNode.data = o; + newNode.next = null; + + if (head == null) { + head = newNode; + } else { + newNode.next = head.next; + head.next = newNode; + } + } + public void addLast(Object o){ + Node newNode = new Node(); + newNode.data = o; + newNode.next = null; + + Node curr = head; + if (head == null) { + head = newNode; + } else { + while(curr.next != null) { + curr = curr.next; + } + curr.next = newNode; + } + } + public Object removeFirst(){ + if (head == null) { + return null; + } + + Object target = head.data; + head = head.next; + return target; + } + public Object removeLast(){ + if (head == null) { + return null; + } + Node curr = head; + Node prev = curr; + while(curr.next != null) { + prev = curr; + curr = curr.next; + } + Object target = curr.data; + prev.next = null; + return target; + } + public Iterator iterator(){ + return null; + } + + + private static class Node{ + Object data; + Node next; + + } +} diff --git a/group11/395443277/a1/src/com/coding/basic/LinkedListTest.java b/group11/395443277/a1/src/com/coding/basic/LinkedListTest.java new file mode 100644 index 0000000000..7faae38be6 --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/LinkedListTest.java @@ -0,0 +1,114 @@ +package com.coding.basic; + +import static org.junit.Assert.*; + +import org.junit.Test; + +public class LinkedListTest { + + @Test + public void testAddObject() { + LinkedList list = new LinkedList(); + list.add(5); + assertEquals(1, list.size()); + assertEquals(5, list.get(0)); + + list.add(4); + list.add(3); + list.add(2); + assertEquals(4, list.size()); + assertEquals(4, list.get(1)); + assertEquals(3, list.get(2)); + assertEquals(2, list.get(3)); + } + + @Test + public void testAddIntObject() { + LinkedList list = new LinkedList(); + list.add(0, 5); + assertEquals(1, list.size()); + assertEquals(5, list.get(0)); + + list.add(4); + list.add(3); + list.add(2); + + list.add(1, 1); + assertEquals(1, list.get(1)); + } + + @Test + public void testRemove() { + LinkedList list = new LinkedList(); + assertEquals(null, list.remove(0)); + list.add(4); + assertEquals(4, list.remove(0)); + + list.add(5); + list.add(-1); + list.add(16); + list.add(2); + list.add(7); + assertEquals(16, list.remove(2)); + assertEquals(4, list.size()); + assertEquals(2, list.get(2)); + } + + @Test + public void testAddFirst() { + LinkedList list = new LinkedList(); + list.addFirst(5); + assertEquals(1, list.size()); + assertEquals(5, list.get(0)); + + list.addFirst(4); + list.addFirst(3); + list.addFirst(2); + assertEquals(4, list.size()); + assertEquals(2, list.get(1)); + assertEquals(3, list.get(2)); + assertEquals(4, list.get(3)); + } + + @Test + public void testAddLast() { + LinkedList list = new LinkedList(); + list.addLast(5); + assertEquals(1, list.size()); + assertEquals(5, list.get(0)); + + list.addLast(4); + list.addLast(3); + list.addLast(2); + assertEquals(4, list.size()); + assertEquals(4, list.get(1)); + assertEquals(3, list.get(2)); + assertEquals(2, list.get(3)); + } + + @Test + public void testRemoveFirst() { + LinkedList list = new LinkedList(); + assertEquals(null, list.removeFirst()); + + list.add(4); + list.add(3); + list.add(2); + assertEquals(4, list.removeFirst()); + assertEquals(3, list.removeFirst()); + assertEquals(2, list.removeFirst()); + } + + @Test + public void testRemoveLast() { + LinkedList list = new LinkedList(); + assertEquals(null, list.removeLast()); + + list.add(4); + list.add(3); + list.add(2); + assertEquals(2, list.removeLast()); + assertEquals(3, list.removeLast()); + } + +} diff --git a/group11/395443277/a1/src/com/coding/basic/List.java b/group11/395443277/a1/src/com/coding/basic/List.java new file mode 100644 index 0000000000..10d13b5832 --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/List.java @@ -0,0 +1,9 @@ +package com.coding.basic; + +public interface List { + public void add(Object o); + public void add(int index, Object o); + public Object get(int index); + public Object remove(int index); + public int size(); +} diff --git a/group11/395443277/a1/src/com/coding/basic/Queue.java b/group11/395443277/a1/src/com/coding/basic/Queue.java new file mode 100644 index 0000000000..f12e73d46d --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/Queue.java @@ -0,0 +1,21 @@ +package com.coding.basic; + +public class Queue { + private LinkedList elementData = new LinkedList(); + + public void enQueue(Object o){ + elementData.add(o); + } + + public Object deQueue(){ + return elementData.removeFirst(); + } + + public boolean isEmpty(){ + return elementData.size()==0; + } + + public int size(){ + return elementData.size(); + } +} diff --git a/group11/395443277/a1/src/com/coding/basic/QueueTest.java b/group11/395443277/a1/src/com/coding/basic/QueueTest.java new file mode 100644 index 0000000000..bd1ec0487a --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/QueueTest.java @@ -0,0 +1,29 @@ +package com.coding.basic; + +import static org.junit.Assert.*; + +import org.junit.Test; + +public class QueueTest { + + @Test + public void testEnQueue() { + Queue q = new Queue(); + assertEquals(0, q.size()); + + q.enQueue(1); + q.enQueue(2); + q.enQueue(3); + } + + @Test + public void testDeQueue() { + Queue q = new Queue(); + q.enQueue(1); + q.enQueue(2); + q.enQueue(3); + assertEquals(1, q.deQueue()); + assertEquals(2, q.deQueue()); + } + +} diff --git a/group11/395443277/a1/src/com/coding/basic/Stack.java b/group11/395443277/a1/src/com/coding/basic/Stack.java new file mode 100644 index 0000000000..28b9e8a203 --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/Stack.java @@ -0,0 +1,23 @@ +package com.coding.basic; + +public class Stack { + private ArrayList elementData = new ArrayList(); + + public void push(Object o){ + elementData.add(o); + } + + public Object pop(){ + return elementData.remove(elementData.size()-1); + } + + public Object peek(){ + return elementData.get(elementData.size()-1); + } + public boolean isEmpty(){ + return elementData.size()==0; + } + public int size(){ + return elementData.size(); + } +} diff --git a/group11/395443277/a1/src/com/coding/basic/StackTest.java b/group11/395443277/a1/src/com/coding/basic/StackTest.java new file mode 100644 index 0000000000..7b3c4d2cf6 --- /dev/null +++ b/group11/395443277/a1/src/com/coding/basic/StackTest.java @@ -0,0 +1,45 @@ +package com.coding.basic; + +import static org.junit.Assert.*; + +import org.junit.Test; + +public class StackTest { + + @Test + public void testPush() { + Stack st = new Stack(); + st.push(1); + assertEquals(1, st.peek()); + + st.push(2); + st.push(3); + st.push(4); + assertEquals(4, st.peek()); + } + + @Test + public void testPop() { + Stack st = new Stack(); + assertEquals(null, st.pop()); + + st.push(1); + assertEquals(1, st.pop()); + + st.push(2); + st.push(3); + st.push(4); + assertEquals(4, st.pop()); + } + + @Test + public void testIsEmpty() { + Stack st = new Stack(); + assertEquals(true, st.isEmpty()); + + st.push(1); + assertEquals(false, st.isEmpty()); + } + + +} From beaf0d3bdd182f9e4e5197cfefaac9a628515089 Mon Sep 17 00:00:00 2001 From: Fred Qin Date: Fri, 24 Feb 2017 20:17:39 -0800 Subject: [PATCH 2/2] Complete data structure assignment --- .../{a1 => data_structure}/.gitignore | 0 .../src/com/coding/basic/ArrayList.java | 22 +++++++++++++++-- .../src/com/coding/basic/ArrayListTest.java | 17 +++++++++++++ .../src/com/coding/basic/BinaryTreeNode.java | 0 .../com/coding/basic/BinaryTreeNodeTest.java | 0 .../src/com/coding/basic/Iterator.java | 0 .../src/com/coding/basic/LinkedList.java | 24 ++++++++++++++++--- .../src/com/coding/basic/LinkedListTest.java | 13 ++++++++++ .../src/com/coding/basic/List.java | 0 .../src/com/coding/basic/Queue.java | 0 .../src/com/coding/basic/QueueTest.java | 0 .../src/com/coding/basic/Stack.java | 0 .../src/com/coding/basic/StackTest.java | 0 13 files changed, 71 insertions(+), 5 deletions(-) rename group11/395443277/{a1 => data_structure}/.gitignore (100%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/ArrayList.java (78%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/ArrayListTest.java (80%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/BinaryTreeNode.java (100%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/BinaryTreeNodeTest.java (100%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/Iterator.java (100%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/LinkedList.java (84%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/LinkedListTest.java (90%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/List.java (100%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/Queue.java (100%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/QueueTest.java (100%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/Stack.java (100%) rename group11/395443277/{a1 => data_structure}/src/com/coding/basic/StackTest.java (100%) diff --git a/group11/395443277/a1/.gitignore b/group11/395443277/data_structure/.gitignore similarity index 100% rename from group11/395443277/a1/.gitignore rename to group11/395443277/data_structure/.gitignore diff --git a/group11/395443277/a1/src/com/coding/basic/ArrayList.java b/group11/395443277/data_structure/src/com/coding/basic/ArrayList.java similarity index 78% rename from group11/395443277/a1/src/com/coding/basic/ArrayList.java rename to group11/395443277/data_structure/src/com/coding/basic/ArrayList.java index 4c6c92c42e..93a2781f3b 100644 --- a/group11/395443277/a1/src/com/coding/basic/ArrayList.java +++ b/group11/395443277/data_structure/src/com/coding/basic/ArrayList.java @@ -57,8 +57,26 @@ public int size(){ return size; } - public Iterator iterator(){ - return null; + public Iterator iterator (){ + return new SeqIterator(); + } + + private class SeqIterator implements Iterator { + int i = 0; + + @Override + public boolean hasNext() { + return i < size; + } + + @Override + public Object next() { + if (!hasNext()) { + return null; + } + return elementData[i++]; + } + } } diff --git a/group11/395443277/a1/src/com/coding/basic/ArrayListTest.java b/group11/395443277/data_structure/src/com/coding/basic/ArrayListTest.java similarity index 80% rename from group11/395443277/a1/src/com/coding/basic/ArrayListTest.java rename to group11/395443277/data_structure/src/com/coding/basic/ArrayListTest.java index 3025b8e077..75bae320f4 100644 --- a/group11/395443277/a1/src/com/coding/basic/ArrayListTest.java +++ b/group11/395443277/data_structure/src/com/coding/basic/ArrayListTest.java @@ -64,4 +64,21 @@ public void testRemove() { assertEquals(6, list.get(4)); } + @Test + public void testIterator() { + ArrayList list = new ArrayList(); + list.add(5); + list.add(4); + list.add(3); + list.add(2); + list.add(1); + + Iterator it = list.iterator(); + if(it.hasNext()) { + assertEquals(5, it.next()); + assertEquals(4, it.next()); + } + + } + } diff --git a/group11/395443277/a1/src/com/coding/basic/BinaryTreeNode.java b/group11/395443277/data_structure/src/com/coding/basic/BinaryTreeNode.java similarity index 100% rename from group11/395443277/a1/src/com/coding/basic/BinaryTreeNode.java rename to group11/395443277/data_structure/src/com/coding/basic/BinaryTreeNode.java diff --git a/group11/395443277/a1/src/com/coding/basic/BinaryTreeNodeTest.java b/group11/395443277/data_structure/src/com/coding/basic/BinaryTreeNodeTest.java similarity index 100% rename from group11/395443277/a1/src/com/coding/basic/BinaryTreeNodeTest.java rename to group11/395443277/data_structure/src/com/coding/basic/BinaryTreeNodeTest.java diff --git a/group11/395443277/a1/src/com/coding/basic/Iterator.java b/group11/395443277/data_structure/src/com/coding/basic/Iterator.java similarity index 100% rename from group11/395443277/a1/src/com/coding/basic/Iterator.java rename to group11/395443277/data_structure/src/com/coding/basic/Iterator.java diff --git a/group11/395443277/a1/src/com/coding/basic/LinkedList.java b/group11/395443277/data_structure/src/com/coding/basic/LinkedList.java similarity index 84% rename from group11/395443277/a1/src/com/coding/basic/LinkedList.java rename to group11/395443277/data_structure/src/com/coding/basic/LinkedList.java index e05f035eb2..fb9fbd81ca 100644 --- a/group11/395443277/a1/src/com/coding/basic/LinkedList.java +++ b/group11/395443277/data_structure/src/com/coding/basic/LinkedList.java @@ -1,7 +1,8 @@ package com.coding.basic; +import java.util.NoSuchElementException; + public class LinkedList implements List { - private Node head; public void add(Object o){ @@ -126,11 +127,28 @@ public Object removeLast(){ return target; } public Iterator iterator(){ - return null; + return new SeqIterator(); } + private class SeqIterator implements Iterator { + Node curr = head; + + @Override + public boolean hasNext() { + return curr != null; + } + + @Override + public Object next() { + if (!hasNext()) throw new NoSuchElementException(); + Object target = curr.data; + curr = curr.next; + return target; + } + + } - private static class Node{ + private static class Node{ Object data; Node next; diff --git a/group11/395443277/a1/src/com/coding/basic/LinkedListTest.java b/group11/395443277/data_structure/src/com/coding/basic/LinkedListTest.java similarity index 90% rename from group11/395443277/a1/src/com/coding/basic/LinkedListTest.java rename to group11/395443277/data_structure/src/com/coding/basic/LinkedListTest.java index 7faae38be6..af5aa2d3a2 100644 --- a/group11/395443277/a1/src/com/coding/basic/LinkedListTest.java +++ b/group11/395443277/data_structure/src/com/coding/basic/LinkedListTest.java @@ -111,4 +111,17 @@ public void testRemoveLast() { assertEquals(3, list.removeLast()); } + @Test + public void testIterator() { + LinkedList list = new LinkedList(); + list.add(4); + list.add(3); + list.add(2); + + Iterator it = list.iterator(); + + assertEquals(4, it.next()); + assertEquals(3, it.next()); + assertEquals(2, it.next()); + } } diff --git a/group11/395443277/a1/src/com/coding/basic/List.java b/group11/395443277/data_structure/src/com/coding/basic/List.java similarity index 100% rename from group11/395443277/a1/src/com/coding/basic/List.java rename to group11/395443277/data_structure/src/com/coding/basic/List.java diff --git a/group11/395443277/a1/src/com/coding/basic/Queue.java b/group11/395443277/data_structure/src/com/coding/basic/Queue.java similarity index 100% rename from group11/395443277/a1/src/com/coding/basic/Queue.java rename to group11/395443277/data_structure/src/com/coding/basic/Queue.java diff --git a/group11/395443277/a1/src/com/coding/basic/QueueTest.java b/group11/395443277/data_structure/src/com/coding/basic/QueueTest.java similarity index 100% rename from group11/395443277/a1/src/com/coding/basic/QueueTest.java rename to group11/395443277/data_structure/src/com/coding/basic/QueueTest.java diff --git a/group11/395443277/a1/src/com/coding/basic/Stack.java b/group11/395443277/data_structure/src/com/coding/basic/Stack.java similarity index 100% rename from group11/395443277/a1/src/com/coding/basic/Stack.java rename to group11/395443277/data_structure/src/com/coding/basic/Stack.java diff --git a/group11/395443277/a1/src/com/coding/basic/StackTest.java b/group11/395443277/data_structure/src/com/coding/basic/StackTest.java similarity index 100% rename from group11/395443277/a1/src/com/coding/basic/StackTest.java rename to group11/395443277/data_structure/src/com/coding/basic/StackTest.java