diff --git a/.gitignore b/.gitignore
index ec55baf87d..7f06ac1c28 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,4 @@
 *.class
-
 # Mobile Tools for Java (J2ME)
 .mtj.tmp/
 
@@ -8,9 +7,25 @@
 *.war
 *.ear
 
+*.iml
+*.idea
+
+
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
 
 #ide config
 .metadata
 .recommenders
+
+
+#macOS
+.DS_Store
+
+.idea/
+*.iml
+rebel.*
+.rebel.*
+
+target
+
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/ArrayList.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/ArrayList.java
new file mode 100644
index 0000000000..59ca0d34ee
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/ArrayList.java
@@ -0,0 +1,97 @@
+package com.github.Ven13.coding2017.basic;
+
+public class ArrayList implements List {
+	
+	//���ؼ��ϴ�С
+	private int size = 0;
+	
+	//�ȸ���һ������Ϊ10������
+	Object[] elementData = new Object[100];
+	
+	@Override
+	//��̬����Ԫ��
+	public void add(Object o) {
+		//���ж������Ƿ�����
+		if(size == elementData.length) {
+			Object[] newObjects = new Object[elementData.length * 2];
+			System.arraycopy(elementData, 0, newObjects, 0, elementData.length);
+			elementData = newObjects;
+		}
+		
+		//Ϊ�����ӵ�Ԫ��ָ���±�
+		elementData[size] = o;
+		size++;
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		//���ж������Ƿ�����
+		if(size == elementData.length) {
+			Object[] newObjects = elementData;
+			this.elementData = new Object[elementData.length * 2];
+			for(int j = 0; j < newObjects.length; j++) {
+				this.elementData[j] = newObjects[j];
+			}
+		}
+		
+		for(int i = size - 1; i >= index; i--) {
+			elementData[i+1] = elementData[i];
+		}
+		
+		elementData[index] = o;
+		size++;
+	}
+
+	@Override
+	public Object get(int index) {
+		return elementData[index];
+	}
+
+	@Override
+	public Object remove(int index) {
+		if (index > size) {
+			return null;
+		};
+		
+		int moveSize = size - index - 1;
+		
+		if (moveSize > 0) {
+			System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
+		}
+		elementData[--size] = null;
+
+		//for(int i = index; i < elementData.length; i++) {
+		//	elementData[i] = elementData[i+1];
+		//}
+		
+		return elementData;
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+	
+	public Iterator iterator(){
+		return new ArrayListIterator();
+	}
+	
+	private class ArrayListIterator implements Iterator {
+
+		private int currentIndex = 0;
+		
+		@Override
+		public boolean hasNext() {
+			if(currentIndex >= size) return false;
+			else return true;
+		}
+
+		@Override
+		public Object next() {
+			Object o = elementData[currentIndex];
+		    currentIndex ++;
+		    return o;
+		}
+	}
+	
+}
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/BinaryTreeNode.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..354b2ba7a0
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/BinaryTreeNode.java
@@ -0,0 +1,32 @@
+package com.github.Ven13.coding2017.basic;
+
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/Iterator.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/Iterator.java
new file mode 100644
index 0000000000..3cf6540e5e
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/Iterator.java
@@ -0,0 +1,7 @@
+package com.github.Ven13.coding2017.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/LinkedList.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/LinkedList.java
new file mode 100644
index 0000000000..adf30d89c2
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/LinkedList.java
@@ -0,0 +1,173 @@
+package com.github.Ven13.coding2017.basic;
+
+public class LinkedList implements List {
+		
+	//��ʾ�������ĳ���  
+	private int size;
+	
+    //������ͷԪ��  
+    private Node head;  
+    //������βԪ��  
+    private Node tail;  
+	
+  //ʹ���ڲ�����ʵ��������ÿһ���ڵ㣬ÿ���ڵ���һ��ָ����һ��Ԫ�ص�next���Լ�������data
+  	private static class Node {
+  		public Object data;
+  		public Node next;
+  				
+  		public Node(Object data) {
+  			this.data = data;
+  		}
+  	}	
+    
+    //�����Ĺ��췽��
+    public LinkedList() {
+    }
+       
+	@Override
+	public void add(Object o) {
+		add(size, o);
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		if(index == 0) {
+			addFirst(o);
+		} else {
+			if(index >= size) {
+				addLast(o);
+			} else {
+				Node node = head;
+				for (int i = 1; i < index; i++) {  
+					head = head.next;  
+				} 
+				Node nextNode = node.next;  
+				Node temp = new Node(o);  
+				node.next = temp;  
+				temp.next = nextNode;  
+				size++;  
+			}
+		}
+	}
+		
+	//����ǰ��
+	public void addFirst(Object o) {
+		Node newNode = new Node(o);
+		newNode.next = head;
+		head = newNode;
+		size++;
+		if(tail == null) {
+			tail = head;
+		}
+	}
+	
+	//���Ӻ���
+	public void addLast(Object o) {
+		if(tail == null) {
+			tail = head = new Node(o);
+		} else {
+			Node newNode = new Node(o);
+			tail.next = newNode;
+			tail = tail.next;
+		}
+		size++;
+	}
+    
+    
+	@Override
+	public Object get(int index) {
+		Node node = head;
+		for(int i = 0; i < index; i++) {
+			node = node.next;
+		}
+		return node.data;
+	}
+
+	@Override
+	public Object remove(int index) {
+		if(size == 0) {
+			throw new java.util.NoSuchElementException();  
+		}
+		if(index == 0) {
+			Node node = head;
+			Node temp = node.next;
+			head = temp;
+			size--;
+			return node.data;
+		} else {
+			if(index >= size) {
+				throw new java.util.NoSuchElementException();  
+			} else {
+				Node node = head;
+				for(int i = 1; i < index; i++) {
+					node = node.next;
+				}
+				Node temp = node.next;
+				node.next = temp.next;
+				size--;
+				return node.data;
+			}
+		}
+		
+	}
+	
+	@Override
+	public int size() {
+		return size;
+	}	
+	
+	public Object removeFirst() {
+		//ͨ��ͷָ�봴��ͷ�ڵ�
+		Node hNode = head;
+		if (hNode == null) {
+			throw new java.util.NoSuchElementException();  
+		}
+		Node nNode  = hNode.next;
+		Object element = hNode.data;
+		
+		//�Ƴ�
+		hNode.data = null;
+		hNode.next = null;
+		head = nNode;
+		//�ж��Ƿ�Ϊβ�ڵ�
+		if (nNode == null) {
+			tail = null;
+		}else {
+			nNode = null;
+		}
+		size --;
+		return element;
+	}
+	
+	public Object removeLast() {
+		return remove(size - 1);
+	}
+	
+	public Iterator iterator() {
+		return new LinkedListIterator();
+	}
+	
+	private class LinkedListIterator implements Iterator {
+		
+		private Node node = head.next;  
+		
+		@Override
+		public boolean hasNext() {
+			return node != tail;  
+		}
+
+		@Override
+		public Object next() {
+			
+            if(!hasNext()) {  
+                throw new java.util.NoSuchElementException();  
+            }  
+            Object nextData = node.data;  
+            node = node.next;   
+            return nextData;  
+		}
+		
+	}
+	
+	
+}
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/List.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/List.java
new file mode 100644
index 0000000000..02e4297a33
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/List.java
@@ -0,0 +1,11 @@
+package com.github.Ven13.coding2017.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();
+	
+	public Iterator iterator();
+}
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/Queue.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/Queue.java
new file mode 100644
index 0000000000..112299b5e9
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/Queue.java
@@ -0,0 +1,30 @@
+package com.github.Ven13.coding2017.basic;
+
+public class Queue {
+	
+	private LinkedList list = new LinkedList();  
+    private int size = 0;  
+	
+	public void enQueue(Object o){
+		size++;  
+        list.addLast(o);  
+	}
+	
+	public Object deQueue(){
+		size--;
+		return list.removeFirst();
+	}
+	
+	public boolean isEmpty(){
+		if(size == 0) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+}
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/Stack.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/Stack.java
new file mode 100644
index 0000000000..c0a2658bb3
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/Stack.java
@@ -0,0 +1,30 @@
+package com.github.Ven13.coding2017.basic;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){		
+
+		elementData.add(o);
+	}
+	
+	public Object pop(){
+		Object o = null;
+		if(elementData.size() > 0) {
+			o = elementData.get(elementData.size() - 1);
+			elementData.remove(elementData.size() - 1);
+		}
+		return o;
+	}
+	
+	public Object peek(){
+		return elementData.get(0);
+	}
+	public boolean isEmpty(){
+		return elementData.size() == 0;
+	}
+	public int size(){
+		return elementData.size();
+	}
+	
+}
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/ArrayListTest.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/ArrayListTest.java
new file mode 100644
index 0000000000..7f3f179f3b
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/ArrayListTest.java
@@ -0,0 +1,11 @@
+package com.github.Ven13.coding2017.basic.test;
+
+import org.junit.Before;
+
+import com.github.Ven13.coding2017.basic.*;
+
+public class ArrayListTest extends ListTest{
+
+	
+
+}
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/LinkedListTest.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/LinkedListTest.java
new file mode 100644
index 0000000000..c6bc65698c
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/LinkedListTest.java
@@ -0,0 +1,100 @@
+package com.github.Ven13.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.Ven13.coding2017.basic.ArrayList;
+import com.github.Ven13.coding2017.basic.LinkedList;
+import com.github.Ven13.coding2017.basic.List;
+
+public class LinkedListTest extends ListTest {
+
+private LinkedList aLinkedList;
+	
+	@Before
+	public void setUpLinkedList() {
+		List aList = new ArrayList();
+		aList = new LinkedList();
+		aLinkedList = new LinkedList();
+	}
+
+	@Test
+	public void testAddFirst() {
+		aLinkedList.addFirst(5);
+		assertEquals(5, aLinkedList.get(0));
+		
+		aLinkedList.addFirst(6);
+		assertEquals(6, aLinkedList.get(0));
+		assertEquals(5, aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+	@Test
+	public void testAddLast() {
+		aLinkedList.addLast("hello");
+		assertEquals("hello", aLinkedList.get(0));
+		
+		aLinkedList.addLast("world");
+		assertEquals("hello", aLinkedList.get(0));
+		assertEquals("world", aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+	@Test
+	public void testRemoveFirst() {
+		aLinkedList.addLast("hello");
+		aLinkedList.addLast("world");
+		
+		aLinkedList.removeFirst();
+		assertEquals("world", aLinkedList.get(0));
+		assertEquals(1, aLinkedList.size());
+		
+		aLinkedList.removeFirst();
+		assertEquals(0, aLinkedList.size());
+	}
+	
+	@Test
+	public void testRemoveLast() {
+		aLinkedList.addFirst("world");
+		aLinkedList.addFirst("hello");
+		
+		aLinkedList.removeLast();
+		//assertEquals("hello", aLinkedList.get(0));
+		assertEquals(1, aLinkedList.size());
+		
+		aLinkedList.removeLast();
+		assertEquals(0, aLinkedList.size());
+	}
+	
+	@Test
+	public void testLinkedListFunctional() {
+		for (int i = 1; i < 4; i++) {
+			aLinkedList.add(i);  // [1,2,3]
+		}
+		aLinkedList.remove(1);  // [1,3]
+		
+		aLinkedList.add(1, 0);  // [1,0,3]
+		for (int i=4; i<6; i++) {
+			aLinkedList.addFirst(i);  // [5, 4, 1, 0, 3]
+		}
+		assertEquals(5, aLinkedList.size());
+		assertEquals(5, aLinkedList.get(0));
+		assertEquals(1, aLinkedList.get(2));
+		assertEquals(0, aLinkedList.get(3));
+		
+		
+		aLinkedList.remove(3);  // [5, 4, 1, 3]
+		assertEquals(3, aLinkedList.get(aLinkedList.size()-1));
+		aLinkedList.removeLast();  // [5, 4, 1]
+		assertEquals(1, aLinkedList.get(aLinkedList.size()-1));
+		aLinkedList.removeFirst();   // [4,1]
+		
+		assertEquals(4, aLinkedList.get(0));
+		assertEquals(1, aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+		
+	}
+
+}
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/ListTest.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/ListTest.java
new file mode 100644
index 0000000000..6959da0421
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/ListTest.java
@@ -0,0 +1,129 @@
+package com.github.Ven13.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.*;
+
+import com.github.Ven13.coding2017.basic.ArrayList;
+import com.github.Ven13.coding2017.basic.Iterator;
+import com.github.Ven13.coding2017.basic.List;
+
+public class ListTest {
+
+	//protected static List aList;
+	
+	@Test
+	public void testFunctional() {
+		
+		List aList = new ArrayList();
+		
+		aList.add(1);
+		aList.add(2);
+		assertEquals(1, aList.get(0));
+		assertEquals(2, aList.get(1));
+		
+		aList.add(3);
+		aList.add(0, 5);
+		aList.add(2, 11);
+		assertEquals(5, aList.get(0));
+		assertEquals(11, aList.get(2));
+		
+		aList.add("hi");
+		assertEquals("hi", aList.get(5));
+		assertEquals(6, aList.size());
+		
+		aList.remove(1);
+		assertEquals(11, aList.get(1));
+		assertEquals(2, aList.get(2));
+		
+		assertEquals(5, aList.size());
+	}
+	
+	@Test
+	public void testAdd() {
+		
+		List aList = new ArrayList();
+		
+		for (int i = 0; i < 100; i++) {
+			aList.add(i);
+		}
+			
+		assertEquals(0, aList.get(0));
+		assertEquals(99, aList.get(99));
+		assertEquals(44, aList.get(44));
+	}
+	
+	@Test
+	public void testRemove() {
+		
+		List aList = new ArrayList();
+		
+		aList.add(1);
+		aList.add(2);
+		aList.add(3);
+		aList.remove(3);
+		assertEquals(2, aList.size());
+		
+	}
+	
+	@Test
+	public void testSize() {
+		
+		List aList = new ArrayList();
+		
+		for (int i = 0; i < 10; i++) {
+			aList.add(i * 2);
+		}
+			
+		assertEquals(10, aList.size());
+	}
+	
+	@Rule  
+	public ExpectedException expectedEx = ExpectedException.none(); 
+	
+	@Test
+	public void testException() {
+		
+		List aList = new ArrayList();
+		
+		expectedEx.expect(Exception.class);
+		
+		aList.remove(1);
+		aList.add(3);
+		aList.add(2, 5);
+	}
+	
+	@Test
+	public void testIterator() {
+		
+		List aList = new ArrayList();
+		
+		Iterator it = aList.iterator();
+		
+		assertEquals(false, it.hasNext());
+		
+		aList.add(1);
+		aList.add(2);
+		aList.add(3);
+		
+		it = aList.iterator();
+		assertEquals(true, it.hasNext());
+		assertEquals(1, it.next());
+		assertEquals(2, it.next());
+		assertEquals(3, it.next());
+		assertEquals(false, it.hasNext());
+		
+		aList.remove(1);
+		it = aList.iterator();
+		assertEquals(true, it.hasNext());
+		assertEquals(1, it.next());
+		assertEquals(3, it.next());
+		assertEquals(false, it.hasNext());	
+		
+		expectedEx.expect(Exception.class);
+		it.next();
+	}
+
+}
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/QueueTest.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/QueueTest.java
new file mode 100644
index 0000000000..965610cdce
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/QueueTest.java
@@ -0,0 +1,36 @@
+package com.github.Ven13.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.Ven13.coding2017.basic.Queue;
+
+public class QueueTest {
+
+private Queue queue;
+	
+	@Before
+	public void setUpQueue() {
+		queue = new Queue();
+	}
+	
+	@Test
+	public void testQueueFunctional() {
+		assertEquals(true, queue.isEmpty());
+		queue.enQueue(4);
+		queue.enQueue(2);
+		assertEquals(2, queue.size());
+		assertEquals(false, queue.isEmpty());
+		
+		int i = (Integer)queue.deQueue();
+		assertEquals(4, i);
+		i = (Integer)queue.deQueue();
+		assertEquals(2, i);
+		
+		assertEquals(0, queue.size());
+		assertEquals(true, queue.isEmpty());
+	}
+
+}
diff --git a/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/StackTest.java b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/StackTest.java
new file mode 100644
index 0000000000..9bbf41914f
--- /dev/null
+++ b/group02/106614649/106614649Learnin/src/com/github/Ven13/coding2017/basic/test/StackTest.java
@@ -0,0 +1,40 @@
+package com.github.Ven13.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.Ven13.coding2017.basic.Stack;
+
+public class StackTest {
+
+private Stack stack;
+	
+	@Before
+	public void setUpStack() {
+		stack = new Stack();
+	}
+
+	@Test
+	public void testStackFunctional() {
+		assertEquals(true, stack.isEmpty());
+		stack.push(4);
+		stack.push(2);
+		assertEquals(2, stack.size());
+		assertEquals(false, stack.isEmpty());
+		
+		int i = (Integer)stack.pop();
+		assertEquals(2, i);
+		
+		i = (Integer)stack.peek();
+		assertEquals(4, i);
+		
+		i = (Integer)stack.pop();
+		assertEquals(4, i);
+		
+		assertEquals(0, stack.size());
+		assertEquals(true, stack.isEmpty());
+	}
+
+}
diff --git a/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyArrayList.java b/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyArrayList.java
new file mode 100644
index 0000000000..03f6710788
--- /dev/null
+++ b/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyArrayList.java
@@ -0,0 +1,83 @@
+package com.github.lhpmatlab.coding2017.basic;
+
+/**
+ * Created by andy on 2017/2/18.
+ */
+public class MyArrayList<T> {
+
+    private Object[] initialArray = {};
+    private Object[] dataArray;
+    private int initSize = 10;
+    private int arraySize;
+    public MyArrayList() {
+        dataArray = initialArray;
+    }
+
+    public MyArrayList(int init) {
+        dataArray = new Object[init];
+    }
+
+    public void ensureCapacity(int newCapacity) {
+        if (newCapacity < arraySize)
+            return;
+
+        Object[] old = dataArray;
+        dataArray = new Object[newCapacity];
+        for (int i = 0; i < size(); i++) {
+            dataArray[i] = old[i];
+        }
+    }
+
+    public void add(T element) {
+        add(size(), element);
+    }
+
+    public void add(int index, T element) {
+        if (size() == dataArray.length) {
+            ensureCapacity(size()*2 + 1);
+        }
+        for(int i=arraySize;i>index;i--) {
+            dataArray[i] = dataArray[i - 1];
+        }
+        dataArray[index] = element;
+        arraySize++;
+    }
+
+    public T delete(int index) {
+        if (index < 0 || index > arraySize) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+        T removeElement = (T)dataArray[index];
+        for (int i = index; i < size() -1; i++) {
+            dataArray[i] = dataArray[i + 1];
+        }
+        arraySize--;
+        return removeElement;
+    }
+
+    public T get(int index) {
+        if (index < 0 || index > arraySize) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+        return (T)dataArray[index];
+    }
+
+    public T set(int index, T newElement) {
+        if (index < 0 || index > arraySize) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+        T oldElement = (T) dataArray[index];
+        dataArray[index] = newElement;
+
+        return oldElement;
+    }
+
+    public int size() {
+        return arraySize;
+    }
+
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+}
diff --git a/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyLinkedList.java b/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyLinkedList.java
new file mode 100644
index 0000000000..9e7eab3401
--- /dev/null
+++ b/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyLinkedList.java
@@ -0,0 +1,119 @@
+package com.github.lhpmatlab.coding2017.basic;
+
+/**
+ * Created by andy on 2017/2/18.
+ */
+public class MyLinkedList<T> {
+	 private class Node<T> {
+	        public Node<T> pre;
+	        public Node<T> next;
+	        public T data;
+
+	        public Node(Node<T> pre,Node<T> next,T data) {
+	            this.pre = pre;
+	            this.next = next;
+	            this.data = data;
+	        }
+	    }
+
+	    private int dataSize;
+
+	    private Node head;
+	    private Node tail;
+
+	    public MyLinkedList() {
+	        head = new Node<T>(null,null,null);
+	        tail = new Node(head, null, null);
+	        head.next = tail;
+	        dataSize = 0;
+	    }
+
+	    public void add(T t) {
+//	        add(size(), t);
+	        Node<T> newNode = new Node<>(null, tail, t);
+	        newNode.pre = tail.pre;
+	        tail.pre.next = newNode;
+	        tail.pre = newNode;
+	        dataSize++;
+
+	    }
+
+	    /**
+	     * 根据索引添加没有实现
+	     * @param index
+	     * @param element
+	     */
+	    public void add(int index,T element) {
+	        //TODO 根据索引添加元素
+//	        addBefore(getNode(index,0,size()-1),element);
+//	        if (index == dataSize) {
+//	            add(element);
+//	        } else {
+	//
+//	        }
+	    }
+
+	    public T get(int index) {
+	        return getNode(index).data;
+	    }
+
+	    public T set(int index, T newValue) {
+	        Node<T> node = getNode(index);
+	        T oldData = node.data;
+	        node.data = newValue;
+	        return oldData;
+	    }
+
+	    public T remove(int index) {
+	        Node<T> node = getNode(index);
+	        node.next.pre = node.pre;
+	        node.pre.next = node.next;
+	        dataSize--;
+
+	        return node.data;
+
+	    }
+
+	    private void addBefore(Node<T> node, T element) {
+//	        newNode.pre.next = newNode;
+//	        node.pre = newNode;
+	        Node<T> pre = node.pre;
+	        Node<T> newNode = new Node<>(node.pre, node, element);
+	        node.pre = newNode;
+	        pre.next = newNode;
+
+	        dataSize++;
+	    }
+
+	    private Node<T> getNode(int index) {
+	        return getNode(index, 0, size());
+	    }
+
+	    private Node<T> getNode(int index, int lower, int upper) {
+	        Node<T> p;
+	        if (index < lower || index > upper) {
+	            throw new IndexOutOfBoundsException();
+	        }
+
+	        if (index < size() / 2) {
+	            p = head.next;
+	            for (int i = 0; i < index; i++) {
+	                p = p.next;
+	            }
+	        } else {
+	            p = tail.pre;
+	            for (int i = size()-1; i > index; i--) {
+	                p = p.pre;
+	            }
+	        }
+	        return p;
+	    }
+
+	    public int size() {
+	        return dataSize;
+	    }
+
+	    public boolean isEmpty() {
+	        return size() == 0;
+	    }
+}
diff --git a/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyQueue.java b/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyQueue.java
new file mode 100644
index 0000000000..6d0c970b65
--- /dev/null
+++ b/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyQueue.java
@@ -0,0 +1,29 @@
+package com.github.lhpmatlab.coding2017.basic;
+
+/**
+ * Created by andy on 2017/2/22.
+ */
+public class MyQueue<T> {
+    private MyLinkedList<T> link = new MyLinkedList<>();
+
+    public void enQueue(T t) {
+        link.add(t);
+    }
+
+    public T deQueue() {
+        if (size() <= 0) {
+            return null;
+        }
+        T t = link.get(0);
+        link.remove(0);
+        return t;
+    }
+
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    public int size() {
+        return link.size();
+    }
+}
diff --git a/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyStack.java b/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyStack.java
new file mode 100644
index 0000000000..3fd9d2f5c2
--- /dev/null
+++ b/group02/435994736/src/main/java/com/github/lhpmatlab/coding2017/basic/MyStack.java
@@ -0,0 +1,30 @@
+package com.github.lhpmatlab.coding2017.basic;
+
+/**
+ * Created by andy on 2017/2/22.
+ */
+public class MyStack<T> {
+    private MyArrayList<T> list = new MyArrayList<>();
+
+    public void push(T t) {
+        list.add(t);
+    }
+
+    public T pop() {
+        if (size() <= 0) {
+            throw new IndexOutOfBoundsException();
+        }
+        return list.delete(size() - 1);
+    }
+
+    public T peek() {
+        return list.get(size() - 1);
+    }
+
+    public boolean isEmpty() {
+        return list.size() == 0;
+    }
+    public int size() {
+        return list.size();
+    }
+}
diff --git a/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyArrayListTest.java b/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyArrayListTest.java
new file mode 100644
index 0000000000..e29d41feac
--- /dev/null
+++ b/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyArrayListTest.java
@@ -0,0 +1,113 @@
+package com.github.lhpmatlab.coding2017.basic;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class MyArrayListTest {
+	 private MyArrayList<String> list;
+
+	    @Before
+	    public void init(){
+	        list = new MyArrayList<>();
+	    }
+
+	    @Test
+	    public void testEnsureCapacity() {
+	        assertEquals("init list size is 0  ", list.size(), 0);
+	        list.add("1");
+	        list.ensureCapacity(10);
+	        assertEquals("ensureCapacity size is 10 ", list.size(),1);
+	    }
+
+	    /**
+	     * 在列表的末尾添加元素
+	     */
+	    @Test
+	    public void testAddT() {
+	        assertEquals("init list size is 0  ", list.size(), 0);
+	        list.add("1");
+	        list.add("2");
+	        assertEquals("add list size ", list.size(), 2);
+	        for (int i=0; i<list.size(); i++) {
+	            assertEquals("index of"+i,list.get(i),""+(i+1));
+	        }
+	    }
+
+	    /**
+	     * 测试在list的任意索引处添加元素
+	     */
+	    @Test
+	    public void testAddIntT() {
+	        assertEquals("init list size is 0  ", list.size(), 0);
+	        list.add("1");
+	        list.add("3");
+	        list.add(1,"2");
+	        assertEquals("add list size ", list.size(), 3);
+	        assertEquals("add index 1 element is" ,list.get(1),"2");
+	        for (int i=0; i<list.size(); i++) {
+	            assertEquals("index of"+i,list.get(i),""+(i+1));
+	        }
+	    }
+
+	    @Test
+	    public void testDelete() {
+	        assertEquals("init list size is 0  ", list.size(), 0);
+	        list.add("1");
+	        list.add("3");
+	        list.add(1,"2");
+	        assertEquals("add list size ", list.size(), 3);
+	        list.delete(1);
+	        assertEquals("after delete index 1 ",list.get(1),"3");
+	    }
+
+	    @Test
+	    public void testGet() {
+	        assertEquals("init list size is 0  ", list.size(), 0);
+	        list.add("1");
+	        list.add("2");
+	        list.add("3");
+	        for(int i=0; i<list.size();i++) {
+	            assertEquals("index of"+i,list.get(i),""+(i+1));
+	        }
+	    }
+
+	    @Test
+	    public void testSet() {
+	        assertEquals("init list size is 0  ", list.size(), 0);
+	        list.add("1");
+	        list.add("3");
+	        list.add("3");
+	        list.set(1, "2");
+	        for(int i=0; i<list.size();i++) {
+	            assertEquals("index of"+i,list.get(i),""+(i+1));
+	        }
+	    }
+
+	    @Test
+	    public void testSize() {
+	        assertEquals("init list size is 0  ", list.size(), 0);
+	        list.add("1");
+	        list.add("3");
+	        list.add("3");
+	        assertEquals("after add list size is ", list.size(),3);
+	    }
+
+	    /**
+	     * 正确的判空用例
+	     */
+	    @Test
+	    public void testIsEmpty() {
+	       assertEquals("list is empty", list.isEmpty(),true);
+	    }
+
+	    /**
+	     * 失败的判空用例
+	     */
+	    @Test
+	    public void testIsEmptyNot() {
+	        list.add("1");
+	        assertEquals("list is empty", list.isEmpty(),false);
+	    }
+}
diff --git a/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyLinkedListTest.java b/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyLinkedListTest.java
new file mode 100644
index 0000000000..ac99458814
--- /dev/null
+++ b/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyLinkedListTest.java
@@ -0,0 +1,121 @@
+package com.github.lhpmatlab.coding2017.basic; 
+
+import org.junit.Test; 
+import org.junit.Before; 
+import org.junit.After;
+
+import java.util.LinkedList;
+
+import static org.junit.Assert.assertEquals;
+
+/** 
+* MyLinkedList Tester. 
+* 
+* @author <Authors name> 
+* @since <pre>���� 26, 2017</pre> 
+* @version 1.0 
+*/ 
+public class MyLinkedListTest {
+    private MyLinkedList<String> linkedList;
+
+    @Before
+    public void before() throws Exception {
+        linkedList = new MyLinkedList<>();
+    }
+
+    @After
+    public void after() throws Exception {
+    }
+
+    /**
+    *
+    * Method: add(T t)
+    *
+    */
+    @Test
+    public void testAddT() throws Exception {
+        assertEquals("init list size is 0  ", linkedList.size(), 0);
+        linkedList.add("1");
+        linkedList.add("2");
+        assertEquals("add list size ", linkedList.size(), 2);
+        for (int i=0; i<linkedList.size(); i++) {
+            assertEquals("index of"+i,linkedList.get(i),""+(i+1));
+        }
+    }
+
+    /**
+    *
+    * Method: add(int index, T element)
+    *
+    */
+    @Test
+    public void testAddForIndexElement() throws Exception {
+//        linkedList.add("1");
+//        linkedList.add("3");
+//        linkedList.add(1,"2");
+//        assertEquals("add list size ", linkedList.size(), 3);
+//        for (int i=0; i<linkedList.size(); i++) {
+//            assertEquals("index of"+i,linkedList.get(i),""+(i+1));
+//        }
+    }
+
+    /**
+    *
+    * Method: get(int index)
+    *
+    */
+    @Test
+    public void testGet() throws Exception {
+        linkedList.add("1");
+        linkedList.add("2");
+        assertEquals("get methos; ",linkedList.get(0),"1" );
+    }
+
+    /**
+    *
+    * Method: set(int index, T newValue)
+    *
+    */
+    @Test
+    public void testSet() throws Exception {
+        linkedList.add("1");
+        linkedList.add("2");
+        linkedList.set(1, "3");
+        assertEquals("set mehtod ", linkedList.get(1),"3");
+    }
+
+    /**
+    *
+    * Method: remove(int index)
+    *
+    */
+    @Test
+    public void testRemove() throws Exception {
+        linkedList.add("1");
+        linkedList.add("2");
+        linkedList.remove(0);
+        assertEquals("remove methos", linkedList.size(),1);
+    }
+
+    /**
+    *
+    * Method: size()
+    *
+    */
+    @Test
+    public void testSize() throws Exception {
+    //TODO: Test goes here...
+    }
+
+    /**
+    *
+    * Method: isEmpty()
+    *
+    */
+    @Test
+    public void testIsEmpty() throws Exception {
+        assertEquals("isEmpth method ", linkedList.isEmpty(),true);
+    }
+
+
+} 
diff --git a/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyQueueTest.java b/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyQueueTest.java
new file mode 100644
index 0000000000..ad1a09dbab
--- /dev/null
+++ b/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyQueueTest.java
@@ -0,0 +1,71 @@
+package com.github.lhpmatlab.coding2017.basic; 
+
+import org.junit.Test; 
+import org.junit.Before; 
+import static  org.junit.Assert.*;
+
+/** 
+* MyQueue Tester. 
+* 
+* @author <Authors name> 
+* @since <pre>���� 26, 2017</pre> 
+* @version 1.0 
+*/ 
+public class MyQueueTest {
+    private MyQueue<String> queue;
+
+    @Before
+    public void init() throws Exception {
+        queue = new MyQueue<>();
+    }
+
+    /**
+    *
+    * Method: enQueue(T t)
+    *
+    */
+    @Test
+    public void testEnQueue() throws Exception {
+        queue.enQueue("1");
+        assertEquals("size ", queue.size(), 1);
+    }
+
+    /**
+    *
+    * Method: deQueue()
+    *
+    */
+    @Test
+    public void testDeQueue() throws Exception {
+        queue.enQueue("1");
+        queue.enQueue("2");
+//        queue.deQueue();
+        assertEquals("dequeue element ",queue.deQueue(),"1");
+        assertEquals("size ", queue.size(), 1);
+
+    }
+
+    /**
+    *
+    * Method: isEmpty()
+    *
+    */
+    @Test
+    public void testIsEmpty() throws Exception {
+        assertEquals("isEmpty method",queue.isEmpty(),true);
+    }
+
+    /**
+    *
+    * Method: size()
+    *
+    */
+    @Test
+    public void testSize() throws Exception {
+        queue.enQueue("1");
+        queue.enQueue("2");
+        assertEquals("size method", queue.size(),2);
+    }
+
+
+} 
diff --git a/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyStackTest.java b/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyStackTest.java
new file mode 100644
index 0000000000..a90af5d720
--- /dev/null
+++ b/group02/435994736/src/test/java/com/github/lhpmatlab/coding2017/basic/MyStackTest.java
@@ -0,0 +1,104 @@
+package com.github.lhpmatlab.coding2017.basic; 
+
+import org.junit.Test; 
+import org.junit.Before; 
+import org.junit.After;
+
+import static org.junit.Assert.*;
+
+/** 
+* MyStack Tester. 
+* 
+* @author <Authors name> 
+* @since <pre>���� 26, 2017</pre> 
+* @version 1.0 
+*/ 
+public class MyStackTest {
+
+    MyStack<String> stack;
+
+
+    @Before
+    public void init() throws Exception {
+        stack = new MyStack<>();
+    }
+
+    @After
+    public void after() throws Exception {
+    }
+
+    /**
+    *
+    * Method: push(T t)
+    *
+    */
+    @Test
+    public void testPush() throws Exception {
+        assertEquals("init stack ", stack.size(), 0);
+        stack.push("1");
+        assertEquals("pust stack ", stack.size(),1);
+    }
+
+    /**
+    *
+    * Method: pop()
+    *
+    */
+    @Test
+    public void testPop() throws Exception {
+        assertEquals("init stack ", stack.size(), 0);
+        stack.push("1");
+        stack.push("2");
+        stack.pop();
+        assertEquals("after pop ",stack.size(),1);
+    }
+
+    /**
+    *
+    * Method: peek()
+    *
+    */
+    @Test
+    public void testPeek() throws Exception {
+        assertEquals("init stack ", stack.size(), 0);
+        stack.push("1");
+        stack.push("2");
+        assertEquals("peek ", stack.peek(),"2");
+    }
+
+    /**
+    *测试判空方法
+    * Method: isEmpty()
+    *
+    */
+    @Test
+    public void testIsEmpty() throws Exception {
+        assertEquals("stack is empty ", stack.isEmpty(), true);
+    }
+
+    /**
+     *测试判空方法,不为空的情况
+     * Method: isEmpty()
+     *
+     */
+    @Test
+    public void testIsNotEmpty() throws Exception {
+        stack.push("1");
+        assertEquals("stack is empty ", stack.isEmpty(), false);
+    }
+
+    /**
+    *
+    * Method: size()
+    *
+    */
+    @Test
+    public void testSize() throws Exception {
+        assertEquals("init stack ", stack.size(), 0);
+        stack.push("1");
+        stack.push("2");
+        assertEquals("size is 2", stack.size(), 2);
+    }
+
+
+} 
diff --git a/group02/527705641/.gitignore b/group02/527705641/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group02/527705641/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/ArrayList.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/ArrayList.java
new file mode 100644
index 0000000000..855e25b257
--- /dev/null
+++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/ArrayList.java
@@ -0,0 +1,71 @@
+package com.github.fei9009.coding2017.basic;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	private int capacity;
+	
+	private Object[] elementData = new Object[100];
+	
+	public ArrayList() {
+		this.capacity = 20;
+	}
+	
+	private void extend() {
+		Object[] updatedElementData = new Object[this.elementData.length + this.capacity];
+		System.arraycopy(this.elementData, 0, updatedElementData, 0, this.elementData.length);
+		this.elementData = updatedElementData;
+	}
+	
+	public void add(Object o){
+		if (this.size == elementData.length) {
+			extend();
+		}
+		elementData[size] = o;
+		this.size++;
+	}
+	
+	public void add(int index, Object o){
+		if (this.size == elementData.length) {
+			extend();
+		}
+		int i;
+		for (i = this.size - 1; i >= index; i--) {
+			this.elementData[i + 1] = this.elementData[i];
+		}
+		this.elementData[i + 1] = o;
+		this.size++;
+	}
+	
+	public Object get(int index){
+		if (index >= 0 && index < this.size) {
+			return this.elementData[index];
+		}else {
+			return null;
+		}
+	}
+	
+	public Object remove(int index){
+		if (index >= 0 && index < this.size) {
+			int i = 0;
+			Object deletedElement = this.elementData[index];
+			for (i = index + 1; i < this.size; i++) {
+				this.elementData[i - 1] = this.elementData[i]; 
+			}
+			this.elementData[i] = null;
+			this.size--;
+			return deletedElement;
+		}else {
+			return null;
+		}
+	}
+	
+	public int size(){
+		return this.size;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+	
+}
diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/ArrayListTest.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/ArrayListTest.java
new file mode 100644
index 0000000000..d623dd05e0
--- /dev/null
+++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/ArrayListTest.java
@@ -0,0 +1,55 @@
+package com.github.fei9009.coding2017.basic;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class ArrayListTest {
+
+	private static ArrayList testArray = new ArrayList();
+	@Before
+	public void setUp() throws Exception {
+		//testArray.clear();
+	}
+
+	@Test
+	public void testArrayList() {
+		//fail("Not yet implemented");
+	}
+
+	@Test
+	public void testAddObject() {
+		testArray.add(10);
+		assertEquals(10, testArray.get(0));
+		//fail("Not yet implemented");
+	}
+
+	@Test
+	public void testAddIntObject() {
+		testArray.add(10);
+		testArray.add(0, 3);
+		testArray.add(0, 2);
+		assertEquals(3, testArray.get(1));
+		assertEquals(2, testArray.get(0));
+		//fail("Not yet implemented");
+	}
+
+	@Test
+	public void testGet() {
+		testArray.add(10);
+		assertEquals(10, testArray.get(0));
+		//fail("Not yet implemented");
+	}
+
+	@Test
+	public void testRemove() {
+		fail("Not yet implemented");
+	}
+
+	@Test
+	public void testSize() {
+		fail("Not yet implemented");
+	}
+
+}
diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/BinaryTreeNode.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..6dbc7ee012
--- /dev/null
+++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/BinaryTreeNode.java
@@ -0,0 +1,57 @@
+package com.github.fei9009.coding2017.basic;
+
+public class BinaryTreeNode <Object extends Comparable<Object>> {
+	
+	private Object data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+	
+	public BinaryTreeNode(Object o) {
+		data = o;
+		left = null;
+		right = null;
+	}
+	
+	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){
+		BinaryTreeNode node = new BinaryTreeNode(o);
+		boolean left = true;
+		BinaryTreeNode cur = this;
+		BinaryTreeNode pre = null;
+		while (cur != null) {
+			pre = cur;
+			if (node.getData().compareTo(cur.getData()) <= 0) {
+				cur = cur.left;
+				left = true;
+			} else {
+				cur = cur.right;
+				left = false;
+			}
+		}
+		if(left) {
+			pre.left = node;
+		} else {
+			pre.right = node;
+		}
+		return node;
+	}
+	
+}
diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/Iterator.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/Iterator.java
new file mode 100644
index 0000000000..e2f03b8247
--- /dev/null
+++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/Iterator.java
@@ -0,0 +1,7 @@
+package com.github.fei9009.coding2017.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/LinkedList.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/LinkedList.java
new file mode 100644
index 0000000000..1ed5923ee9
--- /dev/null
+++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/LinkedList.java
@@ -0,0 +1,91 @@
+package com.github.fei9009.coding2017.basic;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	private int size;
+	
+	public void add(Object o){
+		add(size, o);
+	}
+	
+	public void add(int index , Object o){
+		if (index > this.size || index < 0) {
+			throw new IndexOutOfBoundsException("index " + index + "beyond the size " + size );
+		}
+		Node dummy = node(index);
+		Node newNode = new Node(o);
+		newNode.next = dummy;
+		if (index == 0) {
+			head = newNode;
+		}
+		else {
+			Node before = node(index-1);
+			before.next = newNode;
+		}
+		this.size++;
+		
+	}
+	
+	public Object get(int index){
+		if (index >= this.size || index < 0) {
+			throw new IndexOutOfBoundsException("index " + index + "beyond the size " + size );
+		}
+		Node node = node(index);
+		return node.data;
+		
+	}
+	public Object remove(int index){
+		if (index >= this.size || index < 0) {
+			throw new IndexOutOfBoundsException("index " + index + "beyond the size " + size );
+		}
+		Node delNode = node(index);
+		if (index == 0)
+			head = delNode.next;
+		else {
+			Node before = node(index-1);
+			before.next = delNode.next;
+		}
+		size--;
+		return delNode.data;
+	}
+	
+	public int size(){
+		return this.size;
+	}
+	
+	public void addFirst(Object o){
+		add(0, o);
+	}
+	public void addLast(Object o){
+		add(o);
+	}
+	public Object removeFirst(){
+		return remove(0);
+	}
+	
+	public Object removeLast(){
+		return remove(this.size -1);
+	}
+	public Iterator iterator(){
+		return null;
+	}
+	
+	Node node(int index) {
+		Node x = head;
+		for (int i=0; i<index; i++) {
+			x = x.next;
+		}
+		return x;
+	}
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		Node(Object o) {
+			this.data = o;
+			this.next = null;
+		}
+		
+	}
+}
diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/LinkedListTest.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/LinkedListTest.java
new file mode 100644
index 0000000000..1eb379a020
--- /dev/null
+++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/LinkedListTest.java
@@ -0,0 +1,92 @@
+package com.github.fei9009.coding2017.basic;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class LinkedListTest {
+
+private LinkedList aLinkedList;
+	
+	@Before
+	public void setUpLinkedList() {
+		aLinkedList = new LinkedList();
+	}
+
+	@Test
+	public void testAddFirst() {
+		aLinkedList.addFirst(5);
+		assertEquals(5, aLinkedList.get(0));
+		
+		aLinkedList.addFirst(6);
+		assertEquals(6, aLinkedList.get(0));
+		assertEquals(5, aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+	@Test
+	public void testAddLast() {
+		aLinkedList.addLast("hello");
+		assertEquals("hello", aLinkedList.get(0));
+		
+		aLinkedList.addLast("world");
+		assertEquals("hello", aLinkedList.get(0));
+		assertEquals("world", aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+	@Test
+	public void testRemoveFirst() {
+		aLinkedList.addLast("hello");
+		aLinkedList.addLast("world");
+		
+		aLinkedList.removeFirst();
+		assertEquals("world", aLinkedList.get(0));
+		assertEquals(1, aLinkedList.size());
+		
+		aLinkedList.removeFirst();
+		assertEquals(0, aLinkedList.size());
+	}
+	
+	@Test
+	public void testRemoveLast() {
+		aLinkedList.addFirst("world");
+		aLinkedList.addFirst("hello");
+		
+		aLinkedList.removeLast();
+		assertEquals("hello", aLinkedList.get(0));
+		assertEquals(1, aLinkedList.size());
+		
+		aLinkedList.removeLast();
+		assertEquals(0, aLinkedList.size());
+	}
+	
+	@Test
+	public void testLinkedListFunctional() {
+		for (int i=1; i<4; i++) {
+			aLinkedList.add(i);  // [1,2,3]
+		}
+		aLinkedList.remove(1);  // [1,3]
+		
+		aLinkedList.add(1, 0);  // [1,0,3]
+		for (int i=4; i<6; i++) {
+			aLinkedList.addFirst(i);  // [5, 4, 1, 0, 3]
+		}
+		assertEquals(5, aLinkedList.size());
+		assertEquals(5, aLinkedList.get(0));
+		assertEquals(1, aLinkedList.get(2));
+		assertEquals(0, aLinkedList.get(3));
+		
+		aLinkedList.remove(3);  // [5, 4, 1, 3]
+		assertEquals(3, aLinkedList.get(aLinkedList.size()-1));
+		aLinkedList.removeLast();  // [5, 4, 1]
+		assertEquals(1, aLinkedList.get(aLinkedList.size()-1));
+		aLinkedList.removeFirst();   // [4,1]
+		
+		assertEquals(4, aLinkedList.get(0));
+		assertEquals(1, aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+
+}
diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/List.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/List.java
new file mode 100644
index 0000000000..a5500db4f8
--- /dev/null
+++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/List.java
@@ -0,0 +1,9 @@
+package com.github.fei9009.coding2017.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/group02/527705641/src/com/github/fei9009/coding2017/basic/Queue.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/Queue.java
new file mode 100644
index 0000000000..b5a65964ee
--- /dev/null
+++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/Queue.java
@@ -0,0 +1,21 @@
+package com.github.fei9009.coding2017.basic;
+
+public class Queue {
+	private ArrayList elementData = new ArrayList();
+	
+	public void enQueue(Object o){		
+		elementData.add(o);
+	}
+	
+	public Object deQueue(){
+		return elementData.remove(0);
+	}
+	
+	public boolean isEmpty(){
+		return elementData.size() == 0 ? true : false;
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/QueueTest.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/QueueTest.java
new file mode 100644
index 0000000000..3e2889edc0
--- /dev/null
+++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/QueueTest.java
@@ -0,0 +1,35 @@
+package com.github.fei9009.coding2017.basic;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class QueueTest {
+
+private Queue queue;
+	
+	@Before
+	public void setUpQueue() {
+		queue = new Queue();
+	}
+	
+	@Test
+	public void testQueueFunctional() {
+		assertEquals(true, queue.isEmpty());
+		queue.enQueue(4);
+		queue.enQueue(2);
+		assertEquals(2, queue.size());
+		assertEquals(false, queue.isEmpty());
+		
+		int i = (Integer)queue.deQueue();
+		assertEquals(4, i);
+		i = (Integer)queue.deQueue();
+		assertEquals(2, i);
+		
+		assertEquals(0, queue.size());
+		assertEquals(true, queue.isEmpty());
+	}
+
+
+}
diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/Stack.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/Stack.java
new file mode 100644
index 0000000000..5f10ccd7e9
--- /dev/null
+++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/Stack.java
@@ -0,0 +1,26 @@
+package com.github.fei9009.coding2017.basic;
+
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){		
+		elementData.add(o);
+	}
+	
+	public Object pop(){
+		Object o = elementData.remove(elementData.size() - 1);
+		return o;
+	}
+	
+	public Object peek(){
+		Object o = elementData.get(elementData.size() - 1);
+		return o;
+	}
+	public boolean isEmpty(){
+		return elementData.size() == 0 ? true : false;
+	}
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/StackTest.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/StackTest.java
new file mode 100644
index 0000000000..2872efb3e3
--- /dev/null
+++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/StackTest.java
@@ -0,0 +1,37 @@
+package com.github.fei9009.coding2017.basic;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class StackTest {
+
+private Stack stack;
+	
+	@Before
+	public void setUpStack() {
+		stack = new Stack();
+	}
+
+	@Test
+	public void testStackFunctional() {
+		assertEquals(true, stack.isEmpty());
+		stack.push(4);
+		stack.push(2);
+		assertEquals(2, stack.size());
+		assertEquals(false, stack.isEmpty());
+		
+		int i = (Integer)stack.pop();
+		assertEquals(2, i);
+		
+		i = (Integer)stack.peek();
+		assertEquals(4, i);
+		
+		i = (Integer)stack.pop();
+		assertEquals(4, i);
+		
+		assertEquals(0, stack.size());
+		assertEquals(true, stack.isEmpty());
+	}
+}
diff --git a/group02/562768642/src/com/github/orajavac/coding2017/basic/ArrayList.java b/group02/562768642/src/com/github/orajavac/coding2017/basic/ArrayList.java
new file mode 100644
index 0000000000..73ac68069d
--- /dev/null
+++ b/group02/562768642/src/com/github/orajavac/coding2017/basic/ArrayList.java
@@ -0,0 +1,101 @@
+package com.github.orajavac.coding2017.basic;
+
+public class ArrayList implements List,Iterator{
+	
+	private int size = 0;
+	
+	private int i=0;
+	
+	private Object[] elementData = new Object[2];
+	
+	//SS
+	public void add(Object o){
+		size=size();
+		if (size == elementData.length)
+			grow(elementData,size);
+		elementData[size]=o;
+	}
+	public void add(int index, Object o){
+		Object old=elementData[index];	//[3] old value=c
+		size=size();
+		size+=1;
+		if (size>elementData.length)
+			grow(elementData,size);
+		Object temp = null;
+		int len=elementData.length;
+		for (int i=0;i<len;i++){
+			if (i==index){
+				elementData[index]=o;
+			}else if(i>index){
+				temp=elementData[i];
+				elementData[i]=old;	//[4]=c
+				old=temp;
+			}
+		}
+	}
+	
+	public Object get(int index){
+		return elementData[index];
+	}
+	
+	public Object remove(int index){
+		if (index==elementData.length-1){	//ɾ�����һ������Ԫ�����ֵ
+			elementData[index]=null;
+		}else{
+			elementData[index]=null;
+			int len=elementData.length;
+			for (int i=0;i<len;i++){
+				if (i==index){
+					elementData[i]=elementData[i+1];
+				}else if(i>index){
+					if(i+1!=len){
+						elementData[i]=elementData[i+1];
+					}else{	//���Ǽ����������� 0-3����ô���鳤����4��3+1==4��elementData[i+1]�ᱨ��
+						elementData[i]=null;
+					}
+				}
+			}
+		}
+		return null;
+	}
+	
+	public int size(){
+		size=0;
+		for (int i=0;i<elementData.length;i++){
+			if (elementData[i]!=null){
+				size++;
+			}
+		}
+		return size;
+	}
+	
+	public void grow(Object[] elementData,int size){
+		Object[] target = new Object[size+elementData.length];
+		System.arraycopy(elementData, 0, target, 0, elementData.length);
+		this.elementData=target;
+	}
+	
+	public Iterator iterator(){
+		ArrayList l = new ArrayList();
+		l.elementData=this.elementData;
+		l.size=this.size();
+		return l;
+	}
+	
+	
+	
+	public boolean hasNext(){
+		if (i<=size-1){
+			return true;
+		}else{
+			i=0;
+		}
+		return false;
+	}
+	
+	public Object next(){
+		Object obj=elementData[i];
+		i++;
+		return obj;
+	}
+}
diff --git a/group02/562768642/src/com/github/orajavac/coding2017/basic/BinaryTreeNode.java b/group02/562768642/src/com/github/orajavac/coding2017/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..65ef21a344
--- /dev/null
+++ b/group02/562768642/src/com/github/orajavac/coding2017/basic/BinaryTreeNode.java
@@ -0,0 +1,32 @@
+package com.github.orajavac.coding2017.basic;
+
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git a/group02/562768642/src/com/github/orajavac/coding2017/basic/Iterator.java b/group02/562768642/src/com/github/orajavac/coding2017/basic/Iterator.java
new file mode 100644
index 0000000000..7c7072a614
--- /dev/null
+++ b/group02/562768642/src/com/github/orajavac/coding2017/basic/Iterator.java
@@ -0,0 +1,7 @@
+package com.github.orajavac.coding2017.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group02/562768642/src/com/github/orajavac/coding2017/basic/LinkedList.java b/group02/562768642/src/com/github/orajavac/coding2017/basic/LinkedList.java
new file mode 100644
index 0000000000..da145e33fb
--- /dev/null
+++ b/group02/562768642/src/com/github/orajavac/coding2017/basic/LinkedList.java
@@ -0,0 +1,110 @@
+package com.github.orajavac.coding2017.basic;
+
+public class LinkedList implements List,Iterator {
+	
+private Node head;
+
+private Node current;
+	
+	private int size=0;
+	
+	public void add(Object o){
+		Node n = new Node();
+		n.next=this.head;
+		n.data=o;
+		this.head=n;
+	}
+	public void add(int index , Object o){
+		
+	}
+	public Object get(int index){
+		Node c = this.head;
+		int i=0;
+		while(c!=null){
+			i++;
+			if (index==i){
+				return c.data;
+			}
+			c=c.next;
+		}
+		return null;
+	}
+	public Object remove(int index){
+		return null;
+	}
+	
+	public int size(){
+		size=0;
+		Node c = this.head;
+		while(c!=null){
+			size++;
+			c=c.next;
+		}
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		if (this.head==null){
+			this.head = new Node();
+			this.head.data=o;
+		}
+	}
+	public void addLast(Object o){
+		add(o);
+	}
+	public Object removeFirst(){
+		int s=size();
+		int index=0;
+		Node c = this.head;
+		while(c!=null){
+			index=s--;
+			if (index==2){
+				System.out.println(c.next.data);
+				
+				break;
+			}
+			c=c.next;
+		}
+		return null;
+	}
+	public Object removeLast(){
+		Node e = this.head.next;
+		this.head=null;
+		this.head=e;
+		return null;
+	}
+	
+	public void listNode(){
+		Node c = this.head;
+		while(c!=null){
+			System.out.print(c.data+ " -> ");
+			c=c.next;
+		}
+		System.out.println();
+	}
+	public Iterator iterator(){
+		LinkedList l = new LinkedList();
+		l.head=this.head;
+		return l;
+	}
+	
+	public boolean hasNext(){
+		current = head;
+		if (current!=null){
+			head = current.next;
+			return true;
+		}
+		return false;
+	}
+	
+	public Object next(){
+		return current.data;
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		
+	}
+}
diff --git a/group02/562768642/src/com/github/orajavac/coding2017/basic/List.java b/group02/562768642/src/com/github/orajavac/coding2017/basic/List.java
new file mode 100644
index 0000000000..129333b4da
--- /dev/null
+++ b/group02/562768642/src/com/github/orajavac/coding2017/basic/List.java
@@ -0,0 +1,9 @@
+package com.github.orajavac.coding2017.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/group02/562768642/src/com/github/orajavac/coding2017/basic/Queue.java b/group02/562768642/src/com/github/orajavac/coding2017/basic/Queue.java
new file mode 100644
index 0000000000..772806e391
--- /dev/null
+++ b/group02/562768642/src/com/github/orajavac/coding2017/basic/Queue.java
@@ -0,0 +1,34 @@
+package com.github.orajavac.coding2017.basic;
+
+public class Queue {
+	
+private ArrayList elementData = new ArrayList();
+	
+	public void enQueue(Object o){
+		elementData.add(o);
+	}
+	
+	public Object deQueue(){
+		Object obj = elementData.get(0);
+		elementData.remove(0);
+		return obj;
+	}
+	
+	public ArrayList getElementData() {
+		return elementData;
+	}
+
+	public void setElementData(ArrayList elementData) {
+		this.elementData = elementData;
+	}
+
+	public boolean isEmpty(){
+		if (elementData.size()>0)
+			return true;
+		return false;
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group02/562768642/src/com/github/orajavac/coding2017/basic/Stack.java b/group02/562768642/src/com/github/orajavac/coding2017/basic/Stack.java
new file mode 100644
index 0000000000..62d9f2e278
--- /dev/null
+++ b/group02/562768642/src/com/github/orajavac/coding2017/basic/Stack.java
@@ -0,0 +1,49 @@
+package com.github.orajavac.coding2017.basic;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){		
+		elementData.add(o);
+	}
+	
+	public Object pop(){
+		int s=elementData.size();
+		Object obj = null;
+		for (int i=s-1;i>=0;i--){
+			if(elementData.get(i)!=null){
+				obj = elementData.get(i);
+				elementData.remove(i);
+				break;
+			}
+		}
+		return obj;
+	}
+	
+	public Object peek(){
+		int s=elementData.size();
+		Object obj = null;
+		for (int i=s-1;i>=0;i--){
+			if(elementData.get(i)!=null){
+				obj = elementData.get(i);
+				break;
+			}
+		}
+		return obj;
+	}
+	public boolean isEmpty(){
+		if (elementData.size()>0)
+			return true;
+		return false;
+	}
+	public int size(){
+		return elementData.size();
+	}
+	public ArrayList getElementData() {
+		return elementData;
+	}
+
+	public void setElementData(ArrayList elementData) {
+		this.elementData = elementData;
+	}
+}
diff --git a/group02/609990377/DataStructure/.gitignore b/group02/609990377/DataStructure/.gitignore
new file mode 100644
index 0000000000..fa968c2f2b
--- /dev/null
+++ b/group02/609990377/DataStructure/.gitignore
@@ -0,0 +1,3 @@
+/bin/
+.classpath
+.project
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/ArrayList.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/ArrayList.java
new file mode 100644
index 0000000000..af4588763e
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/ArrayList.java
@@ -0,0 +1,113 @@
+package com.github.congcongcong250.coding2017.basic;
+
+import java.util.Arrays;
+import java.util.InputMismatchException;
+import java.util.NoSuchElementException;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[10];
+	
+	public void add(Object o){
+		
+		//check size limit
+		if(size + 1 > elementData.length){
+			int newlength = elementData.length * 3 / 2 + 1;
+			elementData = Arrays.copyOf(elementData, newlength);
+		}
+		
+		elementData[size++] = o;
+	}
+	
+	public void add(int index, Object o){
+		//index Check
+		checkIndex(index);
+		
+		//check size limit
+		if(size + 1 > elementData.length){
+			int newlength = elementData.length * 3 / 2 + 1;
+			elementData = Arrays.copyOf(elementData, newlength);
+		}
+		
+		for(int i = ++size; i >= index; i-- ){
+			elementData[i] = elementData[i-1];
+		}
+		
+		elementData[index] = o;
+		
+		
+	}
+	
+	public Object get(int index){
+		//index Check
+		checkIndex(index);
+		
+		return elementData[index];
+	}
+	
+	public Object remove(int index){
+		//index Check
+		checkIndex(index);
+		
+		Object old = elementData[index];
+		for(int i = index; i < size-1 ; i++ ){
+			elementData[i] = elementData[i+1];
+		}
+		elementData[--size] = null;
+		return old;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public Iterator iterator(){
+		return new Itr();
+	}
+	
+	public void clear(){
+		elementData = new Object[10];
+		size = 0;
+	}
+	
+	private void checkIndex(int index){
+		if(index >= size || index < 0){
+			throw new IndexOutOfBoundsException("Index:"+index+" Size:"+size);
+		}
+	}
+	
+	
+	private class Itr implements Iterator{
+		//index for next element to visit
+		private int cursor = 0;
+		
+		@Override
+		public boolean hasNext() {
+			return cursor != size;
+		}
+
+		@Override
+		public Object next() {
+			if(cursor >= size){
+				throw new NoSuchElementException();
+			}
+			return elementData[cursor++];
+		}
+
+		@Override
+		public void remove() {
+			//Check bound
+			if(cursor == 0){
+				throw new NoSuchElementException();
+			}
+			
+			ArrayList.this.remove(--cursor);
+			
+		}
+	}
+	
+	
+	
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/BinaryTreeNode.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..9e0e5aa10e
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/BinaryTreeNode.java
@@ -0,0 +1,78 @@
+package com.github.congcongcong250.coding2017.basic;
+
+public class BinaryTreeNode <Object extends Comparable<Object>>{
+	
+	private Object data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+	
+	public BinaryTreeNode(){
+		data = null;
+		left = null;
+		right = null;
+	}
+	
+	public BinaryTreeNode(Object obj){
+		data = obj;
+		left = null;
+		right = null;
+	}
+	
+	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 void destroy(){
+		this.data = null;
+		this.left = null;
+		this.right = null;
+	}
+	
+	public BinaryTreeNode insert(Object o){
+		//If is empty root
+		if(data == null){
+			data = o;
+			return this;
+		}
+
+		//If it is a normal root
+		BinaryTreeNode in;
+		
+		if(o.compareTo(data) <= 0){
+			if(left == null){
+				in = new BinaryTreeNode(o);
+				left = in;
+			}else{
+				in = left.insert(o);
+			}
+		}else{
+			if(right == null){
+				in = new BinaryTreeNode(o);
+				right = in;
+			}else{
+				in = right.insert(o);
+			}
+		}
+		
+		assert (in == null):"Insert error";
+		return in;
+	}
+	
+	
+	
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Iterator.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Iterator.java
new file mode 100644
index 0000000000..9033ad33be
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Iterator.java
@@ -0,0 +1,8 @@
+package com.github.congcongcong250.coding2017.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+	public void remove();
+
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/LinkedList.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/LinkedList.java
new file mode 100644
index 0000000000..640d9ec974
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/LinkedList.java
@@ -0,0 +1,182 @@
+package com.github.congcongcong250.coding2017.basic;
+
+import java.util.NoSuchElementException;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	private int size;
+	
+	public LinkedList(){
+		head = new Node();
+		size = 0;
+	}
+	
+	public void add(Object o){
+		addLast(o);
+	}
+	
+	public void add(int index , Object o){
+		//Check bound
+		checkIndex(index);
+		
+		Node nx = this.find(index);
+		Node pr = nx.previous;
+		Node in = new Node(o,pr,nx);
+		nx.previous = in;
+		pr.next = in;
+		size++;
+	}
+	
+	public Object get(int index){
+		//Check bound
+		checkIndex(index);
+		
+		return this.find(index).data;
+	}
+	
+	public Object remove(int index){
+		//Check bound
+		checkIndex(index);
+		Node rem = this.find(index);
+		
+		Node pr = rem.previous;
+		Node nx = rem.next;
+		pr.next = nx;
+		nx.previous = pr;
+		
+		Object ret = rem.data;
+		rem.previous = null;
+		rem.next = null;
+		rem.data = null;
+		size--;
+		return ret;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		Node nx = head.next;
+		Node in = new Node(o,head, nx);
+		head.next = in;
+		nx.previous = in;
+		size++;
+	}
+	
+	public void addLast(Object o){
+		Node last = head.previous;
+		Node in = new Node(o,last,head);
+		last.next = in;
+		head.previous = in;
+		
+		size++;
+	}
+	public Object removeFirst(){
+		return remove(0);
+	}
+	public Object removeLast(){
+		return remove(size-1);
+	}
+	public Iterator iterator(){
+		return new ListItr();
+	}
+	public void clear(){
+		for (Node x = head; x != null; ) {
+			Node next = x.next;
+			x.data = null;
+			x.next = null;
+            x.previous = null;
+		    x = next;
+		}
+	}
+	
+	private void checkIndex(int index){
+		if(index >= size || index < 0){
+			throw new IndexOutOfBoundsException("Index:"+index+" Size:"+size);
+		}
+	}
+	
+	private Node find(int index){
+		Node tra = head;
+		
+		//If index < size/2
+		if( index < (size >> 1)){
+			for(int i = 0; i <= index; i++){
+				tra = tra.next;
+			}
+		}else{
+			for(int i = size; i > index; i--){
+				tra = tra.previous;
+			}
+		}
+		return tra;
+	}
+	
+	private static class Node{
+		Object data;
+		Node next;
+		Node previous;
+		
+		public Node(){
+			data = null;
+			next = this;
+			previous = this;
+		}
+		
+		public Node(Object obj,Node pre, Node nx){
+			data = obj;
+			next = nx;
+			previous = pre;
+		}
+		
+		
+	}
+	
+	private class ListItr implements Iterator{
+		//Point to next node
+		Node cursor;
+		int nextIndex;
+
+		public ListItr(){
+			cursor = head.next;
+			nextIndex = 0;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			return nextIndex < size;
+		}
+
+		@Override
+		public Object next() {
+			checkBound();
+			Node re = cursor;
+			cursor = cursor.next;
+			nextIndex++;
+			return re.data;
+		}
+		
+		public Object previous() {
+			Node re = cursor.previous.previous;
+			cursor = cursor.previous;
+			nextIndex--;
+			return re.data;
+		}
+
+		@Override
+		public void remove() {
+			//Check bound
+			checkBound();
+			LinkedList.this.remove(--nextIndex);
+			
+		}
+		
+		private void checkBound(){
+			if(nextIndex >= size){
+				throw new NoSuchElementException("Iterates to the end");
+			}
+		}
+	}
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/List.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/List.java
new file mode 100644
index 0000000000..fe05e60f37
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/List.java
@@ -0,0 +1,9 @@
+package com.github.congcongcong250.coding2017.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/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Queue.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Queue.java
new file mode 100644
index 0000000000..0381c65fd8
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Queue.java
@@ -0,0 +1,34 @@
+package com.github.congcongcong250.coding2017.basic;
+
+public class Queue {
+	private LinkedList elementData;
+	
+	public Queue(){
+		elementData = new LinkedList();
+	}
+	
+	public void enQueue(Object o){		
+		elementData.addFirst(o);
+	}
+	
+	public Object deQueue(){
+		Object ret = elementData.removeLast();
+		return ret;
+	}
+	
+	public Object peek(){
+		return elementData.get(elementData.size()-1);
+	}
+	
+	public boolean isEmpty(){
+		return (elementData.size() == 0);
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+	
+	public void clear(){
+		elementData.clear();
+	}
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Stack.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Stack.java
new file mode 100644
index 0000000000..3e411cb0be
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Stack.java
@@ -0,0 +1,32 @@
+package com.github.congcongcong250.coding2017.basic;
+
+public class Stack {
+	private LinkedList elementData = new LinkedList();
+	
+	public Stack(){
+		elementData = new LinkedList();
+	}
+	
+	public void push(Object o){	
+		elementData.addLast(o);
+	}
+	
+	public Object pop(){
+		Object ret = elementData.removeLast();
+		return ret;
+	}
+	
+	public Object peek(){
+		return elementData.get(elementData.size()-1);
+	}
+	public boolean isEmpty(){
+		return (elementData.size() == 0);
+	}
+	public int size(){
+		return elementData.size();
+	}
+	
+	public void clear(){
+		elementData.clear();
+	}
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/ArrayListTest.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/ArrayListTest.java
new file mode 100644
index 0000000000..647a0e9c4e
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/ArrayListTest.java
@@ -0,0 +1,115 @@
+package com.github.congcongcong250.coding2017.basicTest;
+
+import static org.junit.Assert.*;
+
+import java.util.NoSuchElementException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.congcongcong250.coding2017.basic.ArrayList;
+import com.github.congcongcong250.coding2017.basic.Iterator;
+
+public class ArrayListTest implements testCase {
+	
+	ArrayList testlist = new ArrayList();
+	
+	@Override
+	@Before
+	public void setUp() {
+		
+		for(int i = 0; i < 30; i++){
+			testlist.add(i);
+		}
+	}
+
+	@Override
+	@After
+	public void tearDown() {
+		testlist.clear();
+	}
+	
+	@Override
+	@Test
+	public void testAdd() {
+
+		assertEquals(0,testlist.get(0));
+		assertEquals(11,testlist.get(11));
+		assertEquals(20,testlist.get(20));
+		assertEquals(29,testlist.get(29));
+		assertEquals(30,testlist.size());
+		
+		testlist.add(20, 100);
+		assertEquals(100,testlist.get(20));
+		assertEquals(20,testlist.get(21));
+		assertEquals(29,testlist.get(30));
+		assertEquals(31,testlist.size());
+		
+	}
+
+	@Override
+	@Test
+	public void testRemove() {
+
+		
+		assertEquals(6,testlist.get(6));
+		assertEquals(30,testlist.size());
+		testlist.remove(6);
+		assertEquals(7,testlist.get(6));
+		assertEquals(29,testlist.size());
+		assertEquals(21,testlist.get(20));
+		assertEquals(5,testlist.get(5));
+	}
+
+
+	@Test(expected=IndexOutOfBoundsException.class)
+	public void testgetneg(){
+
+	    ArrayList emptyList = new ArrayList();
+	    Object o = emptyList.get(-1);
+	}
+	
+	@Test(expected=IndexOutOfBoundsException.class)
+	public void testgetout(){
+
+	    Object o = testlist.get(31);
+	}
+	
+	@Test(expected=IndexOutOfBoundsException.class)
+	public void testremoveExp(){
+	    Object o = testlist.remove(31);
+	}
+	
+	@Override
+	@Test
+	public void testFunctional() {
+		Iterator itr = testlist.iterator();
+		assertTrue(itr.hasNext());
+		for(int i = 0; i < 20; i++){
+			assertEquals(i, itr.next());
+		}
+		itr.remove();
+		
+		assertTrue(itr.hasNext());
+		assertEquals(20, itr.next());
+		assertEquals(29, testlist.size());
+		
+		for(int i = 21; i < 30; i++){
+			assertEquals(i, itr.next());
+		}
+		assertFalse(itr.hasNext());
+		
+		boolean hasExp = false;
+		try{
+			itr.next();
+		}catch (NoSuchElementException e){
+			hasExp = true;
+		}
+		assertTrue(hasExp);
+	}
+
+	
+
+	
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/BinaryTreeNodeTest.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/BinaryTreeNodeTest.java
new file mode 100644
index 0000000000..f0e7e59ee3
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/BinaryTreeNodeTest.java
@@ -0,0 +1,69 @@
+package com.github.congcongcong250.coding2017.basicTest;
+
+import static org.junit.Assert.*;
+
+import java.util.NoSuchElementException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.congcongcong250.coding2017.basic.BinaryTreeNode;
+
+public class BinaryTreeNodeTest implements testCase {
+
+	BinaryTreeNode node = new BinaryTreeNode();
+	
+	@Override
+	@Before
+	public void setUp() {
+		node.insert(10);
+
+	}
+
+	@Override
+	@After
+	public void tearDown() {
+		node.destroy();
+	}
+
+	@Override
+	@Test
+	public void testAdd() {
+		assertEquals(10,node.getData());
+		node.insert(5);
+		assertEquals(5,node.getLeft().getData());
+		node.insert(1);
+		node.insert(2);
+		node.insert(6);
+		node.insert(19);
+		node.insert(18);
+		/*
+		 *                  10
+		 *          5                19
+		 *    1          6      18  
+		 *        2
+		 * 
+		 * */
+		assertEquals(1,node.getLeft().getLeft().getData());
+		assertEquals(2,node.getLeft().getLeft().getRight().getData());
+		assertEquals(6,node.getLeft().getRight().getData());
+		assertEquals(19,node.getRight().getData());
+		assertEquals(18,node.getRight().getLeft().getData());
+	}
+
+	@Override
+	@Test
+	public void testRemove() {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	@Test
+	public void testFunctional() {
+		// TODO Auto-generated method stub
+
+	}
+
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/LinkedListTest.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/LinkedListTest.java
new file mode 100644
index 0000000000..701bd54402
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/LinkedListTest.java
@@ -0,0 +1,143 @@
+package com.github.congcongcong250.coding2017.basicTest;
+
+import static org.junit.Assert.*;
+
+import java.util.NoSuchElementException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.congcongcong250.coding2017.basic.ArrayList;
+import com.github.congcongcong250.coding2017.basic.LinkedList;
+import com.github.congcongcong250.coding2017.basic.Iterator;
+
+public class LinkedListTest implements testCase {
+	
+	LinkedList testlist = new LinkedList();
+
+	@Override
+	@Before
+	public void setUp() {
+		for(int i = 0; i < 20;i++){
+			testlist.add(i);
+		}
+	}
+
+	@Override
+	@After
+	public void tearDown() {
+		testlist.clear();
+	}
+
+	@Override
+	@Test
+	public void testAdd() {
+		assertEquals(20,testlist.size());
+		assertEquals(0,testlist.get(0));
+		assertEquals(19,testlist.get(19));
+		
+		testlist.add(11, 100);
+		assertEquals(21,testlist.size());
+		assertEquals(5,testlist.get(5));
+		assertEquals(100,testlist.get(11));
+		assertEquals(18,testlist.get(19));
+		
+		testlist.addFirst(200);
+		assertEquals(22,testlist.size());
+		assertEquals(200,testlist.get(0));
+		assertEquals(4,testlist.get(5));
+		assertEquals(100,testlist.get(12));
+		assertEquals(17,testlist.get(19));
+		
+		testlist.addLast(300);
+		assertEquals(23,testlist.size());
+		assertEquals(200,testlist.get(0));
+		assertEquals(4,testlist.get(5));
+		assertEquals(100,testlist.get(12));
+		assertEquals(17,testlist.get(19));
+		assertEquals(300,testlist.get(22));
+
+	}
+
+	@Override
+	@Test
+	public void testRemove() {
+		assertEquals(20,testlist.size());
+		assertEquals(0,testlist.get(0));
+		assertEquals(19,testlist.get(19));
+		
+		testlist.remove(10);
+		assertEquals(19,testlist.size());
+		assertEquals(4,testlist.get(4));
+		assertEquals(9,testlist.get(9));
+		assertEquals(11,testlist.get(10));
+		assertEquals(19,testlist.get(18));
+		
+		testlist.removeFirst();
+		assertEquals(18,testlist.size());
+		assertEquals(1,testlist.get(0));
+		assertEquals(12,testlist.get(10));
+		assertEquals(19,testlist.get(17));
+		
+		testlist.removeLast();
+		assertEquals(17,testlist.size());
+		assertEquals(1,testlist.get(0));
+		assertEquals(12,testlist.get(10));
+		assertEquals(18,testlist.get(16));
+
+	}
+
+	@Test(expected=IndexOutOfBoundsException.class)
+	public void testgetneg(){
+
+	    LinkedList emptyList = new LinkedList();
+	    Object o = emptyList.get(-2);
+	}
+	
+	@Test(expected=IndexOutOfBoundsException.class)
+	public void testgetout(){
+
+	    Object o = testlist.get(31);
+	}
+	
+	@Test(expected=IndexOutOfBoundsException.class)
+	public void testremoveExp(){
+
+	    Object o = testlist.remove(31);
+	}
+	
+	@Override
+	@Test
+	public void testFunctional() {
+		Iterator itr = testlist.iterator();
+		
+		assertTrue(itr.hasNext());
+		for(int i = 0; i < 12; i++){
+			assertEquals(i, itr.next());
+		}
+		
+		//previous() function not yet defined in interface
+		
+		itr.remove();
+		
+		assertTrue(itr.hasNext());
+		assertEquals(12, itr.next());
+		assertEquals(19, testlist.size());
+		
+		for(int i = 13; i < 20; i++){
+			assertEquals(i, itr.next());
+		}
+		assertFalse(itr.hasNext());
+		
+		boolean hasExp = false;
+		try{
+			itr.next();
+		}catch (NoSuchElementException e){
+			hasExp = true;
+		}
+		assertTrue(hasExp);
+
+	}
+
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/QueueTest.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/QueueTest.java
new file mode 100644
index 0000000000..a176a44f2c
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/QueueTest.java
@@ -0,0 +1,76 @@
+package com.github.congcongcong250.coding2017.basicTest;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.congcongcong250.coding2017.basic.Queue;
+
+public class QueueTest implements testCase {
+
+	Queue testqueue = new Queue();
+	
+	@Override
+	@Before
+	public void setUp() {
+		
+		for(int i = 0; i < 20; i++){
+			testqueue.enQueue(i);
+		}
+	}
+
+	@Override
+	@After
+	public void tearDown() {
+		testqueue.clear();
+	}
+	
+
+	@Override
+	@Test
+	public void testAdd() {
+		assertEquals(20,testqueue.size());
+		assertEquals(0,testqueue.peek());
+		assertEquals(20,testqueue.size());
+		assertFalse(testqueue.isEmpty());
+	}
+
+	@Override
+	@Test
+	public void testRemove() {
+		assertEquals(20,testqueue.size());
+		assertEquals(0,testqueue.deQueue());
+		assertEquals(19,testqueue.size());
+		assertEquals(1,testqueue.peek());
+		assertFalse(testqueue.isEmpty());
+	}
+
+	@Override
+	@Test
+	public void testFunctional() {
+		for(int i = 0; i < 20; i++){
+			testqueue.deQueue();
+		}
+		assertTrue(testqueue.isEmpty());
+		testqueue.enQueue(100);
+		testqueue.enQueue(200);
+		assertEquals(100,testqueue.deQueue());
+		testqueue.enQueue(400);
+		assertEquals(200,testqueue.deQueue());
+		assertFalse(testqueue.isEmpty());
+		assertEquals(400,testqueue.deQueue());
+		
+		boolean hasExp = false;
+		try{
+			testqueue.deQueue();
+		}catch (IndexOutOfBoundsException e){
+			hasExp = true;
+		}
+		assertTrue(hasExp);
+	}
+
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/StackTest.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/StackTest.java
new file mode 100644
index 0000000000..9d6085ab03
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/StackTest.java
@@ -0,0 +1,75 @@
+package com.github.congcongcong250.coding2017.basicTest;
+
+import static org.junit.Assert.*;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.congcongcong250.coding2017.basic.Stack;
+
+public class StackTest implements testCase {
+
+	Stack teststack = new Stack();
+	
+	@Override
+	@Before
+	public void setUp() {
+		
+		for(int i = 0; i < 20; i++){
+			teststack.push(i);
+		}
+	}
+
+	@Override
+	@After
+	public void tearDown() {
+		teststack.clear();
+	}
+	
+
+	@Override
+	@Test
+	public void testAdd() {
+		assertEquals(20,teststack.size());
+		assertEquals(19,teststack.peek());
+		assertEquals(20,teststack.size());
+		assertFalse(teststack.isEmpty());
+	}
+
+	@Override
+	@Test
+	public void testRemove() {
+		assertEquals(20,teststack.size());
+		assertEquals(19,teststack.pop());
+		assertEquals(19,teststack.size());
+		assertEquals(18,teststack.peek());
+		assertFalse(teststack.isEmpty());
+	}
+
+	@Override
+	@Test
+	public void testFunctional() {
+		for(int i = 0; i < 20; i++){
+			teststack.pop();
+		}
+		assertTrue(teststack.isEmpty());
+		teststack.push(100);
+		teststack.push(200);
+		assertEquals(200,teststack.pop());
+		teststack.push(400);
+		assertEquals(400,teststack.pop());
+		assertFalse(teststack.isEmpty());
+		assertEquals(100,teststack.pop());
+		
+		
+		boolean hasExp = false;
+		try{
+			teststack.pop();
+		}catch (IndexOutOfBoundsException e){
+			hasExp = true;
+		}
+		assertTrue(hasExp);
+	}
+
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/TestRunner.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/TestRunner.java
new file mode 100644
index 0000000000..c9a623e402
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/TestRunner.java
@@ -0,0 +1,38 @@
+package com.github.congcongcong250.coding2017.basicTest;
+
+
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+
+public class TestRunner {
+
+	public static void main(String[] args){
+		ArrayListTest ALT = new ArrayListTest();
+		test(ALT);
+		
+		LinkedListTest LLT = new LinkedListTest();
+		test(LLT);
+		
+		StackTest STT = new StackTest();
+		test(STT);
+		
+		QueueTest QT = new QueueTest();
+		test(QT);
+		
+		BinaryTreeNodeTest BTNT = new BinaryTreeNodeTest();
+		test(BTNT);
+	    
+	}
+	
+	private static Result test(testCase tc){
+
+		Result result = JUnitCore.runClasses(tc.getClass());
+	    for (Failure failure : result.getFailures()) {
+	    	System.out.println(failure.toString());
+	    }
+	    System.out.println(tc.getClass().toString()+ "\n>>> Test status: "+result.wasSuccessful());
+	    
+	    return result;
+	}
+}
diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/testCase.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/testCase.java
new file mode 100644
index 0000000000..17df6ee30e
--- /dev/null
+++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basicTest/testCase.java
@@ -0,0 +1,21 @@
+package com.github.congcongcong250.coding2017.basicTest;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public interface testCase {
+	@Before
+	public void setUp();
+	
+	@After
+	public void tearDown();
+	
+	@Test
+	public void testAdd();
+	
+	@Test
+	public void testRemove();
+	
+	@Test
+	public void testFunctional();
+}
diff --git a/group02/727171008/.classpath b/group02/727171008/.classpath
new file mode 100644
index 0000000000..3e0fb272a8
--- /dev/null
+++ b/group02/727171008/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group02/727171008/.gitignore b/group02/727171008/.gitignore
new file mode 100644
index 0000000000..0cfebaa908
--- /dev/null
+++ b/group02/727171008/.gitignore
@@ -0,0 +1,19 @@
+/bin/
+.idea/workspace.xml  
+.idea/dictionaries/myj.xml  
+.idea/  
+.DS_Store  
+*.classpath  
+*.project  
+.settings  
+.project  
+.target  
+.classpath  
+**/.settings  
+**/.classpath  
+**/.eclipse  
+**/target/  
+target/  
+bin/  
+.svn  
+*.iml  
\ No newline at end of file
diff --git a/group02/727171008/.project b/group02/727171008/.project
new file mode 100644
index 0000000000..0d10c0ccb2
--- /dev/null
+++ b/group02/727171008/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>727171008Learning</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/ArrayListTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/ArrayListTest.java
new file mode 100644
index 0000000000..0f22f6ba80
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/ArrayListTest.java
@@ -0,0 +1,15 @@
+package com.github.HarryHook.coding2017.basic;
+
+import org.junit.Before;
+import com.github.HarryHook.coding2017.basic.MyArrayList;
+
+
+public class ArrayListTest extends ListTest {
+	
+	@Before
+	public void setUpArrayList() 
+	{
+		aList = new MyArrayList();
+	}
+	
+}
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNode.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..b93790894f
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNode.java
@@ -0,0 +1,121 @@
+/*
+ * Created by Harry 2017-2-23 10:50:39
+ * 实现二叉树,并按二叉查找树插入节点
+ * 
+ */
+package com.github.HarryHook.coding2017.basic;
+
+public class BinaryTreeNode 
+{
+	private Integer data;      
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+
+	//中序遍历二叉树
+	public void inOrder(BinaryTreeNode node)
+	{
+		if(node != null)
+		{
+			inOrder(node.left);
+			System.out.print(" " + node.data);
+			inOrder(node.right);
+		}	
+	}
+	
+	//获取给节点的值
+	public Integer getData() 
+	{
+		return data;
+	}
+	//给一个节点赋值
+	public void setData(Integer 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(Integer obj)
+	{
+		// 新增节点
+        BinaryTreeNode newNode = new BinaryTreeNode();
+        // 当前节点,保留根的值
+        BinaryTreeNode current = this;    
+        // 上个节点
+        BinaryTreeNode parent  = null;
+        // 如果根节点为空
+        if  (current.data == null) 
+        {	
+        	newNode.setData(obj);
+        	newNode.setLeft(null);
+        	newNode.setRight(null);
+            return newNode;
+        }else
+        {
+        	 while (true) 
+             {
+                 parent = current;
+                 if (obj < current.data) 
+                 {
+                     current = current.left;
+                     if (current == null) 
+                     {
+                    	 newNode.setData(obj);
+                     	 newNode.setLeft(null);
+                     	 newNode.setRight(null);
+                         parent.left = newNode;
+                         return newNode;
+                     }
+                 } else 
+                 {
+                     current = current.right;
+                     if (current == null) 
+                     {
+                    	 newNode.setData(obj);
+                     	 newNode.setLeft(null);
+                     	 newNode.setRight(null);
+                         parent.right = newNode;
+                         return newNode;
+                     }
+                 }
+             } 
+        }   
+	}
+
+	public static void main(String[] args)
+	{
+		BinaryTreeNode BTN = new BinaryTreeNode();
+		
+		BTN = BTN.insert(5);
+		System.out.print(BTN.getData() + " ");
+		System.out.print(BTN.insert(2).getData() + " ");
+		System.out.print(BTN.insert(1).getData() + " ");
+		System.out.print(BTN.insert(4).getData() + " ");
+		System.out.print(BTN.insert(6).getData() + " ");
+		System.out.print(BTN.insert(8).getData() + " ");
+		System.out.println("");
+		System.out.println("中序遍历二叉树： ");
+		BTN.inOrder(BTN);	
+	}
+	
+}
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNodeTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNodeTest.java
new file mode 100644
index 0000000000..60d1979713
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNodeTest.java
@@ -0,0 +1,40 @@
+package com.github.HarryHook.coding2017.basic;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.HarryHook.coding2017.basic.BinaryTreeNode;
+
+public class BinaryTreeNodeTest 
+{
+
+	BinaryTreeNode binaryTreeNode;
+
+	@Before
+	public void setUpBinaryTreeNode() 
+	{
+		binaryTreeNode = new BinaryTreeNode();
+	}
+
+	@Test
+	public void testBinaryTreeNodeFunctional() 
+	{
+		binaryTreeNode = binaryTreeNode.insert(4);
+		binaryTreeNode.insert(1);
+		binaryTreeNode.insert(3);
+		binaryTreeNode.insert(5);
+		binaryTreeNode.insert(2);
+		
+		assertEquals(true, 4 == binaryTreeNode.getData());
+		assertEquals(true, 1 == binaryTreeNode.getLeft().getData());
+		assertEquals(true, 5 == binaryTreeNode.getRight().getData());
+		assertEquals(true, 3 == binaryTreeNode.getLeft().getRight().getData());
+		assertEquals(true, 2 == binaryTreeNode.getLeft().getRight().getLeft().getData());
+
+		//节点为空  说明值没有插进去
+		binaryTreeNode.inOrder(binaryTreeNode);
+	}
+
+}
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/Iterator.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/Iterator.java
new file mode 100644
index 0000000000..3fae84a22f
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/Iterator.java
@@ -0,0 +1,7 @@
+package com.github.HarryHook.coding2017.basic;
+
+public interface Iterator
+{
+	public boolean hasNext();
+	public Object next();
+}
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/LinkedListTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/LinkedListTest.java
new file mode 100644
index 0000000000..7c754e37af
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/LinkedListTest.java
@@ -0,0 +1,93 @@
+package com.github.HarryHook.coding2017.basic;
+
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+import com.github.HarryHook.coding2017.basic.MyLinkedList;
+
+public class LinkedListTest extends ListTest{
+
+	private MyLinkedList aLinkedList;
+	
+	@Before
+	public void setUpLinkedList() {
+		aList = new MyLinkedList();
+		aLinkedList = new MyLinkedList();
+	}
+
+	@Test
+	public void testAddFirst() {
+		aLinkedList.addFirst(5);
+		assertEquals(5, aLinkedList.get(0));
+		
+		aLinkedList.addFirst(6);
+		assertEquals(6, aLinkedList.get(0));
+		assertEquals(5, aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+	@Test
+	public void testAddLast() {
+		aLinkedList.addLast("hello");
+		assertEquals("hello", aLinkedList.get(0));
+		
+		aLinkedList.addLast("world");
+		assertEquals("hello", aLinkedList.get(0));
+		assertEquals("world", aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+	@Test
+	public void testRemoveFirst() {
+		aLinkedList.addLast("hello");
+		aLinkedList.addLast("world");
+		
+		aLinkedList.removeFirst();
+		assertEquals("world", aLinkedList.get(0));
+		assertEquals(1, aLinkedList.size());
+		
+		aLinkedList.removeFirst();
+		assertEquals(0, aLinkedList.size());
+	}
+	
+	@Test
+	public void testRemoveLast() {
+		aLinkedList.addFirst("world");
+		aLinkedList.addFirst("hello");
+		
+		aLinkedList.removeLast();
+		assertEquals("hello", aLinkedList.get(0));
+		assertEquals(1, aLinkedList.size());
+		
+		aLinkedList.removeLast();
+		assertEquals(0, aLinkedList.size());
+	}
+	
+	@Test
+	public void testLinkedListFunctional() {
+		for (int i=1; i<4; i++) {
+			aLinkedList.add(i);  // [1,2,3]
+		}
+		aLinkedList.remove(1);  // [1,3]
+		
+		aLinkedList.add(1, 0);  // [1,0,3]
+		for (int i=4; i<6; i++) {
+			aLinkedList.addFirst(i);  // [5, 4, 1, 0, 3]
+		}
+		assertEquals(5, aLinkedList.size());
+		assertEquals(5, aLinkedList.get(0));
+		assertEquals(1, aLinkedList.get(2));
+		assertEquals(0, aLinkedList.get(3));
+		
+		aLinkedList.remove(3);  // [5, 4, 1, 3]
+		assertEquals(3, aLinkedList.get(aLinkedList.size()-1));
+		aLinkedList.removeLast();  // [5, 4, 1]
+		assertEquals(1, aLinkedList.get(aLinkedList.size()-1));
+		aLinkedList.removeFirst();   // [4,1]
+
+		assertEquals(4, aLinkedList.get(0));
+		assertEquals(1, aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+}
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/List.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/List.java
new file mode 100644
index 0000000000..f2299e8e83
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/List.java
@@ -0,0 +1,14 @@
+package com.github.HarryHook.coding2017.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();
+	
+	public Iterator iterator();
+}
+
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/ListTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/ListTest.java
new file mode 100644
index 0000000000..92f84b687c
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/ListTest.java
@@ -0,0 +1,122 @@
+package com.github.HarryHook.coding2017.basic;
+
+import static org.junit.Assert.*;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import com.github.HarryHook.coding2017.basic.Iterator;
+import com.github.HarryHook.coding2017.basic.List;
+
+public class ListTest {
+
+	protected static List aList;
+
+	@Test
+	public void testFunctional() {
+		aList.add(1);
+		aList.add(2);
+		assertEquals(1, aList.get(0));
+		assertEquals(2, aList.get(1));
+		
+		aList.add(3);
+		aList.add(0, 5);
+		aList.add(2, 11);
+		assertEquals(5, aList.get(0));
+		assertEquals(11, aList.get(2));
+		
+		aList.add("hi");
+		assertEquals("hi", aList.get(5));
+		assertEquals(6, aList.size());
+		
+		aList.remove(1);
+		assertEquals(11, aList.get(1));
+		assertEquals(2, aList.get(2));
+		
+		assertEquals(5, aList.size());
+	}
+	
+	@Test
+	public void testAdd() {
+		for (int i=0; i<100; i++)
+			aList.add(i);
+		assertEquals(0, aList.get(0));
+		assertEquals(99, aList.get(99));
+		assertEquals(44, aList.get(44));
+	}
+	
+	@Test
+	public void testRemove() {
+		aList.add(1);
+		aList.add(2);
+		aList.add(3);
+		int u = (Integer)aList.remove(2);
+		assertEquals(3, u);
+		assertEquals(2, aList.size());
+		
+		aList.add(1, 5);
+		u = (Integer)aList.remove(0);
+		assertEquals(1, u);
+		assertEquals(5, aList.get(0));
+		assertEquals(2, aList.get(1));
+		assertEquals(2, aList.size());
+		
+		aList.remove(0);
+		aList.remove(0);
+		assertEquals(0, aList.size());
+		
+
+	}
+	
+	@Test
+	public void testSize() {
+		for (int i=0; i<10; i++)
+			aList.add(i*2);
+		assertEquals(10, aList.size());
+	}
+	
+	@Rule  
+	public ExpectedException expectedEx = ExpectedException.none(); 
+	
+	@Test
+	public void testException() {
+		expectedEx.expect(Exception.class);
+		aList.remove(1);
+		aList.add(3);
+		aList.add(2, 5);
+		expectedEx.expect(Exception.class);
+	}
+	
+	@Test
+	 
+	public void testIterator() 
+	{
+		Iterator it = aList.iterator();
+		assertEquals(false, it.hasNext());
+		
+		aList.add(1);
+		aList.add(2);
+		aList.add(3);
+		
+		it = aList.iterator();
+		assertEquals(true, it.hasNext());
+		assertEquals(1, it.next());
+		assertEquals(2, it.next());
+		assertEquals(3, it.next());
+		assertEquals(false, it.hasNext());
+		
+		aList.remove(1);
+		it = aList.iterator();
+		assertEquals(true, it.hasNext());
+		assertEquals(1, it.next());
+		assertEquals(3, it.next());
+		assertEquals(false, it.hasNext());	
+		
+		expectedEx.expect(Exception.class);
+		it.next();
+		
+	}
+	
+	
+
+}
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyArrayList.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyArrayList.java
new file mode 100644
index 0000000000..dbfd8aae19
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyArrayList.java
@@ -0,0 +1,167 @@
+/*
+ * created by Harry 2017-2-20 18:53:38
+ * 实现简单的ArrayList,具有基本的增删改查功能
+ */
+package com.github.HarryHook.coding2017.basic;
+
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+public class MyArrayList implements List 
+{	
+	private int size = 0;    //数组元素个数
+	
+	private Object[] elementData = new Object[10];  //初始化数组大小为10
+			
+	//将元素添加到数组尾部
+	public void add(Object o)
+	{   //需要判断数组空间是否够用
+		ensureCapacity(size + 1);
+		elementData[size++] = o;
+	}
+	//在指定位置添加元素
+	public void add(int index, Object o)
+	{
+		//判断下标记是否越界		
+		if (index > size || index < 0)
+            throw new IndexOutOfBoundsException(
+            "Index: " + index + ", Size: " + size);
+		ensureCapacity(size + 1);
+		//判断当前位置是否有元素，没有元素添加到当前位置；若有，当前元素及之后元素向右移
+		if(elementData[index] == null)
+		{
+			elementData[index] = o;
+		}
+		else
+		{
+			for(int i=elementData.length-1; i>index; i--)  
+			{
+				elementData[i] = elementData[i-1];
+			} 
+			elementData[index] = o;
+		}  		
+		size++;
+		
+		/*
+		   //判断索引位置是否正确
+        if (index > size || index < 0)
+            throw new IndexOutOfBoundsException(
+            "Index: " + index + ", Size: " + size);
+        //扩容检测
+        ensureCapacity(size+1);  
+        /*
+         * 对源数组进行复制处理（位移），从index + 1到size-index。
+         * 主要目的就是空出index位置供数据插入，
+         * 即向右移动当前位于该位置的元素以及所有后续元素。 
+         
+        System.arraycopy(elementData, index, elementData, index + 1,
+                 size - index);
+        //在指定位置赋值
+        elementData[index] = 0;
+        size++;
+        
+        */
+	}
+	
+	public Object get(int index)
+	{	
+		//若index超出size应该抛出异常
+		if(index >= size)
+			 throw new IndexOutOfBoundsException( "Index: " + index + ", Size: " + size);
+		return  elementData[index];
+		
+	}
+	
+	public Object remove(int index)
+	{	//涉及到元素移位
+		Object oldValue = elementData[index];
+		for(int i=index; i<elementData.length-1; i++)
+			elementData[i] = elementData[i+1];		
+		elementData[--size] = null;
+		
+		return oldValue;
+	}
+	
+	//判断是否需要给数组扩容
+	public void ensureCapacity(int minCapacity)
+	{  
+	    
+	    int oldCapacity = elementData.length;  
+	    if (minCapacity > oldCapacity) 
+	    {  
+	        //Object oldData[] = elementData;   //防止copyof()执行的过程中新内存或者其他进程分配内存时占用旧内存
+	        int newCapacity = (oldCapacity * 3)/2 + 1;  //增加50%+1
+	            if (newCapacity < minCapacity)  
+	                newCapacity = minCapacity;  
+	      // minCapacity is usually close to size, so this is a win:  
+	        elementData = Arrays.copyOf(elementData, newCapacity);  
+	    }  
+	 }
+	
+	//返回数组的大小
+	public int size()
+	{
+		return size;
+	}
+	
+	public Iterator iterator()
+	{
+		return new MyArrayListIterator();
+	}
+	
+	private class MyArrayListIterator implements Iterator
+	{
+		private int cursor = 0;      //记录索引位置         
+		public boolean hasNext()
+		{
+			return cursor != size;    
+		}
+		public Object next() 
+		{  
+			  try { 
+		                Object next = get(cursor);  
+		                cursor++;
+		                return next;
+
+	            } catch (IndexOutOfBoundsException e)
+			  	{
+	                throw new NoSuchElementException();
+	            }
+		
+		}
+	}
+	
+	public static void main(String[] args)
+	{
+		MyArrayList myArrays = new MyArrayList();
+		myArrays.add(3);
+		myArrays.add(0, 11);
+		myArrays.add(1, 2);
+		myArrays.add(3, 5);
+		myArrays.add(2, 1);
+		myArrays.add(7);
+		Print(myArrays);
+		
+		for(int i = 0; i < 19; i++)
+			myArrays.add(i, 55);
+		
+		System.out.println("获取指定位置元素： " + myArrays.get(2));
+		System.out.println("删除指定位置元素： " + myArrays.remove(1));
+		System.out.println("当前元素个数：" + myArrays.size());
+		
+		Print(myArrays);
+			
+	}
+	public static void Print(MyArrayList myArrays)
+	{
+		Iterator it = myArrays.iterator();	
+		System.out.println("对链表中的元素进行打印：");
+		while(it.hasNext())
+			System.out.print(it.next() + " ");
+		System.out.println("");
+		System.out.println("当前元素个数： " + myArrays.size()); 
+
+	}
+	
+}
+
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyLinkedList.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyLinkedList.java
new file mode 100644
index 0000000000..5aeab57496
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyLinkedList.java
@@ -0,0 +1,219 @@
+/*
+ * created by Harry 2017-2-21 14:43:41
+ * 实现简单的LinkedList
+ */
+
+package com.github.HarryHook.coding2017.basic;
+
+public class MyLinkedList implements List 
+{
+	private Node head = null;	//头指针
+	private int size = 0;
+	private static  class Node
+	{
+		Object data;
+		Node next;
+	}
+	public void add(Object o) 
+	{
+		addLast(o);
+	}
+	//在指定位置添加元素
+	public void add(int index , Object o)
+	{
+		
+		if (index > size || index < 0)
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);	
+		//存在插入头结点的情况
+		if(index == 0)
+			addFirst(o);
+		else
+		{		//即 index != 0 的情况
+				// p保存待插入节点的前一节点，x指向要插入的节点
+				Node x = head; 
+				Node p = null;
+				int i = 0;
+				while(i < index)
+				{
+					p = x;
+					x = x.next;
+					i++;
+				}
+				Node n = new Node();
+				p.next = n;
+				n.next = x;
+				n.data = o;	
+				size++;
+		}
+		
+	}
+	//返回指定位置元素
+	public Object get(int index)
+	{
+		Node x = head; 
+		int i = 0;
+		while(i < index && x != null)
+		{
+			x = x.next;
+			i++;
+		}
+		return x.data;
+	}
+	
+	//移除指定位置节点
+	public Object remove(int index)
+	{
+		if (index > size || index < 0)
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+		//先判断是否是头节点
+		if( index == 0)
+		{			
+			return removeFirst();		
+		}
+		else
+		{
+			Node x = head; 
+			Node pre = null;
+			int i = 0;
+			while(i < index)
+			{ 
+				pre = x;
+				x = x.next; 
+				i++;	
+			}
+			Object Data = pre.next.data;
+			pre.next = x.next;
+			x = null;
+			size--;
+			return Data;				
+		}
+
+	}
+	//头部添加节点
+	public void addFirst(Object o)
+	{
+		Node n = new Node();
+		n.next = head;
+		head = n;
+		n.data = o;
+		size++;
+	}
+	//尾部添加节点
+	public void addLast(Object o)
+	{
+		 if (head == null)
+		 {
+			 head = new Node();
+			 head.data = o;
+		 }
+		else
+	    {
+	    	Node x = head; 
+			while(x.next != null)		
+			{
+				x = x.next;
+			}
+			Node n = new Node();
+			x.next = n;
+			n.next = null;
+			n.data = o;
+	    }
+		size++;
+	}
+	//移除第一个节点
+	public Object removeFirst()
+	{
+		Node n = head;
+		Object Data = n.data;
+		head = head.next;
+		n = null;
+		size--;
+		return Data;	
+	}
+	
+	//移除最后一个节点
+	//removeLast()方法存在bug
+	public Object removeLast()
+	{
+		Node x = head; 
+		Node p = null;
+		if(x.next == null)
+		{
+			return removeFirst();
+		}
+		else
+		{
+			while(x.next != null)
+			{
+				p = x;
+				x = x.next;
+			}
+			Object Data = x.data;
+			p.next = null;
+			x = null;       //删除最后一个节点
+			size--;
+			return Data;	
+		}
+	}
+	public int size(){
+		return size;
+	}
+	public Iterator iterator()
+	{
+		return new MyLinkedListIterator();
+	}
+	private class MyLinkedListIterator implements Iterator
+	{
+		private int cursor = 0;      //记录索引位置         
+		public boolean hasNext()
+		{
+			return cursor != size;    
+		}
+		public Object next() 
+		{  
+			Object next = get(cursor);  
+			cursor ++;  
+			return next;  
+		}
+	}
+	public static void main(String[] args)
+	{
+		MyLinkedList myList = new MyLinkedList();
+		myList.add(3);
+		myList.add(5);
+		myList.add(0, 4);
+		myList.add(2, 7);
+		myList.addFirst(1);
+		myList.addLast(6);
+		
+		Print(myList);
+	
+		System.out.println("当前指定位置元素： " + myList.get(1));
+		System.out.println("移除指定位置元素： " + myList.remove(4));
+		Print(myList);
+
+		System.out.println("移除第一个节点元素： " + myList.removeLast());
+		Print(myList);
+		System.out.println("移除最后一个节点元素： " + myList.removeLast());
+		Print(myList);
+		System.out.println("移除最后一个节点元素： " + myList.removeLast());
+		Print(myList);
+		System.out.println("移除最后一个节点元素： " + myList.removeLast());
+		Print(myList);
+		System.out.println("移除最后一个节点元素： " + myList.removeLast());
+		Print(myList);
+
+	}
+	public static void Print(MyLinkedList myList)
+	{
+		Iterator it = myList.iterator();	
+		System.out.println("对链表中的元素进行打印：");
+		while(it.hasNext())
+			System.out.print(it.next() + " ");
+		System.out.println("");
+		System.out.println("当前元素个数： " + myList.size()); 
+		System.out.println("");
+	}
+
+	
+}
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyQueue.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyQueue.java
new file mode 100644
index 0000000000..9b713eaea9
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyQueue.java
@@ -0,0 +1,54 @@
+/*
+ * created by Harry 2017-2-22 13:06:43
+ * 实现简单的队列
+ */
+package com.github.HarryHook.coding2017.basic;
+import java.util.*;
+public class MyQueue 
+{	
+	private MyArrayList elementData = new MyArrayList();
+	private int size = 0;
+	//入队
+	public void enQueue(Object o)
+	{		
+		elementData.add(o);
+		size++;
+	}
+	//出队
+	public Object deQueue()
+	{
+		if(isEmpty())
+			throw new NoSuchElementException();
+		Object Data = elementData.remove(0);
+		size--;
+		return Data;
+	}
+	//判断队列是否为空
+	public boolean isEmpty()
+	{
+		return size() == 0;
+	}
+	//队列中元素个数
+	public int size()
+	{
+		return size;
+	}
+	public static void main(String[] args)
+	{
+		MyQueue mq = new MyQueue();
+		mq.enQueue(1);
+		mq.enQueue(2);
+		mq.enQueue(3);
+		mq.enQueue(4);
+		System.out.println("队列出栈，出栈元素为： " + mq.deQueue());
+		System.out.println("队列中元素个数： " + mq.size());
+		System.out.println("队列出栈，出栈元素为： " + mq.deQueue());
+		System.out.println("队列中元素个数： " + mq.size());
+		System.out.println("队列出栈，出栈元素为： " + mq.deQueue());
+		System.out.println("队列中元素个数： " + mq.size());
+		System.out.println("队列出栈，出栈元素为： " + mq.deQueue());
+		System.out.println("队列中元素个数： " + mq.size());
+		//System.out.println("队列出栈，出栈元素为： " + mq.deQueue());
+		//System.out.println("队列中元素个数： " + mq.size());
+	}
+}
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyStack.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyStack.java
new file mode 100644
index 0000000000..c7f87c04e6
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyStack.java
@@ -0,0 +1,59 @@
+/*
+ * created by Harry 2017-2-22 10:48:34
+ * 实现简单的Stack
+ */
+package com.github.HarryHook.coding2017.basic;
+
+import java.util.*;
+
+public class MyStack 
+{
+	private MyArrayList elementData = new MyArrayList();
+	private int size = 0;
+	
+	//入栈操作
+	public void push(Object o)
+	{		
+		elementData.add(o);
+		size++;
+	}
+	//出栈操作
+	public Object pop()
+	{
+		Object obj = peek();
+		elementData.remove(size() - 1);
+		size--;
+		return obj;
+	}
+	//获取当前栈顶元素，不用出栈
+	public Object peek()
+	{
+		if(isEmpty())
+			throw new EmptyStackException();
+		return elementData.get(size() - 1);
+	}
+	//判断栈是否为空
+	public boolean isEmpty()
+	{
+		return size() == 0;
+	}
+	//返回栈内元素个数
+	public int size(){
+		return size;
+	}
+	
+	public static void main(String[] args)
+	{
+		MyStack ms = new MyStack();
+		
+		ms.push(1);
+		ms.push(2);
+		ms.push(13);
+		System.out.println("当前栈顶元素是: " + ms.peek());
+		System.out.println("出栈元素是: " + ms.pop());
+		System.out.println("出栈元素是: " + ms.pop());
+		ms.push(12);
+		System.out.println("出栈元素是: " + ms.pop());
+		System.out.println("当前栈顶元素是: " + ms.peek());
+	}
+}
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/QueueTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/QueueTest.java
new file mode 100644
index 0000000000..340f79d240
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/QueueTest.java
@@ -0,0 +1,33 @@
+package com.github.HarryHook.coding2017.basic;
+
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+import com.github.HarryHook.coding2017.basic.MyQueue;
+
+public class QueueTest {
+	private MyQueue queue;
+	
+	@Before
+	public void setUpQueue() {
+		queue = new MyQueue();
+	}
+	
+	@Test
+	public void testQueueFunctional() {
+		assertEquals(true, queue.isEmpty());
+		queue.enQueue(4);
+		queue.enQueue(2);
+		assertEquals(2, queue.size());
+		assertEquals(false, queue.isEmpty());
+		
+		int i = (Integer)queue.deQueue();
+		assertEquals(4, i);
+		i = (Integer)queue.deQueue();
+		assertEquals(2, i);
+		
+		assertEquals(0, queue.size());
+		assertEquals(true, queue.isEmpty());
+	}
+
+}
diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/StackTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/StackTest.java
new file mode 100644
index 0000000000..26160faef6
--- /dev/null
+++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/StackTest.java
@@ -0,0 +1,40 @@
+package com.github.HarryHook.coding2017.basic;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.HarryHook.coding2017.basic.MyStack;
+
+public class StackTest {
+
+	private MyStack stack;
+	
+	@Before
+	public void setUpStack() {
+		stack = new MyStack();
+	}
+
+	@Test
+	public void testStackFunctional() {
+		assertEquals(true, stack.isEmpty());
+		stack.push(4);
+		stack.push(2);
+		assertEquals(2, stack.size());
+		assertEquals(false, stack.isEmpty());
+		
+		int i = (Integer)stack.pop();
+		assertEquals(2, i);
+		
+		i = (Integer)stack.peek();
+		assertEquals(4, i);
+		
+		i = (Integer)stack.pop();
+		assertEquals(4, i);
+		
+		assertEquals(0, stack.size());
+		assertEquals(true, stack.isEmpty());
+	}
+
+}
diff --git a/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/Iterator.java b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/Iterator.java
new file mode 100644
index 0000000000..34d062b327
--- /dev/null
+++ b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/Iterator.java
@@ -0,0 +1,7 @@
+package com.github.ZhoufeifeiJAVA.coding2017.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/List.java b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/List.java
new file mode 100644
index 0000000000..7a13f14c83
--- /dev/null
+++ b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/List.java
@@ -0,0 +1,9 @@
+package com.github.ZhoufeifeiJAVA.coding2017.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/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyArrayList.java b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyArrayList.java
new file mode 100644
index 0000000000..0666530694
--- /dev/null
+++ b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyArrayList.java
@@ -0,0 +1,78 @@
+package com.github.ZhoufeifeiJAVA.coding2017.basic;
+
+public class MyArrayList implements List {
+	
+	private int size = 0;
+	 
+	private Object[] elementData = new Object[10];
+	  
+	public void add(Object o){
+		if(size == elementData.length){
+			elementData = arrayGrow(elementData,size/2);
+		}
+		elementData[size] = o;
+		size ++;
+	}
+	public void add(int index, Object o)throws RuntimeException{
+		if(index > size)
+			throw new RuntimeException("index is bigger than the size of MyArrayList");
+		if(size == elementData.length){
+			elementData = arrayGrow(elementData,size/2);
+		}	
+		if(index == size)
+			add(o);
+		else{
+			for(int i=size;i>index;i--){
+				elementData[i] = elementData[i-1];
+			}
+			elementData[index] = o;
+		}	
+		size ++;
+	}
+	private Object[] arrayGrow(Object[] src,int size){
+		Object[] target = new Object[src.length+size];
+		System.arraycopy(src, 0, target, 0, src.length);
+		return target;
+	}
+	public Object get(int index){
+		if(index >= size)
+			return null;
+		else
+			return elementData[index];
+	}
+	
+	public Object remove(int index)throws IndexOutOfBoundsException{
+		if(index>=size || index<0)
+			throw new IndexOutOfBoundsException("index is bigger than the size of MyArrayList");
+		Object removeObject = elementData[index];
+		for(int i=index;i<size-1;i++)
+			elementData[i] = elementData[i+1];				
+		size --;	
+		return removeObject;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	private class MyArrayListIterator implements Iterator{
+		private int pointer;
+		MyArrayListIterator(){
+			pointer = 0;
+		}
+		public boolean hasNext() {
+			if(pointer < size)
+				return true;
+			else
+				return false;
+		}
+		public Object next() {
+			pointer ++;
+			return elementData[pointer-1];
+		}
+		
+	}
+	public Iterator iterator(){
+		return new MyArrayListIterator();
+	}
+}
diff --git a/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyArrayListTest.java b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyArrayListTest.java
new file mode 100644
index 0000000000..886c0094ae
--- /dev/null
+++ b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyArrayListTest.java
@@ -0,0 +1,34 @@
+package com.github.ZhoufeifeiJAVA.coding2017.basic;
+public class MyArrayListTest{
+	public static void main(String[] args){
+		MyArrayList al = new MyArrayList();
+		al.add("string0");
+		al.add("string1");
+		al.add("string2");
+		al.add("string3");
+		al.add("string4");
+		al.add("string5");
+		al.add("string6");
+		al.add("string7");
+		al.add("string8");
+		al.add("string9");
+		al.add("string10");
+		al.add("string11");
+		al.add("string12");
+		al.add("string13");
+		al.add("string14");
+		al.add(11,"string10.5");
+		sop(al.remove(4).toString());
+		sop(al.get(10));
+		sop(al.get(11));
+		sop(al.get(12));
+		sop("the size of al is "+al.size());
+		sop("the iterator method used,so the result is as follows:");
+		for(Iterator it = al.iterator();it.hasNext();){
+			sop(it.next());
+		}
+	}
+	public static void sop(Object o){
+		System.out.println(o);
+	}
+}
\ No newline at end of file
diff --git a/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyLinkedList.java b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyLinkedList.java
new file mode 100644
index 0000000000..eaca2a94b8
--- /dev/null
+++ b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyLinkedList.java
@@ -0,0 +1,127 @@
+package com.github.ZhoufeifeiJAVA.coding2017.basic;
+
+public class MyLinkedList implements List {
+	
+	private Node head,tail;
+	private int size = 0;
+	
+	public void add(Object o){
+		if(size == 0){
+			head = new Node();
+			tail = head;
+			head.data = o;
+		}
+		else{
+			Node newNode = new Node();
+			newNode.data = o;
+			newNode.next = null;
+			tail.next = newNode;
+			tail = newNode;
+		}
+		size ++;
+	}
+	public void add(int index , Object o)throws IndexOutOfBoundsException{
+		if(index>size || index<0)
+			throw new IndexOutOfBoundsException("the index is bigger than the size of MyLinkedList");
+		Node newNode = new Node();
+		newNode.data = o;
+		if(index == 0){
+			newNode.next = head;
+			head = newNode;
+		}
+		else{
+			int i = 0;
+			Node pointer = head;
+			while(i<index-1){
+				i++;
+				pointer = pointer.next;
+			}
+			newNode.next = pointer.next;
+			pointer.next = newNode;	
+		}
+		size++;
+	}
+	public Object get(int index){
+		if(index<0 || index>size-1)
+			return null;
+		Node pointer = head;
+		while(index>0){
+			pointer = pointer.next;
+			index --;
+		}
+		return pointer.data;
+		
+	}
+	public Object remove(int index)throws IndexOutOfBoundsException{
+		if(index<0 || index>size-1)
+			throw new IndexOutOfBoundsException("the index is not legal");
+		Node pointer = head;
+		if(index == 0){
+			head = head.next;
+			size --;
+			return pointer.data;
+		}
+		else{
+			while(index>1){
+				pointer = pointer.next;
+				index --;
+			}
+			Node temp = pointer.next;
+			pointer.next = pointer.next.next;
+			size --;
+			return temp.data;
+		}
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		add(0,o);
+	}
+	public void addLast(Object o){
+		add(size,o);
+	}
+	public Object removeFirst(){
+		return remove(0);
+	}
+	public Object removeLast(){
+		return remove(size-1);
+	}	
+	
+	private static class Node{
+		Object data;
+		Node next;
+	}
+	private class MyLinkedListIterator implements Iterator{
+		private Node pointer;
+		MyLinkedListIterator(){
+			pointer = head;
+		}
+		public boolean hasNext() {
+			if(pointer.next != null)
+				return true;
+			else
+				return false;
+		}
+		public Object next() {
+			Node temp = pointer;
+			pointer = pointer.next;
+			return temp.data;
+		}
+	}
+	public Iterator iterator(){
+		return new MyLinkedListIterator();
+	}
+	//public void showData(int index){
+	//	System.out.println("the data of "+index+" is "+get(index).data);
+	//}
+}
+
+
+
+
+
+
+
diff --git a/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyLinkedListTest.java b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyLinkedListTest.java
new file mode 100644
index 0000000000..6d5ca14e70
--- /dev/null
+++ b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/MyLinkedListTest.java
@@ -0,0 +1,34 @@
+package com.github.ZhoufeifeiJAVA.coding2017.basic;
+public class MyLinkedListTest{
+	public static void main(String[] args){
+		MyLinkedList al = new MyLinkedList();
+		al.add("string0");
+		al.add("string1");
+		al.add("string2");
+		al.add("string3");
+		al.add("string4");
+		al.add("string5");
+		al.add("string6");
+		al.add("string7");
+		al.add("string8");
+		al.add("string9");
+		al.add("string10");
+		al.add("string11");
+		al.add("string12");
+		al.add("string13");
+		al.add("string14");
+		al.add(11,"string10.5");
+		sop(al.remove(4));
+		sop(al.get(10));
+		sop(al.get(11));
+		sop(al.get(12));
+		sop("the size of al is "+al.size());
+		sop("the iterator method used,so the result is as follows:");
+		for(Iterator it = al.iterator();it.hasNext();){
+			sop(it.next());
+		}
+	}
+	public static void sop(Object o){
+		System.out.println(o);
+	}
+}
\ No newline at end of file
diff --git a/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/Queue.java b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/Queue.java
new file mode 100644
index 0000000000..0ce735f150
--- /dev/null
+++ b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/Queue.java
@@ -0,0 +1,26 @@
+package com.github.ZhoufeifeiJAVA.coding2017.basic;
+
+public class Queue {
+	private MyLinkedList llist = null;
+	Queue(){
+		llist = new MyLinkedList();
+	}
+	public void enQueue(Object o){	
+		llist.add(o);
+	}
+	
+	public Object deQueue(){
+		return llist.removeFirst();
+	}
+	
+	public boolean isEmpty(){
+		if(llist.size() != 0)
+			return true;
+		else
+			return false;
+	}
+	
+	public int size(){
+		return llist.size();
+	}
+}
diff --git a/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/QueueTest.java b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/QueueTest.java
new file mode 100644
index 0000000000..95cc5117ff
--- /dev/null
+++ b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/QueueTest.java
@@ -0,0 +1,17 @@
+package com.github.ZhoufeifeiJAVA.coding2017.basic;
+public class QueueTest{
+	public static void sop(Object o){
+		System.out.println(o);
+	}
+	public static void main(String[] args){
+		Queue q = new Queue();
+		q.enQueue("String0");
+		q.enQueue("String1");
+		q.enQueue("String2");
+		sop("the queue is not empty "+q.isEmpty());
+		sop("the size of queue is "+q.size());
+		sop("out queue "+q.deQueue());
+		sop("out queue "+q.deQueue());
+		sop("the size of queue is "+q.size());
+	}
+}
\ No newline at end of file
diff --git a/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/Stack.java b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/Stack.java
new file mode 100644
index 0000000000..3992f89f86
--- /dev/null
+++ b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/Stack.java
@@ -0,0 +1,28 @@
+package com.github.ZhoufeifeiJAVA.coding2017.basic;
+
+public class Stack {
+	private MyLinkedList llist = null;
+	Stack(){
+		llist = new MyLinkedList();
+	}
+	public void push(Object o){	
+		llist.add(o);
+	}
+	
+	public Object pop(){
+		return llist.removeLast();
+	}
+	
+	public Object peek(){
+		return llist.get(llist.size()-1);
+	}
+	public boolean isEmpty(){
+		if(llist.size() != 0)
+			return true;
+		else
+			return false;
+	}
+	public int size(){
+		return llist.size();
+	}
+}
\ No newline at end of file
diff --git a/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/StackTest.java b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/StackTest.java
new file mode 100644
index 0000000000..4bcb60e35d
--- /dev/null
+++ b/group02/793337535/com/github/ZhoufeifeiJAVA/coding2017/basic/StackTest.java
@@ -0,0 +1,17 @@
+package com.github.ZhoufeifeiJAVA.coding2017.basic;
+public class StackTest{
+	public static void sop(Object o){
+		System.out.println(o);
+	}
+	public static void main(String[] args){
+		Stack s = new Stack();
+		s.push("String0");
+		s.push("String1");
+		s.push("String2");
+		sop("the queue is not empty "+s.isEmpty());
+		sop("the size of queue is "+s.size());
+		sop("out queue "+s.pop());
+		sop("just watch queue,not delete "+s.peek());
+		sop("the size of queue is "+s.size());
+	}
+}
\ No newline at end of file
diff --git a/group02/812350401/.gitignore b/group02/812350401/.gitignore
new file mode 100644
index 0000000000..c24866af6d
--- /dev/null
+++ b/group02/812350401/.gitignore
@@ -0,0 +1,3 @@
+/bin/
+/lib/
+/src/java_training
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/ArrayList.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/ArrayList.java
new file mode 100644
index 0000000000..e6bd69b5d8
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/ArrayList.java
@@ -0,0 +1,77 @@
+package com.github.miniyk2012.coding2017.basic;
+
+import java.util.Arrays;
+
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	private int DEFAULT_LENGTH = 10;
+	
+	private Object[] elementData = new Object[DEFAULT_LENGTH];
+	
+	public void add(Object o){
+		ensureCapcacity();
+		elementData[size++] = o;
+	}
+	public void add(int index, Object o){
+		ensurnPosition(index);
+		ensureCapcacity();
+		System.arraycopy(elementData, index, elementData, index + 1,
+                size - index);
+		elementData[index] = o;
+		size++;
+	}
+	
+	public Object get(int index){
+		ensureIndex(index);
+		return elementData[index];
+	}
+	
+	public Object remove(int index){
+		ensureIndex(index);
+		Object temp = elementData[index];
+		System.arraycopy(elementData, index+1, elementData, index,
+                size  - index);
+		size--;
+		return temp;
+	}
+	
+	public void clear() {
+		elementData = new Object[DEFAULT_LENGTH];
+		size = 0;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public Iterator iterator(){
+		Iterator iterator = new IteratorImp(this);
+		return iterator;
+	}
+	
+	private void ensureCapcacity() {
+		int oldLength = elementData.length;
+		if (size+1 > oldLength) {
+			elementData = Arrays.copyOf(elementData, 2*oldLength);
+		}
+	}
+	
+	private void ensureIndex(int index) {
+		if (index >= size || index < 0) 
+			throw new ArrayIndexOutOfBoundsException(String.format("index %d out of bounds [0-%d)", index, size));
+	}
+	
+	private void ensurnPosition(int index) {
+		if (index <0 || index>size)
+			throw new ArrayIndexOutOfBoundsException(String.format("position %d out of position [0-%d)", index, size));
+	}
+	
+	@Override 
+	public String toString() {
+		Object[] tempArray = Arrays.copyOf(elementData, size);
+		return Arrays.toString(tempArray);
+	}
+	
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/BinaryTreeNode.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..5b1f17342b
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/BinaryTreeNode.java
@@ -0,0 +1,55 @@
+package com.github.miniyk2012.coding2017.basic;
+
+public class BinaryTreeNode <E extends Comparable<E>> {
+	private E data;
+	private BinaryTreeNode<E> left;
+	private BinaryTreeNode<E> right;
+	
+	public BinaryTreeNode(E x) {
+		data = x;
+	}
+	public E getData() {
+		return data;
+	}
+	public void setData(E data) {
+		this.data = data;
+	}
+	public BinaryTreeNode<E> getLeft() {
+		return left;
+	}
+	public void setLeft(BinaryTreeNode<E> left) {
+		this.left = left;
+	}
+	public BinaryTreeNode<E> getRight() {
+		return right;
+	}
+	public void setRight(BinaryTreeNode<E> right) {
+		this.right = right;
+	}
+	
+	public BinaryTreeNode<E> insert(E o){
+		BinaryTreeNode<E> node = new BinaryTreeNode<E>(o);
+		boolean left = true; 
+		BinaryTreeNode<E> currentNode = this;
+		BinaryTreeNode<E> previousNode = null;
+		
+		while (currentNode != null) {
+			previousNode = currentNode;
+			int compareTo = node.getData().compareTo(currentNode.getData());
+			if (compareTo <= 0) { // 小于，往左插入
+				currentNode = currentNode.left;
+				left = true;
+			} else {
+				currentNode = currentNode.right;
+				left = false;
+			}
+		}
+		if (left) {
+			previousNode.left = node;
+		} else {
+			previousNode.right = node;
+		}
+		return  node;
+	}
+	
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/Iterator.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/Iterator.java
new file mode 100644
index 0000000000..229ba41b05
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/Iterator.java
@@ -0,0 +1,6 @@
+package com.github.miniyk2012.coding2017.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/IteratorImp.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/IteratorImp.java
new file mode 100644
index 0000000000..cfca8eaac7
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/IteratorImp.java
@@ -0,0 +1,24 @@
+package com.github.miniyk2012.coding2017.basic;
+
+public class IteratorImp implements Iterator {
+
+	private List aList;
+	private int cursor = 0;
+	
+	@Override
+	public boolean hasNext() {
+		return cursor != aList.size();
+	}
+
+	@Override
+	public Object next() {
+		int i = cursor;
+		Object next = aList.get(i);
+		cursor = i+1;
+		return next;
+	}
+	
+	public IteratorImp(List aList) {
+		this.aList = aList;
+	}
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/LinkedList.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/LinkedList.java
new file mode 100644
index 0000000000..e34d76001b
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/LinkedList.java
@@ -0,0 +1,103 @@
+package com.github.miniyk2012.coding2017.basic;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	private int size = 0;
+	
+	/**
+	 * node接收的index一定是范围内的值，不可能越界
+	 * @param index
+	 * @return a Node
+	 */
+	Node node(int index) {
+		Node x = head;
+		for (int i=0; i<index; i++) {
+			x = x.next;
+		}
+		return x;
+	}
+	
+	public void add(Object o){
+		add(size, o);
+	}
+	
+	public void add(int index , Object o){
+		checkPositionIndex(index);
+		Node after = node(index);
+		Node newNode = new Node(o, after);
+		if (index == 0) {
+			head = newNode;
+		}
+		else {
+			Node before = node(index-1);
+			before.next = newNode;
+		}
+		size++;
+	}
+	
+	public Object get(int index){
+		checkElementIndex(index);
+		Node thisNode = node(index);
+		return thisNode.data;
+	}
+	
+	public Object remove(int index){
+		checkElementIndex(index);
+		Node toRemove = node(index);
+		if (index == 0)
+			head = toRemove.next;
+		else {
+			Node before = node(index-1);
+			before.next = toRemove.next;
+		}
+		size--;
+		return toRemove.data;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		add(0, o);
+	}
+	
+	public void addLast(Object o){
+		add(o);
+	}
+	
+	public Object removeFirst(){
+		return remove(0);
+	}
+	
+	public Object removeLast(){
+		return remove(size-1);
+	}
+	
+	public Iterator iterator(){
+		Iterator iterator = new IteratorImp(this);
+		return iterator;
+	}
+	
+	private static class Node{
+		Object data;
+		Node next;
+		
+		Node(){}
+		Node(Object data, Node next) {
+			this.data = data;
+			this.next = next;
+		}
+	}
+	
+	private void checkElementIndex(int index) {
+        if (index < 0 || index >= size)
+            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
+    }
+	
+	private void checkPositionIndex(int index) {
+        if (index < 0 || index > size)
+            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
+    }
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/List.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/List.java
new file mode 100644
index 0000000000..ff6718f462
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/List.java
@@ -0,0 +1,10 @@
+package com.github.miniyk2012.coding2017.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();
+	public Iterator iterator();
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/Queue.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/Queue.java
new file mode 100644
index 0000000000..bcb9d0f9e4
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/Queue.java
@@ -0,0 +1,23 @@
+package com.github.miniyk2012.coding2017.basic;
+
+public class Queue {
+	
+	// 队列入口 -》1，2，3，4 -》队列出口
+	private LinkedList aList = new LinkedList();
+	
+	public void enQueue(Object o){	
+		aList.addFirst(o);
+	}
+	
+	public Object deQueue(){
+		return aList.removeLast();
+	}
+	
+	public boolean isEmpty(){
+		return aList.size() == 0;
+	}
+	
+	public int size(){
+		return aList.size();
+	}
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/Stack.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/Stack.java
new file mode 100644
index 0000000000..ddfe76f774
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/Stack.java
@@ -0,0 +1,25 @@
+package com.github.miniyk2012.coding2017.basic;
+
+public class Stack {
+	
+	// 栈顶  《-》 1，2，3，4 栈底
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){		
+		elementData.add(0, o);
+	}
+	
+	public Object pop(){
+		return elementData.remove(0);
+	}
+	
+	public Object peek(){
+		return elementData.get(0);
+	}
+	public boolean isEmpty(){
+		return elementData.size() == 0;
+	}
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/ArrayListTest.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/ArrayListTest.java
new file mode 100644
index 0000000000..b308c6bfef
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/ArrayListTest.java
@@ -0,0 +1,14 @@
+package com.github.miniyk2012.coding2017.basic.test;
+
+import org.junit.Before;
+import com.github.miniyk2012.coding2017.basic.ArrayList;
+
+
+public class ArrayListTest extends ListTest {
+	
+	@Before
+	public void setUpArrayList() {
+		aList = new ArrayList();
+	}
+	
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/BinaryTreeNodeTest.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/BinaryTreeNodeTest.java
new file mode 100644
index 0000000000..57be8bbfef
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/BinaryTreeNodeTest.java
@@ -0,0 +1,70 @@
+package com.github.miniyk2012.coding2017.basic.test;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import com.github.miniyk2012.coding2017.basic.BinaryTreeNode;
+
+public class BinaryTreeNodeTest {
+
+	private BinaryTreeNode<Integer> binaryTreeNode;
+
+	/**
+		//	    4
+		//	  1   5
+		//  2 	3
+	*/
+	@Before
+	public void setUpBinaryTreeNode() {
+		binaryTreeNode = new BinaryTreeNode<Integer>(4);
+		binaryTreeNode.insert(1);
+		binaryTreeNode.insert(3);
+		binaryTreeNode.insert(5);
+		binaryTreeNode.insert(2);
+	}
+
+	@Test
+	public void testBinaryTreeNodeFunctional1() {
+		assertEquals(new Integer(4), binaryTreeNode.getData());
+		assertEquals(new Integer(1), binaryTreeNode.getLeft().getData());
+		assertEquals(new Integer(5), binaryTreeNode.getRight().getData());
+		assertEquals(new Integer(3), binaryTreeNode.getLeft().getRight().getData());
+		assertEquals(new Integer(2), binaryTreeNode.getLeft().getRight().getLeft().getData());
+	}
+   
+	@Test
+	public void testBinaryTreeFunctional2() {
+		BinaryTreeNode<Integer> node1 = binaryTreeNode.getLeft();
+		assertEquals(new Integer(1), node1.getData());
+		assertEquals(new Integer(3), node1.getRight().getData());
+		assertEquals(new Integer(5), binaryTreeNode.getRight().getData());
+	}
+	
+	@Rule  
+	public ExpectedException expectedEx = ExpectedException.none(); 
+	
+	@Test
+	public void testBinaryTreeFunctional3()
+	{
+		BinaryTreeNode<Integer> treeNode = new BinaryTreeNode<Integer>(100);
+		treeNode.insert(10);
+		binaryTreeNode.setRight(treeNode);
+		//	      4
+		//	   1      100
+		//  2 	  3  10
+		assertEquals(new Integer(4), binaryTreeNode.getData());
+		assertEquals(new Integer(1), binaryTreeNode.getLeft().getData());
+		assertEquals(new Integer(3), binaryTreeNode.getLeft().getRight().getData());
+		assertEquals(new Integer(2), binaryTreeNode.getLeft().getRight().getLeft().getData());	
+		assertEquals(new Integer(100), binaryTreeNode.getRight().getData());
+		assertEquals(new Integer(10), binaryTreeNode.getRight().getLeft().getData());
+		
+		expectedEx.expect(Exception.class);
+		binaryTreeNode.getRight().getRight().getRight();  // null exception
+		binaryTreeNode.getRight().getRight().getLeft();  // null exception
+	}
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/LinkedListTest.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/LinkedListTest.java
new file mode 100644
index 0000000000..487fd2ee00
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/LinkedListTest.java
@@ -0,0 +1,93 @@
+package com.github.miniyk2012.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+import com.github.miniyk2012.coding2017.basic.LinkedList;
+
+public class LinkedListTest extends ListTest{
+
+	private LinkedList aLinkedList;
+	
+	@Before
+	public void setUpLinkedList() {
+		aList = new LinkedList();
+		aLinkedList = new LinkedList();
+	}
+
+	@Test
+	public void testAddFirst() {
+		aLinkedList.addFirst(5);
+		assertEquals(5, aLinkedList.get(0));
+		
+		aLinkedList.addFirst(6);
+		assertEquals(6, aLinkedList.get(0));
+		assertEquals(5, aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+	@Test
+	public void testAddLast() {
+		aLinkedList.addLast("hello");
+		assertEquals("hello", aLinkedList.get(0));
+		
+		aLinkedList.addLast("world");
+		assertEquals("hello", aLinkedList.get(0));
+		assertEquals("world", aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+	@Test
+	public void testRemoveFirst() {
+		aLinkedList.addLast("hello");
+		aLinkedList.addLast("world");
+		
+		aLinkedList.removeFirst();
+		assertEquals("world", aLinkedList.get(0));
+		assertEquals(1, aLinkedList.size());
+		
+		aLinkedList.removeFirst();
+		assertEquals(0, aLinkedList.size());
+	}
+	
+	@Test
+	public void testRemoveLast() {
+		aLinkedList.addFirst("world");
+		aLinkedList.addFirst("hello");
+		
+		aLinkedList.removeLast();
+		assertEquals("hello", aLinkedList.get(0));
+		assertEquals(1, aLinkedList.size());
+		
+		aLinkedList.removeLast();
+		assertEquals(0, aLinkedList.size());
+	}
+	
+	@Test
+	public void testLinkedListFunctional() {
+		for (int i=1; i<4; i++) {
+			aLinkedList.add(i);  // [1,2,3]
+		}
+		aLinkedList.remove(1);  // [1,3]
+		
+		aLinkedList.add(1, 0);  // [1,0,3]
+		for (int i=4; i<6; i++) {
+			aLinkedList.addFirst(i);  // [5, 4, 1, 0, 3]
+		}
+		assertEquals(5, aLinkedList.size());
+		assertEquals(5, aLinkedList.get(0));
+		assertEquals(1, aLinkedList.get(2));
+		assertEquals(0, aLinkedList.get(3));
+		
+		aLinkedList.remove(3);  // [5, 4, 1, 3]
+		assertEquals(3, aLinkedList.get(aLinkedList.size()-1));
+		aLinkedList.removeLast();  // [5, 4, 1]
+		assertEquals(1, aLinkedList.get(aLinkedList.size()-1));
+		aLinkedList.removeFirst();   // [4,1]
+		
+		assertEquals(4, aLinkedList.get(0));
+		assertEquals(1, aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/ListTest.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/ListTest.java
new file mode 100644
index 0000000000..587bf17f4d
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/ListTest.java
@@ -0,0 +1,117 @@
+package com.github.miniyk2012.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import com.github.miniyk2012.coding2017.basic.Iterator;
+import com.github.miniyk2012.coding2017.basic.List;;
+
+public class ListTest {
+	
+	protected static List aList;
+	
+	@Test
+	public void testFunctional() {
+		aList.add(1);
+		aList.add(2);
+		assertEquals(1, aList.get(0));
+		assertEquals(2, aList.get(1));
+		
+		aList.add(3);
+		aList.add(0, 5);
+		aList.add(2, 11);
+		assertEquals(5, aList.get(0));
+		assertEquals(11, aList.get(2));
+		
+		aList.add("hi");
+		assertEquals("hi", aList.get(5));
+		assertEquals(6, aList.size());
+		
+		aList.remove(1);
+		assertEquals(11, aList.get(1));
+		assertEquals(2, aList.get(2));
+		
+		assertEquals(5, aList.size());
+	}
+	
+	@Test
+	public void testAdd() {
+		for (int i=0; i<100; i++)
+			aList.add(i);
+		assertEquals(0, aList.get(0));
+		assertEquals(99, aList.get(99));
+		assertEquals(44, aList.get(44));
+	}
+	
+	@Test
+	public void testRemove() {
+		aList.add(1);
+		aList.add(2);
+		aList.add(3);
+		int u = (Integer)aList.remove(2);
+		assertEquals(3, u);
+		assertEquals(2, aList.size());
+		
+		aList.add(1, 5);
+		u = (Integer)aList.remove(0);
+		assertEquals(1, u);
+		assertEquals(5, aList.get(0));
+		assertEquals(2, aList.get(1));
+		assertEquals(2, aList.size());
+		
+		aList.remove(0);
+		aList.remove(0);
+		assertEquals(0, aList.size());
+		
+
+	}
+	
+	@Test
+	public void testSize() {
+		for (int i=0; i<10; i++)
+			aList.add(i*2);
+		assertEquals(10, aList.size());
+	}
+	
+	@Rule  
+	public ExpectedException expectedEx = ExpectedException.none(); 
+	
+	@Test
+	public void testException() {
+		expectedEx.expect(Exception.class);
+		
+		aList.remove(1);
+		aList.add(3);
+		aList.add(2, 5);
+	}
+	
+	@Test
+	public void testIterator() {
+		Iterator it = aList.iterator();
+		assertEquals(false, it.hasNext());
+		
+		aList.add(1);
+		aList.add(2);
+		aList.add(3);
+		
+		it = aList.iterator();
+		assertEquals(true, it.hasNext());
+		assertEquals(1, it.next());
+		assertEquals(2, it.next());
+		assertEquals(3, it.next());
+		assertEquals(false, it.hasNext());
+		
+		aList.remove(1);
+		it = aList.iterator();
+		assertEquals(true, it.hasNext());
+		assertEquals(1, it.next());
+		assertEquals(3, it.next());
+		assertEquals(false, it.hasNext());	
+		
+		expectedEx.expect(Exception.class);
+		it.next();
+	}
+
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/QueueTest.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/QueueTest.java
new file mode 100644
index 0000000000..67035c1dcf
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/QueueTest.java
@@ -0,0 +1,33 @@
+package com.github.miniyk2012.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+import com.github.miniyk2012.coding2017.basic.Queue;
+
+public class QueueTest {
+	private Queue queue;
+	
+	@Before
+	public void setUpQueue() {
+		queue = new Queue();
+	}
+	
+	@Test
+	public void testQueueFunctional() {
+		assertEquals(true, queue.isEmpty());
+		queue.enQueue(4);
+		queue.enQueue(2);
+		assertEquals(2, queue.size());
+		assertEquals(false, queue.isEmpty());
+		
+		int i = (Integer)queue.deQueue();
+		assertEquals(4, i);
+		i = (Integer)queue.deQueue();
+		assertEquals(2, i);
+		
+		assertEquals(0, queue.size());
+		assertEquals(true, queue.isEmpty());
+	}
+
+}
diff --git a/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/StackTest.java b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/StackTest.java
new file mode 100644
index 0000000000..a9b4e14afd
--- /dev/null
+++ b/group02/812350401/src/com/github/miniyk2012/coding2017/basic/test/StackTest.java
@@ -0,0 +1,40 @@
+package com.github.miniyk2012.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.miniyk2012.coding2017.basic.Stack;
+
+public class StackTest {
+
+	private Stack stack;
+	
+	@Before
+	public void setUpStack() {
+		stack = new Stack();
+	}
+
+	@Test
+	public void testStackFunctional() {
+		assertEquals(true, stack.isEmpty());
+		stack.push(4);
+		stack.push(2);
+		assertEquals(2, stack.size());
+		assertEquals(false, stack.isEmpty());
+		
+		int i = (Integer)stack.pop();
+		assertEquals(2, i);
+		
+		i = (Integer)stack.peek();
+		assertEquals(4, i);
+		
+		i = (Integer)stack.pop();
+		assertEquals(4, i);
+		
+		assertEquals(0, stack.size());
+		assertEquals(true, stack.isEmpty());
+	}
+
+}
diff --git a/group02/851113375/.gitignore b/group02/851113375/.gitignore
new file mode 100644
index 0000000000..fa968c2f2b
--- /dev/null
+++ b/group02/851113375/.gitignore
@@ -0,0 +1,3 @@
+/bin/
+.classpath
+.project
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/ArrayList.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/ArrayList.java
new file mode 100644
index 0000000000..1aa396ce37
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/ArrayList.java
@@ -0,0 +1,91 @@
+
+package com.github.eloiseSJTU.coding2017.basic;
+
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+public class ArrayList implements List {
+
+	private int size = 0;
+
+	private Object[] elementData = new Object[100];
+
+	public void add(Object o) {
+		ensureCapacity(size + 1);
+		
+		elementData[size++] = o;
+	}
+
+	public void add(int index, Object o) {
+		checkBoundsForAdd(index);
+		
+		ensureCapacity(size + 1);
+		
+		if (index < size) {
+			System.arraycopy(elementData, index, elementData, index + 1, size - index);
+		}
+		elementData[index] = o;
+		size++;
+	}
+
+	public Object get(int index) {
+		checkBounds(index);
+		
+		return elementData[index];
+	}
+
+	public Object remove(int index) {
+		checkBounds(index);
+		
+		Object o = elementData[index];
+		System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
+		elementData[--size] = null;
+		return o;
+	}
+
+	public int size() {
+		return size;
+	}
+
+	public Iterator iterator() {
+		return new Itr();
+	}
+	
+	private class Itr implements Iterator {
+		
+		private int cur;
+
+		@Override
+		public boolean hasNext() {
+			return cur != size;
+		}
+
+		@Override
+		public Object next() {
+			if (cur >= size) {
+				throw new NoSuchElementException();
+			}
+			return elementData[cur++];
+		}
+		
+	}
+
+	private void ensureCapacity(int capacity) {
+		if (capacity > elementData.length) {
+			capacity = elementData.length << 1;
+			elementData = Arrays.copyOf(elementData, capacity);
+		}
+	}
+
+	private void checkBounds(int index) {
+		if (index < 0 || index >= size) {
+			throw new IndexOutOfBoundsException();
+		}
+	}
+	
+	private void checkBoundsForAdd(int index) {
+		if (index < 0 || index > size) {
+			throw new IndexOutOfBoundsException();
+		}
+	}
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/BinaryTreeNode.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..9aa88f2155
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/BinaryTreeNode.java
@@ -0,0 +1,72 @@
+package com.github.eloiseSJTU.coding2017.basic;
+
+public class BinaryTreeNode {
+
+	private Integer data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+
+	public BinaryTreeNode() {}
+
+	public BinaryTreeNode(Integer data, BinaryTreeNode left, BinaryTreeNode right) {
+		this.data = data;
+		this.left = left;
+		this.right = right;
+	}
+
+	public Integer getData() {
+		return data;
+	}
+
+	public void setData(Integer 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(Integer o) {
+		if (data == null) {
+			data = o;
+		} else {
+			if (o < data) {
+				if (left == null) {
+					left = new BinaryTreeNode(o, null, null);
+				} else {
+					left = left.insert(o);
+				}
+			} else {
+				if (right == null) {
+					right = new BinaryTreeNode(o, null, null);
+				} else {
+					right = right.insert(o);
+				}
+			}
+		}
+		return this;
+	}
+	
+	public void print() {
+		if (left != null) {
+			left.print();
+		}
+		System.out.println(data);
+		if (right != null) {
+			right.print();
+		}
+	}
+
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/Iterator.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/Iterator.java
new file mode 100644
index 0000000000..c37495db66
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/Iterator.java
@@ -0,0 +1,6 @@
+package com.github.eloiseSJTU.coding2017.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/LinkedList.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/LinkedList.java
new file mode 100644
index 0000000000..19833b1853
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/LinkedList.java
@@ -0,0 +1,170 @@
+package com.github.eloiseSJTU.coding2017.basic;
+
+import java.util.NoSuchElementException;
+
+public class LinkedList implements List {
+
+	private int size = 0;
+	
+	private Node head;
+
+	public void add(Object o) {
+		addLast(o);
+	}
+
+	public void add(int index, Object o) {
+		checkBoundsForAdd(index);
+		
+		if (index == 0) {
+			addFirst(o);
+		} else if (index == size) {
+			addLast(o);
+		} else {
+			Node cur = head;
+			while (--index > 0) {
+				cur = cur.next;
+			}
+			Node newNode = new Node(o, cur.next);
+			cur.next = newNode;
+			size++;
+		}
+	}
+
+	public Object get(int index) {
+		checkBounds(index);
+		
+		Node cur = head;
+		while (index-- > 0) {
+			cur = cur.next;
+		}
+		return cur.data;
+	}
+
+	public Object remove(int index) {
+		checkBounds(index);
+		
+		if (index == 0) {
+			return removeFirst();
+		} else if (index == size - 1) {
+			return removeLast();
+		} else {
+			Node cur = head;
+			int i = 0;
+			while (++i < index) {
+				cur = cur.next;
+			}
+			Node node = cur.next;
+			Object o = node.data;
+			cur.next = node.next;
+			node.data = null;
+			node.next = null;
+			size--;
+			return o;
+		}
+	}
+
+	public int size() {
+		return size;
+	}
+
+	public void addFirst(Object o) {
+		Node newNode = new Node(o, head);
+		head = newNode;
+		size++;
+	}
+
+	public void addLast(Object o) {
+		Node newNode = new Node(o, null);
+		if (head == null) {
+			head = newNode;
+		} else {
+			Node cur = head;
+			while (cur.next != null) {
+				cur = cur.next;
+			}
+			cur.next = newNode;
+		}
+		size++;
+	}
+
+	public Object removeFirst() {
+		if (head == null) {
+			throw new NoSuchElementException();
+		}
+		
+		Object o = head.data;
+		Node node = head.next;
+		head.data = null;
+		head.next = null;
+		head = node;
+		size--;
+		return o;
+	}
+
+	public Object removeLast() {
+		if (head == null) {
+			throw new NoSuchElementException();
+		}
+		
+		if (head.next == null) {
+			return removeFirst();
+		}
+		
+		Node cur = head;
+		int index = 0;
+		while (++index < size - 1) {
+			cur = cur.next;
+		}
+		Object o = cur.next.data;
+		cur.next.data = null;
+		cur.next = null;
+		size--;
+		return o;
+	}
+
+	public Iterator iterator() {
+		return new Itr();
+	}
+	
+	private class Itr implements Iterator {
+		
+		private Node cur = head;
+
+		@Override
+		public boolean hasNext() {
+			return cur != null;
+		}
+
+		@Override
+		public Object next() {
+			if (cur == null) {
+				throw new NoSuchElementException();
+			}
+			Object o = cur.data;
+			cur = cur.next;
+			return o;
+		}
+		
+	}
+
+	private static class Node {
+		Object data;
+		Node next;
+		public Node(Object data, Node next) {
+			this.data = data;
+			this.next = next;
+		}
+	}
+	
+	private void checkBounds(int index) {
+		if (index < 0 || index >= size) {
+			throw new IndexOutOfBoundsException();
+		}
+	}
+	
+	private void checkBoundsForAdd(int index) {
+		if (index < 0 || index > size) {
+			throw new IndexOutOfBoundsException();
+		}
+	}
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/List.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/List.java
new file mode 100644
index 0000000000..2f6bdcc950
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/List.java
@@ -0,0 +1,15 @@
+package com.github.eloiseSJTU.coding2017.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();
+	
+	public Iterator iterator();
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/Queue.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/Queue.java
new file mode 100644
index 0000000000..96e6547548
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/Queue.java
@@ -0,0 +1,28 @@
+package com.github.eloiseSJTU.coding2017.basic;
+
+public class Queue {
+	
+	private int size = 0;
+	
+	private LinkedList elementData = new LinkedList();
+
+	public void enQueue(Object o) {
+		elementData.addLast(o);
+		size++;
+	}
+
+	public Object deQueue() {
+		Object o = elementData.get(0);
+		elementData.removeFirst();
+		size--;
+		return o;
+	}
+
+	public boolean isEmpty() {
+		return size == 0;
+	}
+
+	public int size() {
+		return size;
+	}
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/Stack.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/Stack.java
new file mode 100644
index 0000000000..22b5117842
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/Stack.java
@@ -0,0 +1,31 @@
+package com.github.eloiseSJTU.coding2017.basic;
+
+public class Stack {
+	
+	private int size = 0;
+	
+	private ArrayList elementData = new ArrayList();
+
+	public void push(Object o) {
+		elementData.add(o);
+		size++;
+	}
+
+	public Object pop() {
+		Object o = elementData.get(--size);
+		elementData.remove(size);
+		return o;
+	}
+
+	public Object peek() {
+		return elementData.get(size - 1);
+	}
+
+	public boolean isEmpty() {
+		return size == 0;
+	}
+
+	public int size() {
+		return size;
+	}
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/ArrayListTest.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/ArrayListTest.java
new file mode 100644
index 0000000000..a2bd0cad69
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/ArrayListTest.java
@@ -0,0 +1,15 @@
+package com.github.eloiseSJTU.coding2017.basic.test;
+
+import org.junit.Before;
+
+import com.github.eloiseSJTU.coding2017.basic.ArrayList;
+
+
+public class ArrayListTest extends ListTest {
+	
+	@Before
+	public void setUpArrayList() {
+		aList = new ArrayList();
+	}
+	
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/BinaryTreeNodeTest.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/BinaryTreeNodeTest.java
new file mode 100644
index 0000000000..3da3cf3fa0
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/BinaryTreeNodeTest.java
@@ -0,0 +1,34 @@
+package com.github.eloiseSJTU.coding2017.basic.test;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.eloiseSJTU.coding2017.basic.BinaryTreeNode;
+
+public class BinaryTreeNodeTest {
+
+	private BinaryTreeNode binaryTreeNode;
+
+	@Before
+	public void setUpBinaryTreeNode() {
+		binaryTreeNode = new BinaryTreeNode();
+	}
+
+	@Test
+	public void testBinaryTreeNodeFunctional() {
+		binaryTreeNode.insert(4);
+		binaryTreeNode.insert(1);
+		binaryTreeNode.insert(3);
+		binaryTreeNode.insert(5);
+		binaryTreeNode.insert(2);
+		assertEquals(true, 4 == binaryTreeNode.getData());
+		assertEquals(true, 1 == binaryTreeNode.getLeft().getData());
+		assertEquals(true, 5 == binaryTreeNode.getRight().getData());
+		assertEquals(true, 3 == binaryTreeNode.getLeft().getRight().getData());
+		assertEquals(true, 2 == binaryTreeNode.getLeft().getRight().getLeft().getData());
+		binaryTreeNode.print();
+	}
+
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/LinkedListTest.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/LinkedListTest.java
new file mode 100644
index 0000000000..0ad905694c
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/LinkedListTest.java
@@ -0,0 +1,93 @@
+package com.github.eloiseSJTU.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+import com.github.eloiseSJTU.coding2017.basic.LinkedList;
+
+public class LinkedListTest extends ListTest{
+
+	private LinkedList aLinkedList;
+	
+	@Before
+	public void setUpLinkedList() {
+		aList = new LinkedList();
+		aLinkedList = new LinkedList();
+	}
+
+	@Test
+	public void testAddFirst() {
+		aLinkedList.addFirst(5);
+		assertEquals(5, aLinkedList.get(0));
+		
+		aLinkedList.addFirst(6);
+		assertEquals(6, aLinkedList.get(0));
+		assertEquals(5, aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+	@Test
+	public void testAddLast() {
+		aLinkedList.addLast("hello");
+		assertEquals("hello", aLinkedList.get(0));
+		
+		aLinkedList.addLast("world");
+		assertEquals("hello", aLinkedList.get(0));
+		assertEquals("world", aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+	@Test
+	public void testRemoveFirst() {
+		aLinkedList.addLast("hello");
+		aLinkedList.addLast("world");
+		
+		aLinkedList.removeFirst();
+		assertEquals("world", aLinkedList.get(0));
+		assertEquals(1, aLinkedList.size());
+		
+		aLinkedList.removeFirst();
+		assertEquals(0, aLinkedList.size());
+	}
+	
+	@Test
+	public void testRemoveLast() {
+		aLinkedList.addFirst("world");
+		aLinkedList.addFirst("hello");
+		
+		aLinkedList.removeLast();
+		assertEquals("hello", aLinkedList.get(0));
+		assertEquals(1, aLinkedList.size());
+		
+		aLinkedList.removeLast();
+		assertEquals(0, aLinkedList.size());
+	}
+	
+	@Test
+	public void testLinkedListFunctional() {
+		for (int i=1; i<4; i++) {
+			aLinkedList.add(i);  // [1,2,3]
+		}
+		aLinkedList.remove(1);  // [1,3]
+		
+		aLinkedList.add(1, 0);  // [1,0,3]
+		for (int i=4; i<6; i++) {
+			aLinkedList.addFirst(i);  // [5, 4, 1, 0, 3]
+		}
+		assertEquals(5, aLinkedList.size());
+		assertEquals(5, aLinkedList.get(0));
+		assertEquals(1, aLinkedList.get(2));
+		assertEquals(0, aLinkedList.get(3));
+		
+		aLinkedList.remove(3);  // [5, 4, 1, 3]
+		assertEquals(3, aLinkedList.get(aLinkedList.size()-1));
+		aLinkedList.removeLast();  // [5, 4, 1]
+		assertEquals(1, aLinkedList.get(aLinkedList.size()-1));
+		aLinkedList.removeFirst();   // [4,1]
+		
+		assertEquals(4, aLinkedList.get(0));
+		assertEquals(1, aLinkedList.get(1));
+		assertEquals(2, aLinkedList.size());
+	}
+	
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/ListTest.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/ListTest.java
new file mode 100644
index 0000000000..956ecb9167
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/ListTest.java
@@ -0,0 +1,120 @@
+package com.github.eloiseSJTU.coding2017.basic.test;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import com.github.eloiseSJTU.coding2017.basic.Iterator;
+import com.github.eloiseSJTU.coding2017.basic.List;;
+
+public class ListTest {
+	
+	protected static List aList;
+	
+	@Test
+	public void testFunctional() {
+		aList.add(1);
+		aList.add(2);
+		assertEquals(1, aList.get(0));
+		assertEquals(2, aList.get(1));
+		
+		aList.add(3);
+		aList.add(0, 5);
+		aList.add(2, 11);
+		assertEquals(5, aList.get(0));
+		assertEquals(11, aList.get(2));
+		
+		aList.add("hi");
+		assertEquals("hi", aList.get(5));
+		assertEquals(6, aList.size());
+		
+		aList.remove(1);
+		assertEquals(11, aList.get(1));
+		assertEquals(2, aList.get(2));
+		
+		assertEquals(5, aList.size());
+	}
+	
+	@Test
+	public void testAdd() {
+		for (int i = 0; i < 1000; i++)
+			aList.add(i);
+		assertEquals(0, aList.get(0));
+		assertEquals(100, aList.get(100));
+		assertEquals(999, aList.get(999));
+	}
+	
+	@Test
+	public void testRemove() {
+		aList.add(1);
+		aList.add(2);
+		aList.add(3);
+		int u = (Integer)aList.remove(2);
+		assertEquals(3, u);
+		assertEquals(2, aList.size());
+		
+		aList.add(1, 5);
+		u = (Integer)aList.remove(0);
+		assertEquals(1, u);
+		assertEquals(5, aList.get(0));
+		assertEquals(2, aList.get(1));
+		assertEquals(2, aList.size());
+		
+		aList.remove(0);
+		aList.remove(0);
+		assertEquals(0, aList.size());
+		
+
+	}
+	
+	@Test
+	public void testSize() {
+		for (int i = 0; i < 10; i++)
+			aList.add(i * 2);
+		assertEquals(10, aList.size());
+	}
+	
+	@Rule  
+	public ExpectedException expectedEx = ExpectedException.none(); 
+	
+	@Test
+	public void testException() {
+		expectedEx.expect(Exception.class);
+		aList.remove(1);
+		
+		aList.add(3);
+		
+		expectedEx.expect(Exception.class);
+		aList.add(2, 5);
+	}
+	
+	@Test
+	public void testIterator() {
+		Iterator it = aList.iterator();
+		assertEquals(false, it.hasNext());
+		
+		aList.add(1);
+		aList.add(2);
+		aList.add(3);
+		
+		it = aList.iterator();
+		assertEquals(true, it.hasNext());
+		assertEquals(1, it.next());
+		assertEquals(2, it.next());
+		assertEquals(3, it.next());
+		assertEquals(false, it.hasNext());
+		
+		aList.remove(1);
+		it = aList.iterator();
+		assertEquals(true, it.hasNext());
+		assertEquals(1, it.next());
+		assertEquals(3, it.next());
+		assertEquals(false, it.hasNext());	
+		
+		expectedEx.expect(Exception.class);
+		it.next();
+	}
+
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/QueueTest.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/QueueTest.java
new file mode 100644
index 0000000000..39023e8aaa
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/QueueTest.java
@@ -0,0 +1,33 @@
+package com.github.eloiseSJTU.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+import com.github.eloiseSJTU.coding2017.basic.Queue;
+
+public class QueueTest {
+	private Queue queue;
+	
+	@Before
+	public void setUpQueue() {
+		queue = new Queue();
+	}
+	
+	@Test
+	public void testQueueFunctional() {
+		assertEquals(true, queue.isEmpty());
+		queue.enQueue(4);
+		queue.enQueue(2);
+		assertEquals(2, queue.size());
+		assertEquals(false, queue.isEmpty());
+		
+		int i = (Integer)queue.deQueue();
+		assertEquals(4, i);
+		i = (Integer)queue.deQueue();
+		assertEquals(2, i);
+		
+		assertEquals(0, queue.size());
+		assertEquals(true, queue.isEmpty());
+	}
+
+}
diff --git a/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/StackTest.java b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/StackTest.java
new file mode 100644
index 0000000000..98d2bd9de9
--- /dev/null
+++ b/group02/851113375/src/com/github/eloiseSJTU/coding2017/basic/test/StackTest.java
@@ -0,0 +1,40 @@
+package com.github.eloiseSJTU.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.eloiseSJTU.coding2017.basic.Stack;
+
+public class StackTest {
+
+	private Stack stack;
+	
+	@Before
+	public void setUpStack() {
+		stack = new Stack();
+	}
+
+	@Test
+	public void testStackFunctional() {
+		assertEquals(true, stack.isEmpty());
+		stack.push(4);
+		stack.push(2);
+		assertEquals(2, stack.size());
+		assertEquals(false, stack.isEmpty());
+		
+		int i = (Integer)stack.pop();
+		assertEquals(2, i);
+		
+		i = (Integer)stack.peek();
+		assertEquals(4, i);
+		
+		i = (Integer)stack.pop();
+		assertEquals(4, i);
+		
+		assertEquals(0, stack.size());
+		assertEquals(true, stack.isEmpty());
+	}
+
+}
diff --git a/group02/953840070/src/com/github/lqingchenl/coding2017/basic/ArrayList.java b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/ArrayList.java
new file mode 100644
index 0000000000..286c039e06
--- /dev/null
+++ b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/ArrayList.java
@@ -0,0 +1,86 @@
+package com.github.lqingchenl.coding2017.basic;
+
+import java.util.Arrays;
+
+
+public class ArrayList implements List {
+    private int size = 0;
+
+    private Object[] elementData = new Object[3];
+
+    /**
+     * 添加一个元素
+     *
+     * @param o
+     */
+    public void add(Object o) {
+        elementData[size] = o;
+        size = size + 1;
+        if (size >= elementData.length) {
+            elementData = Arrays.copyOf(elementData, elementData.length * 2);
+        }
+    }
+
+    /**
+     * 往固定位置添加一个元素
+     *
+     * @param index
+     * @param o
+     */
+    public void add(int index, Object o) {
+        if (get(index - 1) == null) { //原来为空，添加到指定位置
+            add(o);
+            return;
+        }
+        size++;
+        if (size >= elementData.length) {
+            elementData = Arrays.copyOf(elementData, elementData.length * 2);
+        }
+        System.arraycopy(elementData, index, elementData, index + 1, size - index);
+        elementData[index] = o;
+    }
+
+    /**
+     * 获取元素
+     *
+     * @param index
+     * @return
+     */
+    public Object get(int index) {
+
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException("索引越界");
+        }
+        return elementData[index];
+    }
+
+    /**
+     * 移除元素
+     *
+     * @param index
+     * @return
+     */
+    public Object remove(int index) {
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException("索引越界");
+        }
+        Object deleteData = elementData[index];
+        if (index == size - 1) {
+            elementData[index] = null;
+        } else {
+            int movedCount = size - index;
+            System.arraycopy(elementData, index + 1, elementData, index, movedCount);
+        }
+        size--;
+        return deleteData;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public Iterator iterator() {
+        return null;
+    }
+
+}
diff --git a/group02/953840070/src/com/github/lqingchenl/coding2017/basic/ArrayListTest.java b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/ArrayListTest.java
new file mode 100644
index 0000000000..ebf29cf406
--- /dev/null
+++ b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/ArrayListTest.java
@@ -0,0 +1,69 @@
+package com.github.lqingchenl.coding2017.basic;
+
+import com.github.lqingchenl.coding2017.basic.ArrayList;
+import org.junit.Test;
+import org.junit.Before;
+import org.junit.After;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * ArrayList Tester.
+ */
+public class ArrayListTest {
+
+    private static ArrayList testArray = new ArrayList();
+
+    /**
+     * Method: add(Object o)
+     */
+    @Test
+    public void testAddO() throws Exception {
+        testArray.add(1);
+        testArray.add(2);
+        assertEquals(1, testArray.get(0));
+        assertEquals(2, testArray.get(1));
+    }
+
+    /**
+     * Method: add(int index, Object o)
+     */
+    @Test
+    public void testAddForIndexO() throws Exception {
+        testArray.add(1, 1);
+        testArray.add(2, 2);
+        assertEquals(1, testArray.get(0));
+        assertEquals(2, testArray.get(1));
+    }
+
+    /**
+     * Method: get(int index)
+     */
+    @Test
+    public void testGet() throws Exception {
+        testArray.add(1);
+        assertEquals(1, testArray.get(0));
+    }
+
+    /**
+     * Method: remove(int index)
+     */
+    @Test
+    public void testRemove() throws Exception {
+        testArray.add(1);
+        testArray.add(2);
+        assertEquals(1, testArray.remove(0));
+        assertEquals(2, testArray.remove(0));
+    }
+
+    /**
+     * Method: size()
+     */
+    @Test
+    public void testSize() throws Exception {
+        testArray.add(1);
+        testArray.add(2);
+        assertEquals(2, testArray.size());
+    }
+
+}
diff --git a/group02/953840070/src/com/github/lqingchenl/coding2017/basic/Iterator.java b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/Iterator.java
new file mode 100644
index 0000000000..086e1cd342
--- /dev/null
+++ b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/Iterator.java
@@ -0,0 +1,7 @@
+package com.github.lqingchenl.coding2017.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group02/953840070/src/com/github/lqingchenl/coding2017/basic/LinkedList.java b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/LinkedList.java
new file mode 100644
index 0000000000..316cad2ee5
--- /dev/null
+++ b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/LinkedList.java
@@ -0,0 +1,118 @@
+package com.github.lqingchenl.coding2017.basic;
+
+public class LinkedList implements List {
+
+    private int size = 0;
+
+    private Node head;
+
+    public void add(Object o) {
+        if (head == null) {
+            head = new Node(o);
+        } else {
+            Node nextNode = head;
+            while (nextNode.next != null) {
+                nextNode = nextNode.next;
+            }
+            nextNode.next = new Node(o);
+        }
+        size++;
+    }
+
+    public void add(int index, Object o) {
+        if (index == 0) {
+            addFirst(o);
+            return;
+        }
+        Node oldNode = getNode(index - 1);
+        Node newNode = new Node(o);
+        newNode.next = oldNode.next;
+        oldNode.next = newNode;
+        size++;
+    }
+
+    public Object get(int index) {
+        Node node = head;
+        for (int i = 0; i < index; i++) {
+            node = node.next;
+        }
+        return node.data;
+    }
+
+    public Node getNode(int index) {
+        Node node = head;
+        for (int i = 0; i < index; i++) {
+            node = node.next;
+        }
+        return node;
+    }
+
+    public Object remove(int index) {
+        if (index == 1) {
+            return removeFirst();
+        }
+        Node fatherNode = getNode(index - 2);
+        Node oldNode = getNode(index - 1);
+        fatherNode.next = oldNode.next;
+        size--;
+
+        return oldNode.data;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public void addFirst(Object o) {
+        Node newNode = new Node(o);
+        newNode.next = head;
+        head = newNode;
+        size++;
+    }
+
+    public void addLast(Object o) {
+        if (head == null) {
+            addFirst(o);
+            return;
+        }
+        Node newNode = new Node(o);
+        Node lastNode = getNode(size - 1);
+        lastNode.next = newNode;
+        size++;
+    }
+
+    public Object removeFirst() {
+        Node oldHead = head;
+        Node secondNode = head.next;
+        head = secondNode;
+        size--;
+        return oldHead.data;
+    }
+
+    public Object removeLast() {
+        if (size == 1) {
+            return removeFirst();
+        }
+        Object data = get(size - 1);
+        Node oldNode = getNode(size - 2);
+        oldNode.next = null;
+        size--;
+        return data;
+    }
+
+    public Iterator iterator() {
+        return null;
+    }
+
+
+    private static class Node {
+        Object data;
+        Node next;
+
+        public Node(Object data) {
+            this.data = data;
+        }
+
+    }
+
+}
diff --git a/group02/953840070/src/com/github/lqingchenl/coding2017/basic/LinkedListTest.java b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/LinkedListTest.java
new file mode 100644
index 0000000000..0ef6290d28
--- /dev/null
+++ b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/LinkedListTest.java
@@ -0,0 +1,125 @@
+package com.github.lqingchenl.coding2017.basic;
+
+import org.junit.Test;
+import org.junit.Before;
+import org.junit.After;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class LinkedListTest {
+
+    private static LinkedList testLinkedList = new LinkedList();
+
+    /**
+     * Method: add(Object o)
+     */
+    @Test
+    public void testAdd() throws Exception {
+        testLinkedList.add(1);
+        testLinkedList.add(2);
+        assertEquals(1, testLinkedList.get(0));
+        assertEquals(2, testLinkedList.get(1));
+    }
+
+    /**
+     * Method: add(int index, Object o)
+     */
+    @Test
+    public void testAddForIndex() throws Exception {
+        testLinkedList.add(0, 0);
+        testLinkedList.add(1, 1);
+        testLinkedList.add(2, 2);
+        assertEquals(0, testLinkedList.get(0));
+        assertEquals(1, testLinkedList.get(1));
+        assertEquals(2, testLinkedList.get(2));
+    }
+
+    /**
+     * Method: get(int index)
+     */
+    @Test
+    public void testGet() throws Exception {
+        testLinkedList.add(1);
+        testLinkedList.add(2);
+        assertEquals(1, testLinkedList.get(0));
+        assertEquals(2, testLinkedList.get(1));
+    }
+
+    /**
+     * Method: getNode(int index)
+     */
+    @Test
+    public void testGetNode() throws Exception {
+        testLinkedList.add(1);
+        testLinkedList.add(2);
+        assertNotNull(testLinkedList.get(0));
+    }
+
+    /**
+     * Method: remove(int index)
+     */
+    @Test
+    public void testRemove() throws Exception {
+        testLinkedList.add(1);
+        testLinkedList.add(2);
+        assertEquals(1, testLinkedList.get(0));
+    }
+
+    /**
+     * Method: size()
+     */
+    @Test
+    public void testSize() throws Exception {
+        testLinkedList.add(1);
+        testLinkedList.add(2);
+        assertEquals(2, testLinkedList.size());
+    }
+
+    /**
+     * Method: addFirst(Object o)
+     */
+    @Test
+    public void testAddFirst() throws Exception {
+        testLinkedList.addFirst(1);
+        assertEquals(1, testLinkedList.get(0));
+    }
+
+    /**
+     * Method: addLast(Object o)
+     */
+    @Test
+    public void testAddLast() throws Exception {
+        testLinkedList.addLast(1);
+        assertEquals(1, testLinkedList.get(0));
+    }
+
+    /**
+     * Method: removeFirst()
+     */
+    @Test
+    public void testRemoveFirst() throws Exception {
+        testLinkedList.addFirst(1);
+        testLinkedList.addFirst(2);
+        assertEquals(2, testLinkedList.removeFirst());
+        assertEquals(1, testLinkedList.removeFirst());
+    }
+
+    /**
+     * Method: removeLast()
+     */
+    @Test
+    public void testRemoveLast() throws Exception {
+        testLinkedList.addFirst(1);
+        assertEquals(1, testLinkedList.removeLast());
+    }
+
+    /**
+     * Method: iterator()
+     */
+    @Test
+    public void testIterator() throws Exception {
+    }
+
+
+} 
diff --git a/group02/953840070/src/com/github/lqingchenl/coding2017/basic/List.java b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/List.java
new file mode 100644
index 0000000000..d993812b9a
--- /dev/null
+++ b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/List.java
@@ -0,0 +1,9 @@
+package com.github.lqingchenl.coding2017.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/group02/953840070/src/com/github/lqingchenl/coding2017/basic/Queue.java b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/Queue.java
new file mode 100644
index 0000000000..eb7f7e3cb0
--- /dev/null
+++ b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/Queue.java
@@ -0,0 +1,28 @@
+package com.github.lqingchenl.coding2017.basic;
+
+public class Queue {
+    private LinkedList queue = new LinkedList();
+    private int size;
+
+    public void enQueue(Object o) {
+        queue.addLast(o);
+        size++;
+    }
+
+    public Object deQueue() {
+        Object o = queue.removeFirst();
+        size--;
+        return o;
+    }
+
+    public boolean isEmpty() {
+        if (queue.size() == 0)
+            return true;
+        return false;
+    }
+
+    public int size() {
+        return size;
+    }
+
+}
diff --git a/group02/953840070/src/com/github/lqingchenl/coding2017/basic/QueueTest.java b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/QueueTest.java
new file mode 100644
index 0000000000..9b26b3cdcf
--- /dev/null
+++ b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/QueueTest.java
@@ -0,0 +1,57 @@
+package com.github.lqingchenl.coding2017.basic;
+
+import org.junit.Test;
+import org.junit.Before;
+import org.junit.After;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Queue Tester.
+ */
+public class QueueTest {
+
+    private static Queue testQueue = new Queue();
+
+    /**
+     * Method: enQueue(Object o)
+     */
+    @Test
+    public void testEnQueue() throws Exception {
+        testQueue.enQueue(1);
+        assertEquals(1, testQueue.deQueue());
+    }
+
+    /**
+     * Method: deQueue()
+     */
+    @Test
+    public void testDeQueue() throws Exception {
+        testQueue.enQueue(1);
+        testQueue.enQueue(2);
+        assertEquals(1, testQueue.deQueue());
+        assertEquals(2, testQueue.deQueue());
+    }
+
+    /**
+     * Method: isEmpty()
+     */
+    @Test
+    public void testIsEmpty() throws Exception {
+        testQueue.enQueue(1);
+        assertEquals(1, testQueue.deQueue());
+        assertEquals(true, testQueue.isEmpty());
+    }
+
+    /**
+     * Method: size()
+     */
+    @Test
+    public void testSize() throws Exception {
+        testQueue.enQueue(1);
+        testQueue.enQueue(2);
+        assertEquals(2, testQueue.size());
+    }
+
+
+} 
diff --git a/group02/953840070/src/com/github/lqingchenl/coding2017/basic/Stack.java b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/Stack.java
new file mode 100644
index 0000000000..8b25283b40
--- /dev/null
+++ b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/Stack.java
@@ -0,0 +1,33 @@
+package com.github.lqingchenl.coding2017.basic;
+
+public class Stack {
+    private ArrayList elementData = new ArrayList();
+    private int size = 0;
+
+    public void push(Object o) {
+        elementData.add(o);
+        size++;
+    }
+
+    public Object pop() {
+        Object o =  elementData.get(size - 1);
+        elementData.remove(size - 1);
+        size--;
+        return o;
+    }
+
+    public Object peek() {
+        return elementData.get(size - 1);
+    }
+
+    public boolean isEmpty() {
+        if (elementData.size() == 0)
+            return true;
+        return false;
+    }
+
+    public int size() {
+        return size;
+    }
+
+}
diff --git a/group02/953840070/src/com/github/lqingchenl/coding2017/basic/StackTest.java b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/StackTest.java
new file mode 100644
index 0000000000..b2d4935c4e
--- /dev/null
+++ b/group02/953840070/src/com/github/lqingchenl/coding2017/basic/StackTest.java
@@ -0,0 +1,64 @@
+package com.github.lqingchenl.coding2017.basic;
+
+import org.junit.Test;
+import org.junit.Before;
+import org.junit.After;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Stack Tester.
+ */
+public class StackTest {
+
+    private static Stack testStack = new Stack();
+
+    /**
+     * Method: push(Object o)
+     */
+    @Test
+    public void testPush() throws Exception {
+        testStack.push(1);
+        assertEquals(1, testStack.peek());
+    }
+
+    /**
+     * Method: pop()
+     */
+    @Test
+    public void testPop() throws Exception {
+        testStack.push(1);
+        assertEquals(1, testStack.pop());
+    }
+
+    /**
+     * Method: peek()
+     */
+    @Test
+    public void testPeek() throws Exception {
+        testStack.push(1);
+        assertEquals(1, testStack.peek());
+        testStack.push(2);
+        assertEquals(2, testStack.peek());
+    }
+
+    /**
+     * Method: isEmpty()
+     */
+    @Test
+    public void testIsEmpty() throws Exception {
+        testStack.push(1);
+        assertEquals(false, testStack.isEmpty());
+    }
+
+    /**
+     * Method: size()
+     */
+    @Test
+    public void testSize() throws Exception {
+        testStack.push(1);
+        testStack.push(2);
+        assertEquals(2, testStack.size());
+    }
+
+}
diff --git "a/group07/1046545622/git\345\221\275\344\273\244.txt" "b/group07/1046545622/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/1046545622/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/1058267830/git\345\221\275\344\273\244.txt" "b/group07/1058267830/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/1058267830/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/1070440331/git\345\221\275\344\273\244.txt" "b/group07/1070440331/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/1070440331/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/1280157271/git\345\221\275\344\273\244.txt" "b/group07/1280157271/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/1280157271/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/1448276993/git\345\221\275\344\273\244.txt" "b/group07/1448276993/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/1448276993/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/1519504320/git\345\221\275\344\273\244.txt" "b/group07/1519504320/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/1519504320/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/1520332119/git\345\221\275\344\273\244.txt" "b/group07/1520332119/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/1520332119/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git a/group07/1536161030/.classpath b/group07/1536161030/.classpath
new file mode 100644
index 0000000000..d171cd4c12
--- /dev/null
+++ b/group07/1536161030/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group07/1536161030/.gitignore b/group07/1536161030/.gitignore
new file mode 100644
index 0000000000..be00f4a4de
--- /dev/null
+++ b/group07/1536161030/.gitignore
@@ -0,0 +1,22 @@
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid* 
\ No newline at end of file
diff --git a/group07/1536161030/.project b/group07/1536161030/.project
new file mode 100644
index 0000000000..11a1957bfe
--- /dev/null
+++ b/group07/1536161030/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>homework</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group07/1536161030/.settings/org.eclipse.core.resources.prefs b/group07/1536161030/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000000..4824b80263
--- /dev/null
+++ b/group07/1536161030/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git "a/group07/1536161030/CPU,\345\206\205\345\255\230,\347\241\254\347\233\230,\346\214\207\344\273\244.txt" "b/group07/1536161030/CPU,\345\206\205\345\255\230,\347\241\254\347\233\230,\346\214\207\344\273\244.txt"
new file mode 100644
index 0000000000..32d83cd08b
--- /dev/null
+++ "b/group07/1536161030/CPU,\345\206\205\345\255\230,\347\241\254\347\233\230,\346\214\207\344\273\244.txt"
@@ -0,0 +1,12 @@
+������ڲ���Ҫ���������CPU���ڴ棬Ӳ�̣�ָ�
+CPU��Ҳ�д��������˿�����˼�������Կ�CPU���㡣CPU��Ҫ�������Ϳ��ƵĲ��֣�����˼�壬���ǿ��Ƶ�Ԫ�����㵥Ԫ�����֣������˵Ĵ��Խ��м��������һ����
+�����Եļ����������һ��ģ����������ÿ�����ܵ�Ԫ���Ƿֹ���ȷ�ġ����п��Ƶ�Ԫ���ݳ���ͨ��ָ�����������㵥Ԫ����������ó������Ȼ����ƴ洢��Ԫ���洢�м�Ľ����
+�ڴ��Ǵ洢CPU��Ҫ���������ϣ���Ҫ�����У�����ϵͳ�е���ʱ���ݣ������Ӳ�̶�ȡ�����ݣ��ṩ��CPUʹ�á�
+Ӳ���Ǹ���洢������Ҫ���ô洢�����ݣ��������ǵĳ�������ݣ��ŵ��Ƿǳ��̶���������׼ȷ���������Դ洢����Ϣ��������ʱ���������
+�ڴ��ȡ���ݵ��ٶȱ�Ӳ�̵Ĵ�ȡ�ٶȿ���10���� ��ĳЩ��������ܻ����
+CPU���ٶȱ��ڴ治֪Ҫ����ٱ��������ǰѳ����Ӳ�̷ŵ��ڴ��Ժ�CPU��ֱ�����ڴ����г���������CPUֱ����Ӳ�����г����Ҫ��ܶࡣ
+�����ڴ�����һ����CPU���й��죬��Ӳ�����ݴ�ȡ̫�������⡣ ��������ǵĵ��Ե������ٶȡ�
+���������г����ʱ��CPU���Ƚ��ܵ����ǵ����֮��CPU�Ǹ���Ӳ�̣���Ҫ������洢�ĳ���A����ѳ���A�͵��ڴ�ȥ��CPU���ڴ�˵������Ӳ�̰ѳ���A�͵����������ˣ��㱣��һ�¡� �ȳ���A���������͵��ڴ�֮��CPU�Ϳ�ʼִ�г���A����CPU������㣬���ȡ������δ洢���ݣ�������ζ������������й�ͨ�������Ҫָ���ˡ�
+ָ��Ҳ���ǻ������Ե�һ������䣬�൱��CPU���ڴ棬Ӳ��֮������ԡ�����ָ�Ӽ�������������������������ݵ����㣬�߼����㣬���ݴ��ͣ�����Ŀ��ƣ��������ָ��ȡ�
+
+
diff --git "a/group07/1536161030/git\345\221\275\344\273\244.txt" "b/group07/1536161030/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/1536161030/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git a/group07/1536161030/src/com/coding/basic/ArrayList.java b/group07/1536161030/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..dfad793392
--- /dev/null
+++ b/group07/1536161030/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,95 @@
+package com.coding.basic;
+
+public class ArrayList implements List{
+
+	private int size = 0;
+
+	private Object[] elementData;
+
+	public ArrayList(int size) {
+		this.elementData = new Object[size];
+	}
+
+	public ArrayList() {
+		this.elementData = new Object[10];
+	}
+
+	public void add(Object o) {
+		if(isFull())
+			resize();
+		elementData[size++] = o;
+	}
+
+	public void add(int index, Object o) {
+		rangeCheckForAdd(index);
+		System.arraycopy(elementData, index, elementData, index + 1, size - index);
+		elementData[index] = o;
+		size++;
+	}
+
+	public Object get(int index) {
+		rangeCheckForAdd(index);
+		return elementData[index];
+	}
+
+	public Object remove(int index) {
+		rangeCheckForAdd(index);
+		Object o = elementData[index];
+		System.arraycopy(elementData, index + 1, elementData, index, size - index);
+		elementData[--size] = null;
+		return o;
+	}
+
+	public int size() {
+		return elementData.length;
+	}
+
+	public com.coding.basic.Iterator iterator() {
+		return new Itr();
+	}
+
+	private class Itr implements com.coding.basic.Iterator {
+		int cursor;
+
+		@Override
+		public boolean hasNext() {
+			return cursor != size;
+		}
+
+		@Override
+		public Object next() {
+			int i = cursor;
+			if (i < elementData.length) {
+				cursor = i + 1;
+				return elementData[i];
+			}
+			return null;
+		}
+	}
+	
+	//檢查下表越界
+	public void rangeCheckForAdd(int index) {
+		if (index < 0 || index > size) 
+			throw new IndexOutOfBoundsException("下标越界");
+	}
+	
+	//数组是否满
+	public boolean isFull(){
+    	return size == elementData.length;
+    }
+    
+    //扩容
+    public void resize(){
+    	Object[] newElementData = new Object[elementData.length * 2];
+    	System.arraycopy(elementData, 0, newElementData, 0, size);
+    	this.elementData = newElementData;
+    	newElementData = null;
+    }
+    
+    //
+	public boolean isEmpty() {
+		return size == 0;
+	}
+	
+
+}
diff --git a/group07/1536161030/src/com/coding/basic/BinaryTreeNode.java b/group07/1536161030/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..b1143e1a74
--- /dev/null
+++ b/group07/1536161030/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,75 @@
+package com.coding.basic;
+
+public class BinaryTreeNode <Object extends Comparable<Object>> {
+
+    private Object data;
+    
+    private BinaryTreeNode left;
+    
+    private BinaryTreeNode right;
+    
+    public BinaryTreeNode(Object data){
+		this.data = data;
+		this.left=null;
+		this.right =null;
+	}
+    
+    public BinaryTreeNode root;
+    
+    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;
+    }
+    /*
+     * 二叉树 b 插入对象  o 父节点 pnode
+     * 若b为空树，插入节点作为根
+     * o 等于根节点  直接返回
+     * o 小于根节点  pnode = 左子树
+     * else pnode = 右子树
+     * 
+     */
+    public BinaryTreeNode insert(Object o) {
+    	BinaryTreeNode current = root;
+    	
+        if(current == null){
+        	return new BinaryTreeNode(o);
+        }
+    	if (o.compareTo((Object) current.data)<0){
+    		if(current.left !=null){
+    			current = current.left;
+    		}else{
+    			current.left = new BinaryTreeNode(o);
+    			return current;
+    		}
+    	}else if(o.compareTo((Object) current.data)==0){
+    		return current;
+    	}else{
+    		if(current.right !=null){
+    			current = current.right;
+    		}else{
+    			current.right = new BinaryTreeNode(o);
+    			return current;
+    		}
+    	}
+    	return current;
+    }
+}
diff --git a/group07/1536161030/src/com/coding/basic/Iterator.java b/group07/1536161030/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..2ab5f039d5
--- /dev/null
+++ b/group07/1536161030/src/com/coding/basic/Iterator.java
@@ -0,0 +1,8 @@
+package com.coding.basic;
+
+public interface Iterator {
+	boolean hasNext();
+
+	Object next();
+
+}
diff --git a/group07/1536161030/src/com/coding/basic/LinkedList.java b/group07/1536161030/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..fc3ed5afaf
--- /dev/null
+++ b/group07/1536161030/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,139 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+
+    private Node head;
+    private int size;
+    
+    public LinkedList(){
+    	this.head = null;
+    	this.size = 0;
+    }
+    
+    public void add(Object o) {
+        Node newNode = new Node(o);
+        if(isEmpty()){
+        	head = newNode;
+        }
+        else{
+	        newNode.next = head;
+	        head = newNode;
+        }
+        size++;
+    }
+
+    public void add(int index, Object o) {
+    	if (index < 0 || index > size) 
+			throw new IndexOutOfBoundsException("下标越界");
+    	
+        Node indexNode = node(index);
+        
+        Node newNode = new Node(o);
+        if(isEmpty()){
+        	head = newNode;
+        }else {
+            newNode.next = indexNode;
+            indexNode = newNode;
+        }
+        size++;
+    }
+
+    public Object get(int index) {
+		if (index < 0 || index > size) 
+			throw new IndexOutOfBoundsException("下标越界");
+        return node(index).data;
+    }
+
+    public Object remove(int index) {
+        Node indexNode = node(index);
+        Node preNode = node(index);
+        preNode.next = indexNode.next;
+        indexNode.next = null;
+        size--;
+        return indexNode.data;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public void addFirst(Object o) {
+    	if(o == null){
+    		throw new RuntimeException("不能加入null元素");  
+    	}
+        Node newNode = new Node(o);
+        newNode.next = head;
+        size++;
+    }
+
+    public void addLast(Object o) {
+        Node newNode = new Node(o);
+        Node last = node(size);
+
+        newNode.next = last.next;
+        last.next = newNode;
+        size++;
+    }
+
+    public Object removeFirst() {
+        Node oldNode = head;
+        head = head.next;
+        head.next = null;
+        size--;
+        return oldNode.data;
+    }
+
+    public Object removeLast() {
+        Node oldNode = node(size);
+        Node preNode = node(size - 1);
+        preNode.next = null;
+        size--;
+        return oldNode.data;
+    }
+
+    public Iterator iterator(int index) {
+        return new Itr(index);
+    }
+    
+    // TODO: 2017/2/24  
+    private class Itr implements com.coding.basic.Iterator {
+        private int nextIndex;
+
+        public Itr(int index) {
+            this.nextIndex = index;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return nextIndex < size;
+        }
+
+        @Override
+        public Object next() {
+            return null;
+        }
+    }
+
+
+    private static class Node {
+        public Object data;
+        public Node next;
+
+        public Node(Object data) {
+            this.data = data;
+            this.next = null;
+        }
+    }
+
+    Node node(int index) {
+        Node x = head;
+        for (int i = 0; i < index; i++)
+            x = x.next;
+        return x;
+    }
+    
+    //
+	public boolean isEmpty() {
+		return head ==null;
+	}
+}
diff --git a/group07/1536161030/src/com/coding/basic/List.java b/group07/1536161030/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..df30cc6e07
--- /dev/null
+++ b/group07/1536161030/src/com/coding/basic/List.java
@@ -0,0 +1,13 @@
+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/group07/1536161030/src/com/coding/basic/Queue.java b/group07/1536161030/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..70f99dfd3e
--- /dev/null
+++ b/group07/1536161030/src/com/coding/basic/Queue.java
@@ -0,0 +1,72 @@
+package com.coding.basic;
+
+public class Queue {
+    private int size;
+    
+    //头标志位
+    private int head;
+    
+    //尾标志位
+    private int tail;
+    
+    private Object[] queue;
+
+    public Queue() {
+        this.queue = new Object[10];
+        this.size = 0 ;
+        this.head = 0;
+        this.tail = 0;
+    }
+
+    public void enQueue(Object o) {
+    	if(isFull()){
+    		resize();
+    		head=0; 
+    	}
+    	int newtail = (head + size )% queue.length;
+    	queue[newtail]=o;
+    	size ++;
+    }
+
+    public Object deQueue() {
+    	if(isEmpty())
+    		throw new IndexOutOfBoundsException("队列为空!");
+    	Object old = queue[head];
+    	queue[head] =null;
+    	head = (head + 1)% queue.length;
+    	size --;
+    	return old;
+    	
+    }
+    
+    public Object getHead(){
+		return head;
+    }
+    
+    public Object getTail(){
+ 		return tail;
+     }
+     
+    
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public int size() {
+    	int diff = tail - head;
+        return diff;
+    }
+    
+    //
+    public boolean isFull(){
+    	return size == queue.length;
+    }
+    
+    //扩容
+    public void resize(){
+    	Object[] newQueue = new Object[queue.length * 2];
+    	System.arraycopy(queue, 0, newQueue, 0, size);
+    	this.queue = newQueue;
+    	newQueue = null;
+    }
+}
diff --git a/group07/1536161030/src/com/coding/basic/Stack.java b/group07/1536161030/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..233723755b
--- /dev/null
+++ b/group07/1536161030/src/com/coding/basic/Stack.java
@@ -0,0 +1,47 @@
+package com.coding.basic;
+
+import java.util.EmptyStackException;
+
+
+public class Stack {
+	private Object[] elementData;
+	private int size;
+
+	public Stack() {
+		this.size = 0;
+		this.elementData = new Object[10];
+	}
+
+	public void push(Object o) {
+		if (o == null) 
+			throw new RuntimeException("元素不可为NULL");
+		size++;
+		elementData[size -1]= o ;
+	}
+
+	public Object pop() {
+		if (isEmpty()) 
+			throw new EmptyStackException();
+		Object old = elementData[size - 1];
+		elementData[size] = null;
+		size--;
+		return old;
+	}
+
+	public Object peek() {
+		if (isEmpty()) 
+			throw new EmptyStackException();
+		return elementData[size -1];
+	}
+
+	public boolean isEmpty() {
+		return size < 1;
+	}
+	
+	//
+	public int size() {
+		return size;
+	}
+}
+
+
diff --git a/group07/1536161030/src/com/coding/test/ArrayListTest.java b/group07/1536161030/src/com/coding/test/ArrayListTest.java
new file mode 100644
index 0000000000..482fe53cd8
--- /dev/null
+++ b/group07/1536161030/src/com/coding/test/ArrayListTest.java
@@ -0,0 +1,70 @@
+package com.coding.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.coding.basic.ArrayList;
+
+//
+public class ArrayListTest {
+
+	@Test
+	public void testAddObject() {
+		ArrayList al = new ArrayList();
+		assertEquals(10, al.size());
+		al.add(new Integer(1));
+		System.out.print(al.get(0));
+	}
+	
+	@Test
+	public void testAddIntObject() {
+		ArrayList al = new ArrayList();
+		al.add(0, new Integer(1));
+		assertEquals(10, al.size());
+		int tmp = 0;
+		try {
+			al.add(4, new Integer(4));
+		} catch (IndexOutOfBoundsException e) {
+			tmp = 1;
+			assertEquals(tmp, 1);
+		}
+		
+	}
+
+	@Test
+	public void testGet() {
+		ArrayList al = new ArrayList();
+		al.add(new Integer(1));
+		assertEquals((Integer)al.get(0),new Integer(1));
+		int tmp = 0;
+		try {
+			al.get(4);
+		} catch (IndexOutOfBoundsException e) {
+			tmp = 1;
+			assertEquals(tmp, 1);
+		}
+	}
+
+	@Test
+	public void testRemove() {
+		ArrayList al = new ArrayList();
+		al.add(new Integer(1));
+		assertEquals((Integer)al.get(0),new Integer(1));
+		assertEquals(al.size(),10);
+	}
+
+	@Test
+	public void testSize() {
+		ArrayList al = new ArrayList();
+		assertEquals(10, al.size());
+	}
+
+	@Test
+	public void testIsEmpty() {
+		ArrayList al = new ArrayList();
+		assertTrue(al.isEmpty());
+		al.add(new Integer(1));
+		assertFalse(al.isEmpty());
+	}
+}
diff --git a/group07/1536161030/src/com/coding/test/BinaryTreeNodeTest.java b/group07/1536161030/src/com/coding/test/BinaryTreeNodeTest.java
new file mode 100644
index 0000000000..dd2cde39b7
--- /dev/null
+++ b/group07/1536161030/src/com/coding/test/BinaryTreeNodeTest.java
@@ -0,0 +1,19 @@
+package com.coding.test;
+
+//
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.coding.basic.BinaryTreeNode;
+import com.coding.basic.LinkedList;
+
+public class BinaryTreeNodeTest {
+
+	@Test
+	public void testAddObject() {
+		BinaryTreeNode bt = new BinaryTreeNode(null);
+		bt.insert(new Integer(1));
+		assertNotNull(bt);
+	}
+}
diff --git a/group07/1536161030/src/com/coding/test/LinkedListTest.java b/group07/1536161030/src/com/coding/test/LinkedListTest.java
new file mode 100644
index 0000000000..fb0ed303ed
--- /dev/null
+++ b/group07/1536161030/src/com/coding/test/LinkedListTest.java
@@ -0,0 +1,68 @@
+package com.coding.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.coding.basic.LinkedList;
+
+//
+public class LinkedListTest{
+	@Test
+	public void testAddObject() {
+		LinkedList list = new LinkedList();
+		assertEquals(0, list.size());
+		list.add(new Integer(1));
+		assertEquals(1, list.size());
+	}
+
+	@Test
+	public void testAddIntObject() {
+		LinkedList list = new LinkedList();
+		list.add(0, new Integer(1));
+		assertEquals(1, list.size());
+		int tmp = 0;
+		try {
+			list.add(4, new Integer(4));
+		} catch (IndexOutOfBoundsException e) {
+			tmp = 1;
+			assertEquals(tmp, 1);
+		}
+	}
+
+	@Test
+	public void testGet() {
+		LinkedList list = new LinkedList();
+		list.add(new Object());
+		assertNotNull(list.get(0));
+		int tmp = 0;
+		try {
+			list.get(4);
+		} catch (IndexOutOfBoundsException e) {
+			tmp = 1;
+			assertEquals(tmp, 1);
+		}
+	}
+
+	@Test
+	public void testRemove() {
+		LinkedList list = new LinkedList();
+		list.add(new Object());
+		list.remove(0);
+		assertEquals(list.size(),0);	
+	}
+
+	@Test
+	public void testSize() {
+		LinkedList list = new LinkedList();
+		assertEquals(0, list.size());	
+	}
+
+	@Test
+	public void testIsEmpty() {
+		LinkedList list = new LinkedList();
+		assertTrue(list.isEmpty());
+		list.add(new Object());
+		assertFalse(list.isEmpty());
+}
+}
diff --git a/group07/1536161030/src/com/coding/test/QueueTest.java b/group07/1536161030/src/com/coding/test/QueueTest.java
new file mode 100644
index 0000000000..3130dbc808
--- /dev/null
+++ b/group07/1536161030/src/com/coding/test/QueueTest.java
@@ -0,0 +1,47 @@
+package com.coding.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.coding.basic.Queue;
+
+//
+public class QueueTest {
+
+	@Test
+	public void testEnQueue() {
+		Queue queue = new Queue();
+		assertEquals(queue.size(), 0);
+		System.out.print(queue.getHead());
+	}
+
+	@Test
+	public void testDeQueue() {
+		Queue queue = new Queue();
+		int tmp = 0;
+		try {
+			queue.deQueue();
+		} catch (IndexOutOfBoundsException e) {
+			tmp = 1;
+			assertEquals(tmp, 1);
+		}
+		queue.enQueue(new Object());
+		assertNotNull(queue.deQueue());
+	}
+
+	@Test
+	public void testIsEmpty() {
+		Queue queue = new Queue();
+		assertTrue(queue.isEmpty());
+		queue.enQueue(new Object());
+		assertFalse(queue.isEmpty());
+	}
+
+	@Test
+	public void testSize() {
+		Queue queue = new Queue();
+		assertEquals(queue.size(), 0);
+	}	
+
+}
diff --git a/group07/1536161030/src/com/coding/test/StackTest.java b/group07/1536161030/src/com/coding/test/StackTest.java
new file mode 100644
index 0000000000..3622e0cb68
--- /dev/null
+++ b/group07/1536161030/src/com/coding/test/StackTest.java
@@ -0,0 +1,58 @@
+package com.coding.test;
+
+import static org.junit.Assert.*;
+
+import java.util.EmptyStackException;
+
+import org.junit.Test;
+
+import com.coding.basic.Stack;
+
+//
+public class StackTest {
+
+	@Test
+	public void testPush() {
+		Stack stack = new Stack();
+		assertEquals(0, stack.size());
+		stack.push(new Object());
+		assertEquals(1, stack.size());
+	}
+
+	@Test
+	public void testPop() {
+		Stack stack = new Stack();
+		stack.push(new Object());
+		assertNotNull(stack.pop());
+		assertEquals(0, stack.size());
+	}
+
+	@Test
+	public void testPeek() {
+		Stack stack = new Stack();
+		int tmp = 0;
+		try {
+			stack.peek();
+		} catch (EmptyStackException e) {
+			tmp = 1;
+			assertEquals(1, tmp);
+		}
+		stack.push(new Object());
+		assertNotNull(stack.peek());
+		assertEquals(1, stack.size());
+	}
+
+	@Test
+	public void testIsEmpty() {
+		Stack stack = new Stack();
+		assertTrue(stack.isEmpty());
+		stack.push(new Object());
+		assertFalse(stack.isEmpty());
+	}
+
+	@Test
+	public void testSize() {
+		Stack stack = new Stack();
+		assertEquals(0, stack.size());
+	}
+}
diff --git "a/group07/178007127/git\345\221\275\344\273\244.txt" "b/group07/178007127/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/178007127/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/20409287/git\345\221\275\344\273\244.txt" "b/group07/20409287/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/20409287/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/2306826375/git\345\221\275\344\273\244.txt" "b/group07/2306826375/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/2306826375/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git a/group07/2306826375/txt b/group07/2306826375/txt
new file mode 100644
index 0000000000..d6459e0054
--- /dev/null
+++ b/group07/2306826375/txt
@@ -0,0 +1 @@
+xxx
diff --git "a/group07/2708094737/git\345\221\275\344\273\244.txt" "b/group07/2708094737/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/2708094737/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/2915553181/git\345\221\275\344\273\244.txt" "b/group07/2915553181/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/2915553181/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/328536398/git\345\221\275\344\273\244.txt" "b/group07/328536398/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/328536398/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/396868934/git\345\221\275\344\273\244.txt" "b/group07/396868934/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/396868934/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/43819473/git\345\221\275\344\273\244.txt" "b/group07/43819473/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/43819473/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/466199956/git\345\221\275\344\273\244.txt" "b/group07/466199956/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/466199956/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git a/group07/476770768/MyDataStructure/.classpath b/group07/476770768/MyDataStructure/.classpath
new file mode 100644
index 0000000000..63b7e892d1
--- /dev/null
+++ b/group07/476770768/MyDataStructure/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group07/476770768/MyDataStructure/.gitignore b/group07/476770768/MyDataStructure/.gitignore
new file mode 100644
index 0000000000..c910559f7f
--- /dev/null
+++ b/group07/476770768/MyDataStructure/.gitignore
@@ -0,0 +1,17 @@
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+#ide config
+.metadata
+.recommenders
+/bin/
diff --git a/group07/476770768/MyDataStructure/.project b/group07/476770768/MyDataStructure/.project
new file mode 100644
index 0000000000..b2d0b8054f
--- /dev/null
+++ b/group07/476770768/MyDataStructure/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>MyDataStructure</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group07/476770768/MyDataStructure/.settings/org.eclipse.jdt.core.prefs b/group07/476770768/MyDataStructure/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..bb35fa0a87
--- /dev/null
+++ b/group07/476770768/MyDataStructure/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/group07/476770768/MyDataStructure/src/com/coding/basic/BinaryTreeNode.java b/group07/476770768/MyDataStructure/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..6cc4ecb4df
--- /dev/null
+++ b/group07/476770768/MyDataStructure/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,44 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	private Object data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+
+	public void insert(BinaryTreeNode node) {
+		if (this.data == null) {
+			// empty binary tree
+			this.data = node.data;
+			this.left = node.left;
+			this.right = node.right;
+		} else if (((Integer) this.data).intValue() >= ((Integer) node.data).intValue()) {
+			this.left.insert(node);
+		}else{
+			this.right.insert(node);
+		}
+	}
+
+	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;
+	}
+}
diff --git a/group07/476770768/MyDataStructure/src/com/coding/basic/MyArrayList.java b/group07/476770768/MyDataStructure/src/com/coding/basic/MyArrayList.java
new file mode 100644
index 0000000000..f0c1b3608c
--- /dev/null
+++ b/group07/476770768/MyDataStructure/src/com/coding/basic/MyArrayList.java
@@ -0,0 +1,149 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+public class MyArrayList implements MyList{
+
+	private int size = 0;
+	
+	private Object[] elementData = new Object[5];
+	
+	@Override
+	/**
+	 * add an element to the end
+	 */
+	public void add(Object o) {
+		int index = size;
+		if(isFull()){
+			extendLength();
+		}
+		elementData[index] = o;
+		size++;
+	}
+
+	@Override
+	/**
+	 * add an element to certain index
+	 */
+	public void add(int index, Object o) {
+		checkBounds(index);
+		if(isFull()){
+			extendLength();
+		}
+		for(int i=size; i>=index; i--){
+			elementData[i+1] = elementData[i];
+		}
+		elementData[index] = o;
+		size++;
+	}
+
+	@Override
+	/**
+	 * get an element
+	 */
+	public Object get(int index) {
+		checkBoundsForGet(index);
+		if(index >= size){
+			return null;
+		}
+		return elementData[index];
+	}
+
+	@Override
+	/**
+	 * remove an element
+	 */
+	public Object remove(int index) {
+		checkBounds(index);
+		Object res = elementData[index];
+		for(int i=index+1; i<=size; i++){
+			elementData[i-1] = elementData[i];
+		}
+		size--;
+		return res;
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+	
+	/**
+	 * extends the length
+	 */
+	public void extendLength(){
+		elementData = Arrays.copyOf(elementData, elementData.length * 2);
+		//System.out.println("add extend "+elementData.length);
+	}
+	
+	public boolean isEmpty(){
+		return size == 0;
+	}
+	
+	public boolean isFull(){
+		int len = elementData.length;
+		if(size >= len-1){
+			return true;
+		}
+		return false;
+	}
+	
+	public void checkBounds(int index){
+		if(index >= size || index < 0){
+			//System.out.println("From MyArrayList: Index out of bounds");
+			throw new IndexOutOfBoundsException(OutOfBoundsMsg(index));
+		}
+	}
+	
+	/**
+	 * for get()
+	 * @param index
+	 */
+	public void checkBoundsForGet(int index){
+		if(index >= elementData.length || index < 0){
+			//System.out.println("From MyArrayList: Index out of bounds");
+			throw new IndexOutOfBoundsException(OutOfBoundsMsg(index));
+		}
+	}
+	
+	public String OutOfBoundsMsg(int index){
+		return "Index: "+index+", Size: "+size;
+	}
+
+	@Override
+	public String toString() {
+		String s = "";
+		for(int i=0; i<size; i++){
+			s += elementData[i] + " ";
+		}
+		return s;
+	}
+	
+	public MyIterator iterator() {
+		return new ArrayListIterator(this);
+	}
+	
+	private class ArrayListIterator implements MyIterator{
+		
+		private MyArrayList eleIterator;
+		int pos;//current position
+		int len;//size of elementData
+				
+		private ArrayListIterator(MyArrayList mal){
+			eleIterator = mal;
+			pos = 0;
+			len = mal.size();
+		}
+		
+		@Override
+		public boolean hasNext() {
+			return pos < len;
+		}
+
+		@Override
+		public Object next() {
+			return eleIterator.get(pos++);
+		}
+		
+	}
+}
diff --git a/group07/476770768/MyDataStructure/src/com/coding/basic/MyIterator.java b/group07/476770768/MyDataStructure/src/com/coding/basic/MyIterator.java
new file mode 100644
index 0000000000..a2321e842f
--- /dev/null
+++ b/group07/476770768/MyDataStructure/src/com/coding/basic/MyIterator.java
@@ -0,0 +1,6 @@
+package com.coding.basic;
+
+public interface MyIterator {
+	public boolean hasNext();
+	public Object next();
+}
diff --git a/group07/476770768/MyDataStructure/src/com/coding/basic/MyLinkedList.java b/group07/476770768/MyDataStructure/src/com/coding/basic/MyLinkedList.java
new file mode 100644
index 0000000000..297c97a3ed
--- /dev/null
+++ b/group07/476770768/MyDataStructure/src/com/coding/basic/MyLinkedList.java
@@ -0,0 +1,223 @@
+package com.coding.basic;
+
+public class MyLinkedList implements MyList {
+	private int size = 0;
+	private Node head;
+	private Node tail;
+
+	@Override
+	public void add(Object o) {
+		if (isEmpty()) {
+			head = new Node(o);
+			tail = head;
+		} else {
+			Node tmp = new Node(o);
+			tail.next = tmp;
+			tmp.prov = tail;
+			tail = tmp;
+		}
+		size++;
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		checkBoundsForAdd(index);
+		if (index == 0) {
+			addFirst(o);
+		} else if (index == size) {
+			addLast(o);
+		} else {
+			Node pos = findIndexPosition(index);
+			addMid(pos, o);
+		}
+		size++;
+	}
+
+	/**
+	 * add node to the head
+	 */
+	public void addFirst(Object o) {
+		Node tmp = new Node(o);
+		tmp.next = head;
+		head.prov = tmp;
+		head = tmp;
+	}
+
+	/**
+	 * add node to the last
+	 */
+	public void addLast(Object o) {
+		Node tmp = new Node(o);
+		tail.next = tmp;
+		tmp.prov = tail;
+		tail = tmp;
+	}
+
+	/**
+	 * add node to middle position
+	 * 
+	 * @param pos
+	 * @param o
+	 */
+	public void addMid(Node pos, Object o) {
+		Node tmp = new Node(o);
+		tmp.prov = pos.prov;
+		pos.prov.next = tmp;
+		tmp.next = pos;
+		pos.prov = tmp;
+	}
+
+	@Override
+	public Node get(int index) {
+		checkBounds(index);
+		if (index == 0) {
+			return head;
+		} else {
+			Node pos = findIndexPosition(index);
+			return pos;
+		}
+	}
+
+	@Override
+	public Object remove(int index) {
+		checkBounds(index);
+		Node res;
+		if (index == 0) {
+			res = removeFirst();
+		} else if (index == size-1) {
+			res = removeLast();
+		} else {
+			Node pos = findIndexPosition(index);
+			res = removeMid(pos);
+		}
+		size--;
+		return res;
+	}
+
+	public Node removeFirst() {
+		Node tmp = head;
+		head = head.next;
+		head.prov = null;
+		return tmp;
+	}
+
+	public Node removeLast() {
+		Node tmp = tail;
+		tail = tail.prov;
+		tail.next = null;
+		return tmp;
+
+	}
+
+	public Node removeMid(Node pos) {
+		pos.prov.next = pos.next;
+		pos.next.prov = pos.prov;
+		return pos;
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+
+	public boolean isEmpty() {
+		return head == null;
+	}
+
+	/**
+	 * the index should be within 0~size-1
+	 * 
+	 * @param index
+	 */
+	public void checkBounds(int index) {
+		if (index < 0 || index > size - 1) {
+			// System.out.println("From MyLinkedList: Index out of bounds");
+			throw new IndexOutOfBoundsException(OutOfBoundsMsg(index));
+		}
+	}
+
+	/**
+	 * the index should be within 0~size
+	 * 
+	 * @param index
+	 */
+	public void checkBoundsForAdd(int index) {
+		if (index < 0 || index > size) {
+			// System.out.println("From MyLinkedList: Index out of bounds");
+			throw new IndexOutOfBoundsException(OutOfBoundsMsg(index));
+		}
+	}
+
+	public String OutOfBoundsMsg(int index) {
+		return "Index: " + index + ", Size: " + size;
+	}
+
+	/**
+	 * find the position of index
+	 * 
+	 * @param index
+	 * @return
+	 */
+	public Node findIndexPosition(int index) {
+		Node pos = head;
+		for (int i = 0; i < index; i++) {
+			pos = pos.next;
+		}
+		return pos;
+	}
+
+	@Override
+	public String toString() {
+		String s = "";
+		Node tmp = head;
+		while (tmp != null) {
+			s += tmp.data + " ";
+			tmp = tmp.next;
+		}
+		return s;
+	}
+
+	private static class Node {
+		public Object data;
+		public Node prov;
+		public Node next;
+
+		public Node() {
+		}
+
+		public Node(Object o) {
+			this.data = o;
+			this.prov = null;
+			this.next = null;
+		}
+	}
+	
+	public MyIterator iterator() {
+		return new LinkedListIterator(this);
+	}
+	
+	private class LinkedListIterator implements MyIterator{
+		
+		private MyLinkedList eleIterator;
+		private Node pos;
+		
+		private LinkedListIterator(MyLinkedList mll){
+			this.eleIterator = mll;
+			this.pos = eleIterator.get(0);
+		}
+		
+		@Override
+		public boolean hasNext() {
+			return pos != null;
+		}
+
+		@Override
+		public Object next() {
+			Node res = pos;
+			pos = pos.next;
+			return res;
+		}
+		
+	}
+
+}
diff --git a/group07/476770768/MyDataStructure/src/com/coding/basic/MyList.java b/group07/476770768/MyDataStructure/src/com/coding/basic/MyList.java
new file mode 100644
index 0000000000..9089e106db
--- /dev/null
+++ b/group07/476770768/MyDataStructure/src/com/coding/basic/MyList.java
@@ -0,0 +1,9 @@
+package com.coding.basic;
+
+public interface MyList {
+	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/group07/476770768/MyDataStructure/src/com/coding/basic/MyQueue.java b/group07/476770768/MyDataStructure/src/com/coding/basic/MyQueue.java
new file mode 100644
index 0000000000..717c67bd4b
--- /dev/null
+++ b/group07/476770768/MyDataStructure/src/com/coding/basic/MyQueue.java
@@ -0,0 +1,30 @@
+package com.coding.basic;
+
+public class MyQueue {
+	
+	private MyLinkedList elementData = new MyLinkedList();
+	
+	public void enQueue(Object o){
+		elementData.add(o);
+	}
+	
+	public Object deQueue(){
+		//if queue is empty, element.size()-1 = -1
+		//MyLinkedList will throw exception
+		Object tmp = elementData.remove(elementData.size()-1);
+		return tmp;
+	}
+	
+	public boolean isEmpty(){
+		return elementData.isEmpty();
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+	
+	public MyIterator iterator() {
+		return elementData.iterator();
+	}
+
+}
diff --git a/group07/476770768/MyDataStructure/src/com/coding/basic/MyStack.java b/group07/476770768/MyDataStructure/src/com/coding/basic/MyStack.java
new file mode 100644
index 0000000000..3d9e1ef9a0
--- /dev/null
+++ b/group07/476770768/MyDataStructure/src/com/coding/basic/MyStack.java
@@ -0,0 +1,44 @@
+package com.coding.basic;
+
+import java.util.EmptyStackException;
+
+public class MyStack {
+	private MyArrayList elementData = new MyArrayList();
+	int top = -1;//always points to top element
+	
+	public void push(Object o){
+		elementData.add(o);
+		top++;
+	}
+	
+	public Object pop(){
+		if(isEmpty()){
+			throw new EmptyStackException();
+		}else{
+			Object tmp = elementData.remove(top);
+			top--;
+			return tmp;
+		}
+	}
+	
+	public Object peek(){
+		if(isEmpty()){
+			throw new EmptyStackException();
+		}else{
+			Object tmp = elementData.get(top);
+			return tmp;
+		}
+	}
+	
+	public boolean isEmpty(){
+		return top >= 0;
+	}
+	
+	public int size(){
+		return top + 1;
+	}
+	
+	public MyIterator iterator() {
+		return elementData.iterator();
+	}
+}
diff --git a/group07/476770768/MyDataStructure/src/com/coding/basic/testFile.java b/group07/476770768/MyDataStructure/src/com/coding/basic/testFile.java
new file mode 100644
index 0000000000..1ccabfc977
--- /dev/null
+++ b/group07/476770768/MyDataStructure/src/com/coding/basic/testFile.java
@@ -0,0 +1,23 @@
+package com.coding.basic;
+
+public class testFile {
+
+	public static void main(String[] args) {
+		MyLinkedList mll = new MyLinkedList();
+		mll.add(new Integer(5));
+		mll.add(new Integer(2));
+		mll.add(new Integer(3));
+		mll.add(new Integer(4));
+		System.out.println(mll);
+		MyIterator mIt = mll.iterator();
+		while(mIt.hasNext()){
+			System.out.println(mIt.next());
+		}
+		mll.remove(3);
+		System.out.println(mll);
+		
+		
+		
+	}
+
+}
diff --git "a/group07/476770768/git\345\221\275\344\273\244.txt" "b/group07/476770768/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/476770768/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/515372252/git\345\221\275\344\273\244.txt" "b/group07/515372252/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/515372252/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/562247675/git\345\221\275\344\273\244.txt" "b/group07/562247675/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/562247675/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git a/group07/562247675/homework/.gitignore b/group07/562247675/homework/.gitignore
new file mode 100644
index 0000000000..df3ade545c
--- /dev/null
+++ b/group07/562247675/homework/.gitignore
@@ -0,0 +1,22 @@
+rebel.xml
+.idea/
+*.iml
+target/
+*.class
+*.jar
+*.war
+*.ear
+hs_err_pid*
+*.DS_Store
+._*
+.Trashes
+.TemporaryItems
+desktop.ini
+Thumbs.db
+$RECYCLE.BIN/
+*.lnk
+.metadata
+.settings
+.classpath
+.mymetadata
+.project
\ No newline at end of file
diff --git a/group07/562247675/homework/homework-0226/pom.xml b/group07/562247675/homework/homework-0226/pom.xml
new file mode 100644
index 0000000000..f6a6002f6d
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/pom.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+     http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>com.coding2017.group7</groupId>
+        <artifactId>homework</artifactId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.coding2017.group7</groupId>
+    <artifactId>homework-0226</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+        </dependency>
+    </dependencies>
+
+</project>
\ No newline at end of file
diff --git a/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyArrayList.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyArrayList.java
new file mode 100644
index 0000000000..05d3d80d49
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyArrayList.java
@@ -0,0 +1,98 @@
+package com.coding2017.group7.homework.c0226;
+
+import java.util.Arrays;
+
+public class MyArrayList implements MyList {
+
+    private int size = 0;
+
+    private Object[] elementData = new Object[10];
+
+    @Override
+    public void add(Object o) {
+        if (isFull()) {
+            increase();
+        }
+        elementData[size++] = o;
+    }
+
+    @Override
+    public void add(int index, Object o) {
+        checkRangeAdd(index);
+        if (isFull()) {
+            increase();
+        }
+        System.arraycopy(elementData, index, elementData, index + 1, size - index);
+        elementData[index] = o;
+        size++;
+    }
+
+    @Override
+    public Object get(int index) {
+        checkRangeGet(index);
+        return elementData[index];
+    }
+
+    @Override
+    public Object remove(int index) {
+        checkRangeGet(index);
+        Object element = elementData[index];
+        System.arraycopy(elementData, index + 1, elementData, index, size - (index + 1));
+        elementData[--size] = null;
+        return element;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    public MyIterator iterator() {
+        return new MyArrayListIterator();
+    }
+
+    private boolean isFull() {
+        return size >= elementData.length;
+    }
+
+    private void checkRangeGet(int index) {
+        boolean outOfRange = index < 0 || index >= size;
+        if (outOfRange) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+        }
+    }
+
+    private void checkRangeAdd(int index) {
+        boolean outOfRange = index < 0 || index > size;
+        if (outOfRange) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+        }
+    }
+
+    private void increase() {
+        Object[] target = new Object[elementData.length * 2];
+        System.arraycopy(elementData, 0, target, 0, elementData.length);
+        elementData = target;
+    }
+
+    @Override
+    public String toString() {
+        return Arrays.toString(elementData);
+    }
+
+    private class MyArrayListIterator implements MyIterator {
+
+        private int index = 0;
+
+        @Override
+        public boolean hasNext() {
+            return index < size;
+        }
+
+        @Override
+        public Object next() {
+            checkRangeGet(index);
+            return elementData[index++];
+        }
+    }
+}
diff --git a/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyArrayListTest.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyArrayListTest.java
new file mode 100644
index 0000000000..7523092985
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyArrayListTest.java
@@ -0,0 +1,71 @@
+package com.coding2017.group7.homework.c0226;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class MyArrayListTest {
+
+    private MyArrayList myList = new MyArrayList();
+    private Object[] elements = new Object[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+    private final int mySize = elements.length;
+
+    @Before
+    public void setUp() throws Exception {
+        for (int i = 0; i < mySize; i++) {
+            myList.add(i, i + 1);
+        }
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        for (int i = myList.size(); i > 0; i--) {
+            myList.remove(i - 1);
+        }
+        myList = null;
+    }
+
+    @Test
+    public void addLast() throws Exception {
+        int element = -1;
+        myList.add(element);
+        Assert.assertEquals(myList.size(), mySize + 1);
+        Assert.assertTrue(myList.get(myList.size() - 1).equals(element));
+    }
+
+    @Test
+    public void addIndex() throws Exception {
+        int index = mySize / 2;
+        int element = -1;
+        myList.add(index, element);
+        Assert.assertTrue(myList.get(index).equals(element));
+        Assert.assertEquals(myList.size(), mySize + 1);
+    }
+
+    @Test
+    public void remove() throws Exception {
+        int index = mySize / 2;
+        Object before = myList.get(index + 1);
+        Object element = myList.remove(index);
+        Object after = myList.get(index);
+        Assert.assertTrue(before.equals(after));
+        Assert.assertEquals(myList.size(), mySize - 1);
+
+    }
+
+    @Test
+    public void iterator() throws Exception {
+        MyIterator iterator = myList.iterator();
+        int count = 0;
+        while (iterator.hasNext()) {
+            iterator.next();
+            count++;
+        }
+        Assert.assertEquals(mySize, count);
+    }
+
+}
\ No newline at end of file
diff --git a/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyBinaryTreeNode.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyBinaryTreeNode.java
new file mode 100644
index 0000000000..334dcd06de
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyBinaryTreeNode.java
@@ -0,0 +1,52 @@
+package com.coding2017.group7.homework.c0226;
+
+public class MyBinaryTreeNode {
+
+    private Comparable data;
+    private MyBinaryTreeNode left;
+    private MyBinaryTreeNode right;
+
+    public Comparable getData() {
+        return data;
+    }
+
+    public void setData(Comparable data) {
+        this.data = data;
+    }
+
+    public MyBinaryTreeNode getLeft() {
+        return left;
+    }
+
+    public void setLeft(MyBinaryTreeNode left) {
+        this.left = left;
+    }
+
+    public MyBinaryTreeNode getRight() {
+        return right;
+    }
+
+    public void setRight(MyBinaryTreeNode right) {
+        this.right = right;
+    }
+
+    public MyBinaryTreeNode insert(Comparable o) {
+        if (data == null) {
+            data = o;
+        }
+        int compare = o.compareTo(data);
+        if (compare < 0) {
+            if (left == null) {
+                left = new MyBinaryTreeNode();
+            }
+            left.insert(o);
+        } else if (compare > 0) {
+            if (right == null) {
+                right = new MyBinaryTreeNode();
+            }
+            right.insert(o);
+        }
+        return this;
+    }
+
+}
diff --git a/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyBinaryTreeNodeTest.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyBinaryTreeNodeTest.java
new file mode 100644
index 0000000000..9766b03947
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyBinaryTreeNodeTest.java
@@ -0,0 +1,34 @@
+package com.coding2017.group7.homework.c0226;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MyBinaryTreeNodeTest {
+
+
+    @Test
+    public void insert() throws Exception {
+        MyBinaryTreeNode node = new MyBinaryTreeNode();
+        node.insert(5)
+                .insert(2)
+                .insert(7)
+                .insert(1)
+                .insert(6)
+                .insert(4)
+                .insert(8)
+                .insert(3);
+        Comparable data1 = node.getLeft().getLeft().getData();
+        Comparable data4 = node.getLeft().getRight().getData();
+        Comparable data6 = node.getRight().getLeft().getData();
+        Comparable data8 = node.getRight().getRight().getData();
+        Comparable data3 = node.getLeft().getRight().getLeft().getData();
+        Assert.assertEquals(1, data1);
+        Assert.assertEquals(4, data4);
+        Assert.assertEquals(6, data6);
+        Assert.assertEquals(8, data8);
+        Assert.assertEquals(3, data3);
+
+    }
+
+
+}
\ No newline at end of file
diff --git a/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyIterator.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyIterator.java
new file mode 100644
index 0000000000..9ecc4d3a7f
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyIterator.java
@@ -0,0 +1,8 @@
+package com.coding2017.group7.homework.c0226;
+
+public interface MyIterator {
+    public boolean hasNext();
+
+    public Object next();
+
+}
diff --git a/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyLinkedList.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyLinkedList.java
new file mode 100644
index 0000000000..6b8a9ed197
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyLinkedList.java
@@ -0,0 +1,150 @@
+package com.coding2017.group7.homework.c0226;
+
+public class MyLinkedList implements MyList {
+
+    private Node head = new Node();
+    private int size = 0;
+
+    @Override
+    public void add(Object o) {
+        Node node = new Node();
+        node.data = o;
+        Node last = find(size - 1);
+        last.next = node;
+        size++;
+    }
+
+    @Override
+    public void add(int index, Object o) {
+        checkRangeAdd(index);
+        Node insert = find(index);
+        Node before = find(index - 1);
+        Node node = new Node();
+        node.data = o;
+        node.next = insert;
+        before.next = node;
+        size++;
+    }
+
+    @Override
+    public Object get(int index) {
+        checkRangeGet(index);
+        return find(index).data;
+    }
+
+    @Override
+    public Object remove(int index) {
+        checkRangeGet(index);
+        Node before = find(index - 1);
+        Node remove = find(index);
+        Node after = find(index + 1);
+        before.next = after;
+        size--;
+        return remove.data;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    public void addFirst(Object o) {
+        Node node = new Node();
+        node.data = o;
+        node.next = find(0);
+        head.next = node;
+        size++;
+    }
+
+    public void addLast(Object o) {
+        Node last = find(size - 1);
+        Node node = new Node();
+        node.data = o;
+        last.next = node;
+        size++;
+    }
+
+    public Object removeFirst() {
+        checkRangeGet(size - 1);
+        Node remove = find(0);
+        head.next = find(1);
+        size--;
+        return remove.data;
+    }
+
+    public Object removeLast() {
+        checkRangeGet(size - 1);
+        Node remove = find(size - 1);
+        Node before = find(size - 2);
+        before.next = null;
+        size--;
+        return remove.data;
+    }
+
+    public MyIterator iterator() {
+        return new MyLinkedListIterator();
+    }
+
+    private void checkRangeGet(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size:" + size);
+        }
+    }
+
+    private void checkRangeAdd(int index) {
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size:" + size);
+        }
+    }
+    private Node find(int index) {
+        Node node = head;
+        int pos = -1;
+        while (pos < index) {
+            node = node.next;
+            pos++;
+        }
+        return node;
+    }
+
+    @Override
+    public String toString() {
+        Node node = head;
+        StringBuilder sBuilder = new StringBuilder();
+        while (node.next != null) {
+            node = node.next;
+            sBuilder.append(node.data).append(", ");
+        }
+        int length = sBuilder.length();
+        if (length > 0) {
+            sBuilder.delete(length - 2, length);
+        }
+        return "[" + sBuilder.toString() + "]";
+    }
+
+    private static class Node {
+        Object data;
+        Node next;
+
+    }
+
+
+    private class MyLinkedListIterator implements MyIterator {
+
+
+        private Node node = head;
+        private int size = 0;
+
+        @Override
+        public boolean hasNext() {
+            return node.next != null;
+        }
+
+        @Override
+        public Object next() {
+            checkRangeGet(size);
+            node = node.next;
+            size++;
+            return node.data;
+        }
+    }
+}
diff --git a/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyLinkedListTest.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyLinkedListTest.java
new file mode 100644
index 0000000000..fe7d9ba28b
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyLinkedListTest.java
@@ -0,0 +1,108 @@
+package com.coding2017.group7.homework.c0226;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class MyLinkedListTest {
+
+    private MyLinkedList myList = new MyLinkedList();
+    private Object[] elements = new Object[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+    private final int mySize = elements.length;
+
+    @Before
+    public void setUp() throws Exception {
+        for (int i = 0; i < mySize; i++) {
+            myList.add(i, i + 1);
+        }
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        for (int i = myList.size(); i > 0; i--) {
+            myList.remove(i - 1);
+        }
+        myList = null;
+    }
+
+    @Test
+    public void add() throws Exception {
+        myList.add(-1);
+        Assert.assertEquals(myList.size(), mySize + 1);
+    }
+
+    @Test
+    public void addIndex() throws Exception {
+        int pos = mySize / 2;
+        Object before = myList.get(pos);
+        myList.add(pos, -1);
+        Object after = myList.get(pos + 1);
+        Assert.assertEquals(myList.size(), mySize + 1);
+        Assert.assertEquals(before, after);
+    }
+
+    @Test
+    public void remove() throws Exception {
+        myList.remove(0);
+        myList.remove(myList.size() - 1);
+        myList.remove(myList.size() / 2);
+        Assert.assertEquals(myList.size(), mySize - 3);
+    }
+
+    @Test
+    public void addFirst() throws Exception {
+        myList.addFirst(-1);
+        myList.addFirst(-1);
+        myList.addFirst(-1);
+        Object o1 = myList.get(0);
+        Object o2 = myList.get(1);
+        Object o3 = myList.get(2);
+        Assert.assertTrue(o1.equals(o2));
+        Assert.assertTrue(o2.equals(o3));
+        Assert.assertTrue(o3.equals(-1));
+        Assert.assertEquals(myList.size(), mySize + 3);
+    }
+
+    @Test
+    public void addLast() throws Exception {
+        myList.addLast(-1);
+        myList.addLast(-1);
+        myList.addLast(-1);
+        Object o1 = myList.get(myList.size() - 1);
+        Object o2 = myList.get(myList.size() - 2);
+        Object o3 = myList.get(myList.size() - 3);
+        Assert.assertTrue(o1.equals(o2));
+        Assert.assertTrue(o2.equals(o3));
+        Assert.assertTrue(o3.equals(-1));
+        Assert.assertEquals(myList.size(), mySize + 3);
+    }
+
+    @Test
+    public void removeFirst() throws Exception {
+        myList.addFirst(-1);
+        Object o = myList.removeFirst();
+        Assert.assertTrue(o.equals(-1));
+        Assert.assertEquals(myList.size(), mySize);
+    }
+
+    @Test
+    public void removeLast() throws Exception {
+        myList.addLast(-1);
+        Object o = myList.removeLast();
+        Assert.assertTrue(o.equals(-1));
+        Assert.assertEquals(myList.size(), mySize);
+    }
+
+    @Test
+    public void iterator() throws Exception {
+        MyIterator iterator = myList.iterator();
+        int count = 0;
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next());
+            count++;
+        }
+        Assert.assertEquals(mySize, count);
+    }
+
+}
\ No newline at end of file
diff --git a/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyList.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyList.java
new file mode 100644
index 0000000000..7532313b89
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyList.java
@@ -0,0 +1,13 @@
+package com.coding2017.group7.homework.c0226;
+
+public interface MyList {
+    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/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyQueue.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyQueue.java
new file mode 100644
index 0000000000..c701c032b8
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyQueue.java
@@ -0,0 +1,35 @@
+package com.coding2017.group7.homework.c0226;
+
+import java.util.EmptyStackException;
+
+public class MyQueue {
+
+    private MyLinkedList myLinkedList = new MyLinkedList();
+
+    public void enQueue(Object o) {
+        myLinkedList.add(0, o);
+    }
+
+    public Object deQueue() {
+        if (isEmpty()) {
+            throw new EmptyQueueException();
+        }
+        return myLinkedList.removeLast();
+    }
+
+    public boolean isEmpty() {
+        return myLinkedList.size() <= 0;
+    }
+
+    public int size() {
+        return myLinkedList.size();
+    }
+
+    private static class EmptyQueueException extends EmptyStackException {
+    }
+
+    @Override
+    public String toString() {
+        return myLinkedList.toString();
+    }
+}
diff --git a/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyQueueTest.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyQueueTest.java
new file mode 100644
index 0000000000..6bcae88530
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyQueueTest.java
@@ -0,0 +1,48 @@
+package com.coding2017.group7.homework.c0226;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class MyQueueTest {
+
+    private MyQueue myQueue = new MyQueue();
+    private final Object[] elements = {1, 2, 3};
+    private final int mySize = elements.length;
+
+    @Before
+    public void setUp() throws Exception {
+        for (int i = 0; i < mySize; i++) {
+            myQueue.enQueue(i + 1);
+        }
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        for (int i = myQueue.size(); i > 0; i--) {
+            myQueue.deQueue();
+        }
+    }
+
+    @Test
+    public void enQueue() throws Exception {
+        myQueue.enQueue(-1);
+        Object o = 0;
+        for (int i = myQueue.size(); i > 0; i--) {
+            o = myQueue.deQueue();
+        }
+        Assert.assertTrue(o.equals(-1));
+    }
+
+    @Test
+    public void deQueue() throws Exception {
+        myQueue.enQueue(-1);
+        Object o = myQueue.deQueue();
+        Assert.assertTrue(o.equals(elements[0]));
+    }
+
+}
\ No newline at end of file
diff --git a/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyStack.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyStack.java
new file mode 100644
index 0000000000..18c10704a7
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyStack.java
@@ -0,0 +1,40 @@
+package com.coding2017.group7.homework.c0226;
+
+import java.util.EmptyStackException;
+
+public class MyStack {
+    private MyArrayList elementData = new MyArrayList();
+    private final int first = 0;
+
+    public void push(Object o) {
+
+        elementData.add(first, o);
+    }
+
+    public Object pop() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        return elementData.remove(first);
+    }
+
+    public Object peek() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        return elementData.get(first);
+    }
+
+    public boolean isEmpty() {
+        return elementData.size() <= 0;
+    }
+
+    public int size() {
+        return elementData.size();
+    }
+
+    @Override
+    public String toString() {
+        return elementData.toString();
+    }
+}
diff --git a/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyStackTest.java b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyStackTest.java
new file mode 100644
index 0000000000..d29031be60
--- /dev/null
+++ b/group07/562247675/homework/homework-0226/src/main/java/com/coding2017/group7/homework/c0226/MyStackTest.java
@@ -0,0 +1,50 @@
+package com.coding2017.group7.homework.c0226;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class MyStackTest {
+    private MyStack myStack = new MyStack();
+    private Object[] elements = new Object[]{1};
+    private final int mySize = elements.length;
+
+    @Before
+    public void setUp() throws Exception {
+        for (int i = 0; i < mySize; i++) {
+            myStack.push(i + 1);
+        }
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        for (int i = myStack.size(); i > 0; i--) {
+            myStack.pop();
+        }
+    }
+
+    @Test
+    public void push() throws Exception {
+        myStack.push(-1);
+        Assert.assertTrue(myStack.pop().equals(-1));
+    }
+
+    @Test
+    public void pop() throws Exception {
+        for (int i = myStack.size(); i > 0; i--) {
+            myStack.pop();
+        }
+        Assert.assertEquals(myStack.size(), 0);
+    }
+
+    @Test
+    public void peek() throws Exception {
+        for (int i = 0; i < myStack.size(); i++) {
+            Object peek = myStack.peek();
+            Assert.assertTrue(peek.equals(elements[i]));
+        }
+        Assert.assertEquals(myStack.size(), mySize);
+    }
+
+}
\ No newline at end of file
diff --git a/group07/562247675/homework/homework-0226/src/main/resources/readme.md b/group07/562247675/homework/homework-0226/src/main/resources/readme.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/group07/562247675/homework/homework-0226/src/test/resources/readme.md b/group07/562247675/homework/homework-0226/src/test/resources/readme.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/group07/562247675/homework/pom.xml b/group07/562247675/homework/pom.xml
new file mode 100644
index 0000000000..17a2c5f0fd
--- /dev/null
+++ b/group07/562247675/homework/pom.xml
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+     http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.coding2017.group7</groupId>
+    <artifactId>homework</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <modules>
+        <module>homework-0226</module>
+    </modules>
+
+    <packaging>pom</packaging>
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.6</maven.compiler.source>
+        <maven.compiler.target>1.6</maven.compiler.target>
+    </properties>
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>junit</groupId>
+                <artifactId>junit</artifactId>
+                <version>4.12</version>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-compiler-plugin</artifactId>
+                    <configuration>
+                        <source>${maven.compiler.source}</source>
+                        <target>${maven.compiler.target}</target>
+                        <encoding>${project.build.sourceEncoding}</encoding>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/group07/562247675/homework/readme.md b/group07/562247675/homework/readme.md
new file mode 100644
index 0000000000..2a54b7ef9a
--- /dev/null
+++ b/group07/562247675/homework/readme.md
@@ -0,0 +1 @@
+# Homework
\ No newline at end of file
diff --git a/group07/562247675/notebook/readme.md b/group07/562247675/notebook/readme.md
new file mode 100644
index 0000000000..d36f4b9c53
--- /dev/null
+++ b/group07/562247675/notebook/readme.md
@@ -0,0 +1 @@
+# Notebook
\ No newline at end of file
diff --git "a/group07/598812995/git\345\221\275\344\273\244.txt" "b/group07/598812995/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/598812995/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/603622009/git\345\221\275\344\273\244.txt" "b/group07/603622009/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/603622009/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/724319952/git\345\221\275\344\273\244.txt" "b/group07/724319952/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/724319952/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git "a/group07/752262774/git\345\221\275\344\273\244.txt" "b/group07/752262774/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/752262774/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git a/group07/764189149/.classpath b/group07/764189149/.classpath
new file mode 100644
index 0000000000..fb5011632c
--- /dev/null
+++ b/group07/764189149/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group07/764189149/.gitignore b/group07/764189149/.gitignore
new file mode 100644
index 0000000000..8d9372e204
--- /dev/null
+++ b/group07/764189149/.gitignore
@@ -0,0 +1,23 @@
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+/bin/
diff --git a/group07/764189149/.project b/group07/764189149/.project
new file mode 100644
index 0000000000..2076c6b51c
--- /dev/null
+++ b/group07/764189149/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>764189149Learning</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group07/764189149/src/firstHomeWork/util/ArrayList.java b/group07/764189149/src/firstHomeWork/util/ArrayList.java
new file mode 100644
index 0000000000..88b97d828f
--- /dev/null
+++ b/group07/764189149/src/firstHomeWork/util/ArrayList.java
@@ -0,0 +1,197 @@
+package firstHomeWork.util;
+
+import java.util.NoSuchElementException;
+
+/**
+ * @Description: 基于数组的列表
+ * @author: leijing
+ * @date: 2017年2月21日 下午9:03:17
+ * @param <E>
+ */
+public class ArrayList<E> implements List<E> {
+	private static int initialCapacity = 10 ;//数组默认初始容量
+	Object[] elements;//元素的数组
+	private int size;//元素的个数
+	
+	public ArrayList(){
+		this(initialCapacity);
+	}
+	public ArrayList(int capacity){
+		elements = new Object[capacity];
+	}
+	private void ensureCapacity(int minCapacity){
+		if(minCapacity > 0){
+			
+		}
+	}
+	@Override
+	public boolean add(E e) {
+		ensureCapacity(size + 1);
+		elements[size++] = e;
+		return true;
+	}
+
+	@Override
+	public E remove(int index) {
+		rangeCheck(index);
+		E oldElement = (E) elements[index];
+		//将其后的元素前移
+		int needMovedNum = size - index - 1;
+		move(elements, index+1, elements,index, needMovedNum);
+		size--;
+		return oldElement;
+	}
+	
+	/**
+	 * @Description: 移动数组中的元素
+	 * @param src 原数组
+	 * @param from 复制元素起始下标
+	 * @param dest 目标元素数组
+	 * @param num 要复制的元素个数
+	 * @return: void
+	 * @author: leijing  
+	 * @date: 2017年2月22日 下午7:54:08
+	 */
+	private void move(Object[] src , int srcPosition , Object[] dest , int destPosition, int num){
+		for(int i = 0 ; i < num ; i ++){
+			dest[destPosition++] = src[srcPosition++];
+		}
+	}
+	
+	/**
+	 * @Description: 检查下标是否正确，如果越界抛出异常
+	 * @param index
+	 * @return: void
+	 * @author: leijing  
+	 * @date: 2017年2月22日 下午7:52:59
+	 */
+	private void rangeCheck(int index){
+		if(index < 0 || index > size){
+			throw new IndexOutOfBoundsException();
+		}
+	}
+
+	@Override
+	public boolean remove(Object o) {
+		if(o == null){
+			for (int index = 0; index < size; index++) {
+				if(elements[index] == null){
+					remove(index);
+					return true;
+				}
+			}
+		}else{
+			for (int index = 0; index < size; index++) {
+				if(o.equals(elements[index])){
+					remove(index);
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return size == 0;
+	}
+
+	@Override
+	public E get(int index) {
+		rangeCheck(index);
+		return (E) elements[index];
+	}
+
+	@Override
+	public E set(int index, E e) {
+		rangeCheck(index);
+		E oldElement = (E) elements[index];
+		elements[index] = e;
+		return oldElement;
+	}
+
+	@Override
+	public boolean contains(Object o) {
+		return indexOf(o) >= 0;
+	}
+	
+	private int indexOf(Object o){
+		if(o == null){
+			for (int index = 0; index < size; index++) {
+				if(elements[index] == null){
+					return index;
+				}
+			}
+		}else{
+			for (int index = 0; index < size; index++) {
+				if(o.equals(elements[index])){
+					return index;
+				}
+			}
+		}
+		return -1;
+	}
+
+	@Override
+	public void clear() {
+		for (int index = 0; index < size; index++) {
+			elements[index] = null;
+		}
+		size = 0;
+	}
+
+	@Override
+	public Iterator<E> iterator() {
+		return new ArraylistIterator();
+	}
+	
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		for (int index = 0; index < size; index++) {
+			if(index == size -1){
+				sb.append(elements[index]);
+			}else{
+				sb.append(elements[index]).append(",");
+			}
+			
+		}
+		return sb.toString();
+	}
+	private class ArraylistIterator implements Iterator<E>{
+		private int position;
+		
+		@Override
+		public boolean hasNext() {
+			return position != size;
+		}
+
+		@Override
+		public E next() {
+			Object[] elements = ArrayList.this.elements;
+			int i = position;
+			if(i >= size){
+				throw new NoSuchElementException();
+			}
+			position = i + 1;
+			return (E) elements[i+1];
+		}
+
+		@Override
+		public void remove() {
+			if(position > size){
+				throw new NoSuchElementException();
+			}
+			ArrayList.this.remove(position);
+		}
+		
+	}
+	
+	
+
+}
diff --git a/group07/764189149/src/firstHomeWork/util/BinaryTreeNode.java b/group07/764189149/src/firstHomeWork/util/BinaryTreeNode.java
new file mode 100644
index 0000000000..c7e85d4915
--- /dev/null
+++ b/group07/764189149/src/firstHomeWork/util/BinaryTreeNode.java
@@ -0,0 +1,31 @@
+package firstHomeWork.util;
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git a/group07/764189149/src/firstHomeWork/util/DoubleLinkedList.java b/group07/764189149/src/firstHomeWork/util/DoubleLinkedList.java
new file mode 100644
index 0000000000..9e83297a46
--- /dev/null
+++ b/group07/764189149/src/firstHomeWork/util/DoubleLinkedList.java
@@ -0,0 +1,335 @@
+package firstHomeWork.util;
+
+import java.util.NoSuchElementException;
+
+/**
+ * @Description: 双向链表
+ * @author: leijing
+ * @date: 2017年2月24日 上午11:37:58
+ * @param <E>
+ */
+public class DoubleLinkedList<E> {
+
+	private int size;//节点个数
+	private Node<E> head;//头节点
+	private Node<E> tail;//尾节点
+
+	public Node<E> getHead() {
+		return head;
+	}
+	public void setHead(Node<E> head) {
+		this.head = head;
+	}
+	public Node<E> getTail() {
+		return tail;
+	}
+	public void setTail(Node<E> tail) {
+		this.tail = tail;
+	}
+	/**
+	 * @Description: 添加元素到头部
+	 * @param e
+	 * @return: boolean
+	 * @author: leijing  
+	 * @date: 2017年2月24日 上午11:38:20
+	 */
+	public boolean addFirst(E e) {
+		Node<E> node = new Node<E>(e);
+		if(null == head){
+			node.prev = null;
+			head = node;
+			tail = head;
+		}else{
+			node.next = head;
+			head.prev = node;
+			head = node;
+		}
+		size++;
+		return true;
+	}
+	/**
+	 * @Description: 添加元素到尾部
+	 * @param e
+	 * @return: boolean
+	 * @author: leijing  
+	 * @date: 2017年2月24日 上午11:38:20
+	 */
+	public boolean addLast(E e) {
+		Node<E> node = new Node<E>(e);
+		if(null == tail){
+			tail.next = null;
+			tail = node;
+			head = tail;
+		}else{
+			tail.next = node;
+			node.prev = tail;
+			tail = node;
+		}
+		size++;
+		return true;
+	}
+
+	public boolean remove(E o) throws Exception {
+		if(isEmpty()){
+			throw new Exception("链表为空，没有元素可以删除");
+		}
+		Node<E> current = head;//从头节点开始删
+		if(o == null){
+			while(current != null){
+				if(current.data == null){
+					current.prev.next = current.next;//将当前节点的前驱节点的后继节点改为当前节点的后继
+					current.next.prev = current.prev;//将当前节点后继节点的前驱节点改为当前节点的前驱节点
+					current.next = null;//当前节点的前驱改为null
+					current.prev = null;//当前节点的后继改为null
+					size--;
+					return true;
+				}
+				current = current.next;
+			}
+		}else{
+			while(current != null){
+				if(o.equals(current.data)){
+					current.prev.next = current.next;//将当前节点的前驱节点的后继节点改为当前节点的后继
+					current.next.prev = current.prev;//将当前节点后继节点的前驱节点改为当前节点的前驱节点
+					current.next = null;//当前节点的前驱改为null
+					current.prev = null;//当前节点的后继改为null
+					size--;
+					return true;
+				}
+				current = current.next;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * @Description: 返回元素个数
+	 * @return: int
+	 * @author: leijing  
+	 * @date: 2017年2月24日 上午11:38:20
+	 */
+	public int size() {
+		return size;
+	}
+	/**
+	 * @Description: 是否空链表
+	 * @return: boolean
+	 * @author: leijing  
+	 * @date: 2017年2月24日 上午11:38:20
+	 */
+	public boolean isEmpty() {
+		return size == 0;
+	}
+	/**
+	 * @Description: 检查下标有效性
+	 * @param index
+	 * @return: void
+	 * @author: leijing  
+	 * @date: 2017年2月24日 上午11:40:15
+	 */
+	private void rangeCheck(int index){
+		if(index < 0 || index > size){
+			throw new IndexOutOfBoundsException();
+		}
+	}
+	public E get(int index) {
+		rangeCheck(index);
+		Node<E> current = head;//从头节点开始
+		int i = 0;
+		while(current != null){
+			if(i == index){
+				return current.data;
+			}
+			current = current.next;
+			i++;
+		}
+		return null;
+	}
+	public Node<E> node(int index) {
+		rangeCheck(index);
+		if(index < size >> 1){//小于元素大小的二分之一，从头节点开始遍历
+			Node<E> current = head;//从头节点开始
+			for(int i = 0 ; i < index ; i++){
+				current = current.next;
+			}
+			return (Node<E>)current;
+		}else{//从尾节点开始遍历
+			Node<E> current = tail;//从尾节点开始
+			for(int i = 0 ; i < index ; i++){
+				current = current.prev;
+			}
+			return (Node<E>)current;
+		}
+	}
+	/**
+	 * @Description: 设置某个位置的元素
+	 * @param index
+	 * @param data
+	 * @return: E
+	 * @author: leijing  
+	 * @date: 2017年2月24日 上午11:58:32
+	 */
+	public E set(int index, E data) {
+		rangeCheck(index);
+		Node<E> current = head;//从头节点开始
+		int i = 0;
+		while(current != null){
+			if(i == index){
+				Node<E> node = new Node<E>(data);
+				Node<E> prev = current.prev;
+				prev.next = node;
+				node.prev = prev;
+				node.next = current;
+				current.prev = node;
+				size++;
+				return data;
+			}
+			current = current.next;
+			i++;
+		}
+		return null;
+	}
+	/**
+	 * @Description: 判断是否包含某个元素
+	 * @param o
+	 * @throws Exception
+	 * @return: boolean
+	 * @author: leijing  
+	 * @date: 2017年2月24日 上午11:57:35
+	 */
+	public boolean contains(Object o) throws Exception {
+		if(isEmpty()){
+			throw new Exception("链表为空，没有任何元素");
+		}
+		Node<E> current = head;//从头节点开始找
+		if(o == null){
+			while(current != null){
+				if(current.data == null){
+					return true;
+				}
+				current = current.next;
+			}
+		}else{
+			while(current != null){
+				if(o.equals(current.data)){
+					return true;
+				}
+				current = current.next;
+			}
+		}
+		return false;
+	}
+	/**
+	 * @Description: 清空链表，删除所有元素
+	 * @return: void
+	 * @author: leijing  
+	 * @date: 2017年2月24日 下午4:41:56
+	 */
+	public void clear() {
+		Node<E> current = head;//从头节点开始遍历
+		while(current != null){
+			Node<E> tmp = current;
+			current = current.next;
+			tmp.prev = null;
+			tmp.next = null;
+		}
+		size = 0;
+	}
+
+	public Iterator<E> iterator() {
+		return new ListItr(0);
+	}
+	private  class ListItr implements Iterator<E>{
+		private Node<E> lastReturned = null;//当前的节点
+		private Node<E> next;//下一个节点
+		private int nextIndex;//当前索引的下标
+		
+		public ListItr(int nextIndex){
+			next = (nextIndex == size) ? null : node(nextIndex);
+		}
+
+		@Override
+		public boolean hasNext() {
+			return nextIndex < size;
+		}
+
+		@Override
+		public E next() {
+			if (!hasNext()){
+				throw new NoSuchElementException();
+			}
+
+			lastReturned = next;
+			next = next.next;
+			nextIndex++;
+			return lastReturned.data;
+		}
+
+		@Override
+		public void remove() {
+			 if (lastReturned == null){
+				 throw new IllegalStateException();
+			 }
+	          
+			 if(lastReturned == next){//tail node
+				 lastReturned.prev.next = null;
+				 lastReturned.prev = null;
+			 }else{
+				 lastReturned.prev.next = lastReturned.next;
+				 lastReturned.next.prev = lastReturned.prev;
+				 lastReturned.next = null;
+				 lastReturned.prev = null;
+			 }
+			nextIndex--;
+		}
+		
+		public boolean hasPrev(){
+			return nextIndex > 0;
+		}
+		
+		public E prev(){
+			if(!hasPrev()){
+				throw new NoSuchElementException();
+			}
+			next = lastReturned = (next == null ) ? tail : next.prev;//如果是头节点，前一个指向尾节点
+			nextIndex--;
+			return lastReturned.data;
+		}
+
+	}
+
+	static class Node<E>{
+		private E data;
+		private Node<E> prev;//前驱节点
+		private Node<E> next;//后继节点
+
+		public Node(E data){
+			this.data = data;
+		}
+
+		public E getData() {
+			return data;
+		}
+
+		public void setData(E data) {
+			this.data = data;
+		}
+
+		public Node<E> getPrev() {
+			return prev;
+		}
+
+		public void setPrev(Node<E> prev) {
+			this.prev = prev;
+		}
+
+		public Node<E> getNext() {
+			return next;
+		}
+
+		public void setNext(Node<E> next) {
+			this.next = next;
+		}
+	}
+}
diff --git a/group07/764189149/src/firstHomeWork/util/Iterator.java b/group07/764189149/src/firstHomeWork/util/Iterator.java
new file mode 100644
index 0000000000..ecbf3015e0
--- /dev/null
+++ b/group07/764189149/src/firstHomeWork/util/Iterator.java
@@ -0,0 +1,30 @@
+package firstHomeWork.util;
+
+/**
+ * @Description: 迭代器
+ * @author: leijing
+ * @date: 2017年2月21日 下午8:49:10
+ * @param <E>
+ */
+public interface Iterator<E> {
+	/**
+	 * @Description: 返回迭代器中是否有下一个元素
+	 * @return: boolean
+	 * @author: leijing  
+	 * @date: 2017年2月21日 下午8:49:52
+	 */
+	boolean hasNext();
+	/**
+	 * @Description: 返回迭代器中的下一个元素
+	 * @return: E
+	 * @author: leijing  
+	 * @date: 2017年2月21日 下午8:50:35
+	 */
+	E next();
+	/**
+	 * @Description: 删除迭代器中的当前元素
+	 * @author: leijing  
+	 * @date: 2017年2月21日 下午8:51:07
+	 */
+	void remove();
+}
diff --git a/group07/764189149/src/firstHomeWork/util/List.java b/group07/764189149/src/firstHomeWork/util/List.java
new file mode 100644
index 0000000000..fac6efa0cc
--- /dev/null
+++ b/group07/764189149/src/firstHomeWork/util/List.java
@@ -0,0 +1,87 @@
+package firstHomeWork.util;
+
+/**
+ * @Description: 定义一组操作有序列表的接口
+ * @author: leijing
+ * @date: 2017年2月21日 下午8:53:52
+ * @param <E>
+ */
+public interface List<E> {
+	/**
+	 * @Description: 添加元素
+	 * @param e
+	 * @return: boolean
+	 * @author: leijing  
+	 * @date: 2017年2月21日 下午8:55:32
+	 */
+	 boolean add(E e);
+	 /**
+	  * @Description: 删除指定索引的元素
+	  * @param index
+	  * @return: E
+	  * @author: leijing  
+	  * @date: 2017年2月21日 下午8:56:08
+	  */
+	 E remove(int index);
+	 /**
+	  * @Description: 删除元素
+	  * @param o
+	  * @return: boolean
+	  * @author: leijing  
+	  * @date: 2017年2月21日 下午8:56:28
+	  */
+	 boolean remove(Object o);
+	 /**
+	  * @Description: 返回元素个数
+	  * @return: int
+	  * @author: leijing  
+	  * @date: 2017年2月21日 下午8:57:25
+	  */
+	 int size();
+	 /**
+	  * @Description: 判断集合是否为空
+	  * @return: boolean
+	  * @author: leijing  
+	  * @date: 2017年2月21日 下午8:57:51
+	  */
+	 boolean isEmpty();
+	 /**
+	  * @Description: 获取指定位置的元素
+	  * @param index
+	  * @return: E
+	  * @author: leijing  
+	  * @date: 2017年2月21日 下午8:58:27
+	  */
+	 E get(int index);
+	 /**
+	  * @Description: 设置指定位置的元素
+	  * @param index
+	  * @param e
+	  * @return: E
+	  * @author: leijing  
+	  * @date: 2017年2月21日 下午8:58:58
+	  */
+	 E set(int index , E e);
+	 /**
+	  * @Description: 判断集合是否包含某个元素
+	  * @param o
+	  * @return: boolean
+	  * @author: leijing  
+	  * @date: 2017年2月21日 下午8:59:32
+	  */
+	 boolean contains(Object o);
+	 /**
+	  * @Description: 清空集合
+	  * @return: void
+	  * @author: leijing  
+	  * @date: 2017年2月21日 下午9:00:12
+	  */
+	 void clear();
+	 /**
+	  * @Description: 获取集合的迭代器
+	  * @return: Iterator<E>
+	  * @author: leijing  
+	  * @date: 2017年2月21日 下午9:00:47
+	  */
+	 Iterator<E> iterator();
+}
diff --git a/group07/764189149/src/firstHomeWork/util/Queue.java b/group07/764189149/src/firstHomeWork/util/Queue.java
new file mode 100644
index 0000000000..78185c3ae8
--- /dev/null
+++ b/group07/764189149/src/firstHomeWork/util/Queue.java
@@ -0,0 +1,59 @@
+package firstHomeWork.util;
+
+/**
+ * @Description: 循环队列
+ * @author: leijing
+ * @date: 2017年2月24日 下午9:00:30
+ * @param <E>
+ */
+public class Queue<E> {
+	private Object[] queue;
+	private int capacity;
+	private static int INITIAL_CAPACITY = 10;
+	private int front; //队头
+	private int rear; //队尾 
+	
+	public Queue(int capacity){
+		this.capacity = capacity;
+		this.front = 0;
+		this.rear = 0;
+		queue = new Object[capacity];
+	}
+	public Queue(){
+		this(INITIAL_CAPACITY);
+	}
+
+	public boolean enQueue(E e) throws Exception{	
+		if(isFull()){
+			return false;
+		}
+		if(rear == capacity - 1){//循环利用
+			rear = 0;
+		}
+		queue[rear++] = e;
+		return true;
+	}
+
+	public E deQueue(){
+		if(isEmpty()){
+			return null;
+		}
+		if(front == capacity - 1){
+			front = 0;
+		}
+		
+		return (E) queue[front++];
+	}
+
+	public boolean isEmpty(){
+		return front == rear;
+	}
+
+	public int size(){
+		return Math.abs(rear - front) + 1;
+	}
+	
+	public boolean isFull(){
+		return (rear + 1) % capacity == front;
+	}
+}
diff --git a/group07/764189149/src/firstHomeWork/util/Stack.java b/group07/764189149/src/firstHomeWork/util/Stack.java
new file mode 100644
index 0000000000..00dc784170
--- /dev/null
+++ b/group07/764189149/src/firstHomeWork/util/Stack.java
@@ -0,0 +1,23 @@
+package firstHomeWork.util;
+
+import java.util.Queue;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	public void push(Object o){		
+	}
+	
+	public Object pop(){
+		return null;
+	}
+	
+	public Object peek(){
+		return null;
+	}
+	public boolean isEmpty(){
+		return false;
+	}
+	public int size(){
+		return -1;
+	}
+}
diff --git "a/group07/770164810/git\345\221\275\344\273\244.txt" "b/group07/770164810/git\345\221\275\344\273\244.txt"
new file mode 100644
index 0000000000..8bcf2ffa0f
--- /dev/null
+++ "b/group07/770164810/git\345\221\275\344\273\244.txt"
@@ -0,0 +1,11 @@
+��װgit gui��������git bash����
+1.��¡
+git clone git@github.com:leijing1992/coding2017.git
+2.�����޸ĵ��ļ�
+git add -A
+3.�ύ���ݴ���
+git commit -m "�ύ***����"
+4.����master
+git pull origin master
+5.�ύ��master
+git push origin master
\ No newline at end of file
diff --git a/group07/770164810/test.txt b/group07/770164810/test.txt
new file mode 100644
index 0000000000..7c4a013e52
--- /dev/null
+++ b/group07/770164810/test.txt
@@ -0,0 +1 @@
+aaa
\ No newline at end of file
diff --git a/group08/108621969/2-26/com/coding/basic/ArrayList.java b/group08/108621969/2-26/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..a06488acb9
--- /dev/null
+++ b/group08/108621969/2-26/com/coding/basic/ArrayList.java
@@ -0,0 +1,119 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+/**
+ * Created by zhangjiatao on 2017/2/25.
+ */
+public class ArrayList implements List {
+    private int size = 0;
+    private Object[] elementData = new Object[100];
+
+    @Override
+    public void add(Object o) {
+        if(isFull()) {
+            elementData = expandArray(elementData);
+        }
+        elementData[size++] = o;
+    }
+
+    @Override
+    public void add(int index, Object o) {
+        ifOutOfBounds(index);
+        if(isFull()) {
+            elementData = expandArray(elementData);
+        }
+        System.arraycopy(elementData,index,elementData,index+1,size++);
+        elementData[index] = o;
+    }
+
+    @Override
+    public Object get(int index) {
+        ifOutOfBounds(index);
+        return elementData[index];
+    }
+
+    @Override
+    public Object remove(int index) {
+        ifOutOfBounds(index);
+        Object delData = elementData[index];
+        System.arraycopy(elementData,index+1,elementData,index,size-index);
+        size--;
+        return index;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public String toString() {
+        String str = "";
+        for(int i=0; i<=size-1; i++){
+            str += elementData[i] + " ";
+        }
+        return str;
+    }
+
+    private boolean isFull() {
+        if(size >= elementData.length-1){
+            return true;
+        }
+        return false;
+    }
+
+    public boolean isEmpty() {
+        if(size == 0) {
+            return true;
+        }
+        return false;
+    }
+
+    private void ifOutOfBounds(int index) {
+        if(index >= size || index < 0) {
+            throw new IndexOutOfBoundsException();
+        }
+    }
+
+    private Object[] expandArray(Object[] arr) {
+        return Arrays.copyOf(arr, arr.length+10);
+    }
+
+    public Iterator iterator = new ArrayListIterator(this);
+
+    private class ArrayListIterator implements Iterator{
+
+        private ArrayList arrList;
+        int position = 0,length;
+
+        private ArrayListIterator(ArrayList arrList){
+            this.arrList = arrList;
+            this.length = arrList.size();
+        }
+
+        @Override
+        public boolean hasNext() {
+            return position < length;
+        }
+
+        @Override
+        public Object next() {
+            return arrList.get(position++);
+        }
+
+    }
+
+    public static void main(String[] args) {
+        ArrayList arr = new ArrayList();
+        arr.add(1);
+        arr.add(2);
+        arr.add(3);
+        arr.add(1,4);
+        arr.remove(2);
+        System.out.println(arr.toString());
+        System.out.println(arr.size());
+        System.out.println(arr.iterator.next());
+        System.out.println(arr.iterator.next());
+    }
+}
diff --git a/group08/108621969/2-26/com/coding/basic/BinaryTreeNode.java b/group08/108621969/2-26/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..f86efd62f5
--- /dev/null
+++ b/group08/108621969/2-26/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,56 @@
+package com.coding.basic;
+
+/**
+ * Created by zhangjiatao on 2017/2/25.
+ */
+public class BinaryTreeNode {
+    private Object data;
+    private BinaryTreeNode left;
+    private BinaryTreeNode right;
+
+    public BinaryTreeNode(Object o) {
+        this.data = o;
+        this.left = null;
+        this.right = null;
+    }
+
+    public int getData() {
+        return (int) 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) {
+        BinaryTreeNode newNode = new BinaryTreeNode(o);
+        insertInto(this, newNode);
+        return this;
+    }
+
+    private void insertInto(BinaryTreeNode tree, BinaryTreeNode o) {
+        if (o.getData() <= tree.getData()) {
+            if (tree.getLeft() != null) insertInto(tree.getLeft(), o);
+            else tree.setLeft(o);
+        } else {
+            if (tree.getRight() != null) insertInto(tree.getRight(), o);
+            else tree.setRight(o);
+        }
+    }
+}
diff --git a/group08/108621969/2-26/com/coding/basic/Iterator.java b/group08/108621969/2-26/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..ae5e36f464
--- /dev/null
+++ b/group08/108621969/2-26/com/coding/basic/Iterator.java
@@ -0,0 +1,9 @@
+package com.coding.basic;
+
+/**
+ * Created by zhangjiatao on 2017/2/25.
+ */
+public interface Iterator {
+    public boolean hasNext();
+    public Object next();
+}
diff --git a/group08/108621969/2-26/com/coding/basic/LinkedList.java b/group08/108621969/2-26/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..dadf8caeaf
--- /dev/null
+++ b/group08/108621969/2-26/com/coding/basic/LinkedList.java
@@ -0,0 +1,174 @@
+package com.coding.basic;
+
+import java.util.Objects;
+
+/**
+ * Created by zhangjiatao on 2017/2/25.
+ */
+public class LinkedList implements List {
+    private Node head = null,tail = null;
+    private int size=0;
+    private LinkedListIterator iterator = null;
+
+    @Override
+    public void add(Object o) {
+        Node newNode = new Node(o);
+        if(tail == null) {
+            head = tail = newNode;
+        }else {
+            tail.next = newNode;
+            tail = newNode;
+        }
+        size++;
+    }
+
+    @Override
+    public void add(int index, Object o) {
+        ifOutOfBounds(index);
+        Node temp = head,previousNode = head;
+        Node newNode = new Node(o);
+        if(index == 0) {
+            newNode.next = head;
+            head = newNode;
+            return ;
+        }
+        while(index-- > 0) {
+            previousNode = temp;
+            temp = temp.next;
+        }
+        previousNode.next = newNode;
+        newNode.next = temp;
+        size++;
+    }
+
+    @Override
+    public Object get(int index) {
+        ifOutOfBounds(index);
+        Node temp = head;
+        while(index-- > 0) {
+            temp = temp.next;
+        }
+        return temp;
+    }
+
+    @Override
+    public Object remove(int index) {
+        ifOutOfBounds(index);
+        Node temp = head,previousNode = head;
+        if(head == tail) {
+            head = tail = null;
+            return temp;
+        }
+        while(index-- > 0) {
+            previousNode = temp;
+            temp = temp.next;
+        }
+        if(tail == temp) {
+            tail = previousNode;
+        }
+        previousNode.next = temp.next;
+        size--;
+        return temp;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    public void addFirst(Object o) {
+        add(0,o);
+    }
+
+    public void addLast(Object o) {
+        add(o);
+    }
+
+    public Object removeFirst() {
+        return remove(0);
+    }
+
+    public Object removeLast() {
+        return remove(size()-1);
+    }
+
+    public LinkedListIterator Iterator() {
+        if(iterator ==null) {
+            iterator = new LinkedListIterator(this);
+        }
+        return iterator;
+    }
+
+    private void ifOutOfBounds(int index) {
+        if(index >= size || index < 0) {
+            throw new IndexOutOfBoundsException();
+        }
+    }
+
+    private boolean isEmpty() {
+        return size==0;
+    }
+
+    public String toString() {
+        String str = "";
+        Node temp = head;
+        while(temp!=tail) {
+            str = str + temp.data + " ";
+            temp = temp.next;
+        }
+        return str + tail.data;
+    }
+
+    private static class Node {
+        Object data;
+        Node next;
+        public Node(Object o) {
+            this.data = o;
+            this.next = null;
+        }
+    }
+
+    private class LinkedListIterator implements Iterator {
+        private LinkedList linkedList = null;
+        private Node currentNode = null;
+
+        public LinkedListIterator(LinkedList linkedList) {
+            this.linkedList = linkedList;
+            this.currentNode = this.linkedList.head;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if(linkedList.isEmpty()) return false;
+            return currentNode.next != null;
+        }
+
+        @Override
+        public Object next() {
+            Object data = currentNode.data;
+            if(hasNext()) {
+                currentNode = currentNode.next;
+            }
+            return data;
+        }
+    }
+
+    public static void main(String[] args) {
+        LinkedList arr = new LinkedList();
+        arr.add(1);
+        arr.add(2);
+        arr.add(3);
+        arr.add(5);
+        arr.add(1,4);
+        arr.remove(2);
+        arr.removeLast();
+        arr.addFirst(5);
+        System.out.println(arr.toString());
+        System.out.println(arr.size());
+        System.out.println(arr.Iterator().hasNext());
+        System.out.println(arr.Iterator().next());
+        System.out.println(arr.Iterator().next());
+        System.out.println(arr.Iterator().next());
+        System.out.println(arr.Iterator().next());
+    }
+}
diff --git a/group08/108621969/2-26/com/coding/basic/List.java b/group08/108621969/2-26/com/coding/basic/List.java
new file mode 100644
index 0000000000..30a4b4e7cb
--- /dev/null
+++ b/group08/108621969/2-26/com/coding/basic/List.java
@@ -0,0 +1,12 @@
+package com.coding.basic;
+
+/**
+ * Created by zhangjiatao on 2017/2/25.
+ */
+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/group08/108621969/2-26/com/coding/basic/Queue.java b/group08/108621969/2-26/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..fd087cbd9b
--- /dev/null
+++ b/group08/108621969/2-26/com/coding/basic/Queue.java
@@ -0,0 +1,33 @@
+package com.coding.basic;
+
+/**
+ * Created by zhangjiatao on 2017/2/25.
+ */
+public class Queue {
+    private ArrayList elementData = new ArrayList();
+
+    public void enQueue(Object o) {
+        elementData.add(0, o);
+    }
+
+    public Object deQueue() {
+        return elementData.remove(elementData.size() - 1);
+    }
+
+    public boolean isEmpty() {
+        return elementData.isEmpty();
+    }
+
+    public int size() {
+        return elementData.size();
+    }
+
+    public static void main(String[] args) {
+        Queue queue = new Queue();
+        queue.enQueue(1);
+        queue.enQueue(2);
+        queue.enQueue(3);
+        System.out.println(queue.deQueue());
+        System.out.println(queue.toString());
+    }
+}
diff --git a/group08/108621969/2-26/com/coding/basic/Stack.java b/group08/108621969/2-26/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..d600d86fe5
--- /dev/null
+++ b/group08/108621969/2-26/com/coding/basic/Stack.java
@@ -0,0 +1,40 @@
+package com.coding.basic;
+
+import java.util.ArrayList;
+
+
+/**
+ * Created by zhangjiatao on 2017/2/25.
+ */
+public class Stack {
+    private ArrayList elementData = new ArrayList();
+
+    public void push(Object o) {
+        elementData.add(elementData.size(), o);
+    }
+
+    public Object pop() {
+        return elementData.remove(elementData.size() - 1);
+    }
+
+    public Object peek() {
+        return elementData.get(elementData.size() - 1);
+    }
+
+    public boolean isEmpty() {
+        return elementData.isEmpty();
+    }
+
+    public int size() {
+        return elementData.size();
+    }
+
+    public static void main(String[] args) {
+        Stack stack = new Stack();
+        stack.push(1);
+        stack.push(2);
+        stack.push(3);
+        System.out.println(stack.pop());
+        System.out.println(stack.toString());
+    }
+}
diff --git a/group08/108621969/README.md b/group08/108621969/README.md
new file mode 100644
index 0000000000..413f53e93a
--- /dev/null
+++ b/group08/108621969/README.md
@@ -0,0 +1,7 @@
+# About Me
+1. 姓名: 张加涛
+2. 性别: 男
+3. 状态: 实习
+4. 年龄: 22
+5. 职业: web前端
+6. 坐标: 上海浦东
diff --git a/group08/108621969/article/Comp-Units-Relations(2-16).md b/group08/108621969/article/Comp-Units-Relations(2-16).md
new file mode 100644
index 0000000000..b3fdcbb61b
--- /dev/null
+++ b/group08/108621969/article/Comp-Units-Relations(2-16).md
@@ -0,0 +1,14 @@
+# CPU
+由寄存器、运算器、控制器组成
+还有一级缓存、二级缓存等
+# 内存 
+我们所说的内存都是系统内存，是SDRAM，动态随机存储器
+速度快容量小
+# 硬盘 
+容量大速度慢 
+# 指令 
+程序在计算机中被分解为一条条的指令 
+# 关系 
+程序文件在硬盘中，当调用时，从硬盘载入内存，
+控制器从内存中读取程序的第一条指令，指令通知运算器读取内存中的数据的地址，
+运算器结合寄存器计算出结果，读取下一条指令，直到指令结束。
diff --git a/group08/1144989424/Readme.md b/group08/1144989424/Readme.md
new file mode 100644
index 0000000000..3a515bb88b
--- /dev/null
+++ b/group08/1144989424/Readme.md
@@ -0,0 +1,3 @@
+### 目录说明
+
+个人目录，他人勿动
diff --git a/group08/1144989424/firstPractice/readme.md b/group08/1144989424/firstPractice/readme.md
new file mode 100644
index 0000000000..ac4feb57b8
--- /dev/null
+++ b/group08/1144989424/firstPractice/readme.md
@@ -0,0 +1,4 @@
+### 第一次作业：
+1. 实现ArrayList, LinkedList, Queue, Stack 
+2. 有余力的同学可以实现 BinaryTree 和Iterator
+3. 写一篇文章，建议: 描述CPU，内存， 硬盘，指令之间的关系。
\ No newline at end of file
diff --git a/group08/1144989424/firstPractice/src/basic/BinaryTreeNode.java b/group08/1144989424/firstPractice/src/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..6300e92259
--- /dev/null
+++ b/group08/1144989424/firstPractice/src/basic/BinaryTreeNode.java
@@ -0,0 +1,49 @@
+package basic;
+
+/**
+ * 二叉树的数据结构
+ * @author Wayss
+ * 2017-02-25
+ */
+
+public class BinaryTreeNode {
+    
+    private Object data;
+    private BinaryTreeNode left;
+    private BinaryTreeNode right;
+    
+    public BinaryTreeNode(){
+        
+    }
+    
+    public BinaryTreeNode(Integer val){
+        data = val;
+        left = null;
+        right = null;
+    }
+    
+    
+    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){
+        return  null;
+    }
+    
+}
diff --git a/group08/1144989424/firstPractice/src/basic/MyArrayList.java b/group08/1144989424/firstPractice/src/basic/MyArrayList.java
new file mode 100644
index 0000000000..f9cf5b1b80
--- /dev/null
+++ b/group08/1144989424/firstPractice/src/basic/MyArrayList.java
@@ -0,0 +1,97 @@
+package basic;
+
+/**
+ * 我的ArrayList实现
+ * @author Wayss
+ * 2017-02-22
+ */
+
+public class MyArrayList implements MyList {
+    
+    private int size = 0;
+    
+    private Object[] elementData = new Object[10];
+    
+    /**
+     * 往集合中添加一个元素
+     */
+    public void add(Object o){
+        int length = elementData.length;
+        //1.比较元素个数和数组大小，判断是否需要扩大数组
+        if(size == length){
+            expandArray();
+        }
+        //2.直接赋值给size，即最后一个元素
+        elementData[size] = o;
+        size++;
+    }
+    
+    /**
+     * 往集合指定位置添加一个元素，该位置和其之后的元素向后移动一位。
+     * 位置不合法时，抛出异常。
+     */
+    public void add(int index, Object o){
+        int length = elementData.length;
+        //0.先对index的值进行判断，小于0，或者，大于size，越界
+        if(index < 0 || index > size){
+            throw new IndexOutOfBoundsException("插入的下标越界了:"+"插入的下标为："+index+"集合大小为："+size);
+        }
+        //1.比较元素个数和数组大小，判断是否需要扩大数组
+        if(size == length){
+            expandArray();
+        }
+        //2.移动index之后的数组元素
+        for(int i = size; i > index; i--){
+            elementData[i] = elementData[i-1];
+        }
+        elementData[index] = o;
+        size++;
+    }
+    
+    public Object get(int index){
+        int length = elementData.length;
+        //0.先对index的值进行判断，小于0，或者，大于等于size，便越界
+        if(index < 0 || index >= size){
+            throw new IndexOutOfBoundsException("插入的下标越界了:"+"插入的下标为："+index+"集合大小为："+size);
+        }
+        //2.拿出index位置的值，
+        Object o = elementData[index];
+        
+        return o;
+    }
+    
+    public Object remove(int index){
+        //remove 前两步的逻辑和get方法相同
+        int length = elementData.length;
+        //0.先对index的值进行判断，小于0，或者，大于等于size，便越界
+        if(index < 0 || index >= size){
+            throw new IndexOutOfBoundsException("插入的下标越界了:"+"插入的下标为："+index+"集合大小为："+size);
+        }
+        //2.拿出index位置的值，
+        Object o = elementData[index];
+        
+        //3.删除index位置的值，之后的值，向前移动。
+        for(int i = index; i < size-1; i++){
+            elementData[i] = elementData[i+1];
+        }
+        size--;
+        return null;
+    }
+    
+    public int size(){
+        return size;
+    }
+    
+    public MyIterator iterator(){
+        return null;
+    }
+    
+    private void expandArray(){
+        int length = elementData.length;
+        Object [] newArr = new Object[length * 2];
+        for(int i = 0; i < length; i++){
+            newArr[i] = elementData[i];
+        }
+        elementData = newArr;
+    }
+}
diff --git a/group08/1144989424/firstPractice/src/basic/MyIterator.java b/group08/1144989424/firstPractice/src/basic/MyIterator.java
new file mode 100644
index 0000000000..2aa1de62c4
--- /dev/null
+++ b/group08/1144989424/firstPractice/src/basic/MyIterator.java
@@ -0,0 +1,7 @@
+package basic;
+
+public interface MyIterator {
+    public boolean hasNext();
+    public Object next();
+
+}
diff --git a/group08/1144989424/firstPractice/src/basic/MyLinkedList.java b/group08/1144989424/firstPractice/src/basic/MyLinkedList.java
new file mode 100644
index 0000000000..3894884373
--- /dev/null
+++ b/group08/1144989424/firstPractice/src/basic/MyLinkedList.java
@@ -0,0 +1,113 @@
+package basic;
+
+/**
+ * 实现LinkedList基本功能
+ * @author Wayss
+ * 2017-02-23
+ */
+
+public class MyLinkedList implements MyList {
+    
+    private Node head;
+    private int size = 0;
+    
+    public void add(Object o){
+        Node n = new Node(o);
+        head.next = n;
+        size++;
+    }
+    public void add(int index , Object o){
+        //1.index校验
+        if(index < 0 || index > size){
+            throw new IndexOutOfBoundsException("插入的下标越界了:"+"插入的下标为："+index+"集合大小为："+size);
+        }
+        //2. 查找index位置的前一个节点
+        //tempNode为当前链表的第一个节点
+        Node tempNode = head.next;
+        for(int i = 0; i < index - 1 ; i++){
+            tempNode = tempNode.next;
+        }
+        Node behindNode = tempNode.next;
+        Node insertNode = new Node(o);
+        tempNode.next = insertNode;
+        insertNode.next = behindNode;
+        size++;
+    }
+    public Object get(int index){
+      //1.index校验
+        if(index < 0 || index > size){
+            throw new IndexOutOfBoundsException("插入的下标越界了:"+"插入的下标为："+index+"集合大小为："+size);
+        }
+        //2. 查找当前节点
+        Node tempNode = head.next;
+        for(int i = 0; i < index; i++){
+            tempNode = tempNode.next;
+        }
+        return tempNode.data;
+    }
+    public Object remove(int index){
+        //1.index校验
+        if(index < 0 || index > size){
+            throw new IndexOutOfBoundsException("插入的下标越界了:"+"插入的下标为："+index+"集合大小为："+size);
+        }
+        //2. 查找当前节点的上一个节点
+        Node tempNode = head.next;
+        for(int i = 0; i < index - 1; i++){
+            tempNode = tempNode.next;
+        }
+        Node deleteNode = tempNode.next;
+        Node behideNode = tempNode.next.next;
+        tempNode.next = behideNode;
+        size--;
+        return deleteNode.data;
+    }
+    
+    public int size(){
+        return size;
+    }
+    
+    public void addFirst(Object o){
+        Node insertNode = new Node(o);
+        insertNode.next = head.next;
+        head.next = insertNode;
+        size++;
+    }
+    public void addLast(Object o){
+        Node insertNode = new Node(o);
+        Node tempNode = head.next;
+        for(int i = 0; i < size; i++){
+            tempNode = tempNode.next;
+        }
+        tempNode.next = insertNode;
+        size++;
+    }
+    public Object removeFirst(){
+        Node firstNode = head.next;
+        head = firstNode.next;
+        size--;
+        return firstNode;
+    }
+    public Object removeLast(){
+        Node tempNode = head.next;
+        //1.移除需要找到最后一个点的前一个点
+        for(int i = 0; i < size - 1; i++){
+            tempNode = tempNode.next;
+        }
+        Node deleteNode = tempNode.next;
+        tempNode.next = null;
+        size--;
+        return deleteNode;
+    }
+    public MyIterator iterator(){
+        return null;
+    }
+    
+    
+    private static class Node{
+        Object data;
+        Node next;
+        public Node(Object data){
+            this.data = data;
+        }
+    }
+}
diff --git a/group08/1144989424/firstPractice/src/basic/MyList.java b/group08/1144989424/firstPractice/src/basic/MyList.java
new file mode 100644
index 0000000000..c017431b22
--- /dev/null
+++ b/group08/1144989424/firstPractice/src/basic/MyList.java
@@ -0,0 +1,9 @@
+package basic;
+
+public interface MyList {
+    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/group08/1144989424/firstPractice/src/basic/MyQueue.java b/group08/1144989424/firstPractice/src/basic/MyQueue.java
new file mode 100644
index 0000000000..31fab53105
--- /dev/null
+++ b/group08/1144989424/firstPractice/src/basic/MyQueue.java
@@ -0,0 +1,31 @@
+package basic;
+
+/**
+ * 实现队列
+ * @author Wayss
+ * 2017-02-25
+ */
+
+public class MyQueue {
+    
+    MyLinkedList linkList = new MyLinkedList();
+    
+    public void enQueue(Object o){
+        linkList.addLast(o);
+    }
+    
+    public Object deQueue(){
+        return linkList.removeFirst();
+    }
+    
+    public boolean isEmpty(){
+        if(linkList.size() == 0){
+            return true;
+        }
+        return false;
+    }
+    
+    public int size(){
+        return linkList.size();
+    }
+}
diff --git a/group08/1144989424/firstPractice/src/basic/MySortBinaryTree.java b/group08/1144989424/firstPractice/src/basic/MySortBinaryTree.java
new file mode 100644
index 0000000000..a4579217e5
--- /dev/null
+++ b/group08/1144989424/firstPractice/src/basic/MySortBinaryTree.java
@@ -0,0 +1,81 @@
+package basic;
+
+import java.util.Comparator;
+
+/**
+ * 实现二叉排序树，使左节点的值，始终父节点小，右节点的值，始终比父节点大
+ * @author Wayss
+ * 2017-02-25
+ */
+
+public class MySortBinaryTree {
+    
+    public BinaryTreeNode root = new BinaryTreeNode();
+    
+    /**
+     * 1. 添加时，先判断与root节点值的大小
+     * 2. insert的值小于root的值，则插入到root的左边。
+     * 3. insert的值大于root的值，则插入到root的右边。
+     * PS:目前只支持Integer类型的对象插入
+     * @param val
+     */
+    public void add(Integer val){
+        BinaryTreeNode treeNode = new BinaryTreeNode(val);
+        insert(root, treeNode);
+    }
+    
+    private void insert(BinaryTreeNode node, BinaryTreeNode insertNode){
+        
+        int result = compare((Integer)insertNode.getData(),(Integer)node.getData());
+        
+        if(0 == result){
+            //相等的话，当重复数据，不插了.呵呵
+        }
+        //insert的值小于root的值，则插入到root的左边。
+        //如果左节点有值，则递归
+        if(-1 == result){
+            if(node.getLeft() != null){
+                insert(node.getLeft(), insertNode);
+            }else{
+                node.setLeft(insertNode);
+            }
+        }
+        //insert的值大于root的值，则插入到root的右边。
+        if(1 == result){
+            if(node.getRight() != null){
+                insert(node.getRight(), insertNode);
+            }else{
+                node.setRight(insertNode);
+            }
+        }
+    }
+    
+    public MyArrayList getValue(){
+        MyArrayList malist = new MyArrayList();
+        getTreeValue(root,malist);
+        return malist;
+    }
+    
+    private void getTreeValue(BinaryTreeNode node,MyArrayList list){
+        //遍历左子数
+        if(node.getLeft() != null){
+            getTreeValue(node.getLeft(),list); 
+        }
+        list.add(node.getData());
+        //遍历右子数
+        if(node.getRight() != null){
+            getTreeValue(node.getRight(),list);
+        }
+    }
+    
+    public static int compare(Integer i1, Integer i2){
+        if(i1 < i2){
+            return -1;
+        }else if(i1 == i2){
+            return 0;
+        }else {
+            return 1;
+        }
+    }
+    
+}
diff --git a/group08/1144989424/firstPractice/src/basic/MyStack.java b/group08/1144989424/firstPractice/src/basic/MyStack.java
new file mode 100644
index 0000000000..c8e8e0d2fd
--- /dev/null
+++ b/group08/1144989424/firstPractice/src/basic/MyStack.java
@@ -0,0 +1,33 @@
+package basic;
+
+/**
+ * 栈实现
+ * @author Wayss
+ * 2017-02-25
+ */
+
+public class MyStack {
+    private MyArrayList arrList = new MyArrayList();
+    
+    public void push(Object o){
+        arrList.add(o);
+    }
+    
+    public Object pop(){
+        //elementData.size()-1是当前数组的最后一个元素的下标
+        return arrList.remove(arrList.size() - 1);
+    }
+    
+    public Object peek(){
+        return arrList.get(arrList.size() - 1);
+    }
+    public boolean isEmpty(){
+        if(arrList.size() == 0){
+            return true;
+        }
+        return false;
+    }
+    public int size(){
+        return arrList.size();
+    }
+}
diff --git a/group08/121027265/README.md b/group08/121027265/README.md
new file mode 100644
index 0000000000..488916d101
--- /dev/null
+++ b/group08/121027265/README.md
@@ -0,0 +1,3 @@
+# 是标题
+* aaa
+* bbb
diff --git a/group08/1226637491/2_26/ArrayList.java b/group08/1226637491/2_26/ArrayList.java
new file mode 100644
index 0000000000..1d4aaf7bc4
--- /dev/null
+++ b/group08/1226637491/2_26/ArrayList.java
@@ -0,0 +1,95 @@
+interface MyIterator{
+	public boolean hasNext();
+	public Object next();
+
+}
+
+
+public class ArrayList {
+/*	public static void main(String[] d){
+		ArrayList p = new ArrayList();
+		p.add("asd");p.add("123");p.add("123");p.add("234");p.add("456");
+		p.remove(1);
+		p.add(1, 345);
+		MyIterator it = p.iterator();
+		while(it.hasNext()){
+			System.out.println(it.next().toString());
+		}
+	}
+*/
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[100];
+
+	public void add(Object o){
+		if(size >= elementData.length){//�������鳤��
+			Object[] tem = new Object[elementData.length*2];
+			for(int i=0;i<size;i++){
+				tem[i] = elementData[i];
+			}
+			elementData = tem;
+		}
+		elementData[size] = o;
+		size++;	
+	}
+	public void add(int index, Object o){
+		if(size >= elementData.length){
+			Object[] tem = new Object[elementData.length*2];
+			for(int i=0;i<size;i++){
+				tem[i] = elementData[i];
+			}
+			elementData = tem;
+		}
+		for(int i = index; i < size; i++){
+			elementData[i+1] = elementData[i];
+		}
+		elementData[index] = o;
+		size++;
+	}
+	
+	public Object get(int index){
+		return elementData[index];
+	}
+	
+	public Object remove(int index){
+		if(index<0  || index >=size){
+			throw new IndexOutOfBoundsException();
+		}
+		for(int i = index; i < size; i++){
+			elementData[i-1] = elementData[i];
+		}
+		size--;
+		return elementData[index];
+	}
+	
+	public int size(){
+		return size;
+	
+	}
+	
+	
+	class MMIt implements MyIterator{
+		int loc = 0;
+		
+		public boolean hasNext() {
+			if(loc>=size)
+				return false;
+			else 
+				return true;
+		}
+
+		
+		public Object next() {
+			++loc;
+			return elementData[loc-1];
+		}
+		
+	}
+	
+	
+	public MyIterator iterator(){
+		return new MMIt();
+	}
+	
+}
\ No newline at end of file
diff --git a/group08/1226637491/2_26/LinkedList.java b/group08/1226637491/2_26/LinkedList.java
new file mode 100644
index 0000000000..4534272573
--- /dev/null
+++ b/group08/1226637491/2_26/LinkedList.java
@@ -0,0 +1,127 @@
+
+
+public class LinkedList {
+	
+	private Node head = new Node();
+	private int size = 0;
+	
+	public void add(Object o){
+		Node tem = new Node();
+		tem.data = o;
+		tem.next = null;
+		Node temp = head;
+		int i = 0;
+		while(i<size){
+			temp = temp.next;
+			++i;
+		}
+		temp.next = tem;
+		size++;
+		
+	}
+	public void add(int index , Object o){
+		if(index <=0 || index >size+1)
+			throw new IndexOutOfBoundsException();
+		Node tem = new Node();
+		tem.data = o;
+		tem.next = null;
+		++size;
+		Node temp = head;
+		int i = 0;
+		while(i<index-1){
+			temp = temp.next;
+			++i;
+		}
+		tem.next=temp.next;
+		temp.next = tem;
+		
+	}
+	public Object get(int index){
+		Node temp = head;
+		int i = 0;
+		while(i<index){
+			temp = temp.next;
+			++i;
+		}
+		return temp.data;
+	}
+	public Object remove(int index){
+		if(index <=0 || index >size+1)
+			throw new IndexOutOfBoundsException();
+		--size;
+		Node temp = head;
+		int i = 0;
+		while(i<index-1){
+			temp = temp.next;
+			++i;
+		}
+		Object t = temp.next.data;
+		temp.next=temp.next.next;
+		return t;
+		
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		Node tem = new Node();
+		tem.data = o;
+		tem.next = null;
+		head.next = tem;
+		size++;
+		
+	}
+	public void addLast(Object o){
+		Node tem = new Node();
+		tem.data = o;
+		tem.next = null;
+		Node temp = head;
+		int i = 0;
+		while(i<size){
+			temp = temp.next;
+			++i;
+		}
+		temp.next = tem;
+		size++;
+		
+	}
+	public Object removeFirst(){
+		Object t = head.next.data;
+		head.next=head.next.next;
+		size--;
+		return t;
+	}
+	public Object removeLast(){
+		Node temp = head;
+		int i = 0;
+		while(i<size-1){
+			temp = temp.next;
+			++i;
+		}
+		Object t = temp.next.data;
+		temp.next = null;
+		size--;
+		return t;
+		
+	}
+	public static void main(String []args){
+		LinkedList l = new LinkedList();
+		l.addFirst("c");
+		l.add("a");
+		l.add(1,"b");//�����1�ǵ�һ�������������
+		l.add("123");
+		System.out.println(l.removeFirst());
+		System.out.println(l.remove(2));
+		System.out.println(l.removeLast());
+	}
+
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		
+	}
+}
diff --git a/group08/1226637491/2_26/Queue.java b/group08/1226637491/2_26/Queue.java
new file mode 100644
index 0000000000..c1cb2283a7
--- /dev/null
+++ b/group08/1226637491/2_26/Queue.java
@@ -0,0 +1,39 @@
+import java.util.EmptyStackException;
+
+public class Queue {
+	private ArrayList elementData = new ArrayList();
+	public void enQueue(Object o){	
+		elementData.add(o);
+	}
+	
+	public Object deQueue(){
+		if(!isEmpty())
+			return elementData.remove(1);
+		else 
+			throw new EmptyStackException();
+	}
+
+	
+	public boolean isEmpty(){
+		if(elementData.size()==0)
+			return true;
+		return false;
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+	public static void main(String[] args){
+		Queue q = new Queue();
+		q.enQueue("123");
+		q.enQueue("a");
+		q.enQueue("f");
+		q.enQueue("t");
+		q.enQueue("w");
+		
+		System.out.println(q.deQueue());
+		System.out.println(q.size());
+		System.out.println(q.isEmpty());
+		
+}
+}
diff --git a/group08/1226637491/2_26/Stack.java b/group08/1226637491/2_26/Stack.java
new file mode 100644
index 0000000000..626024bae7
--- /dev/null
+++ b/group08/1226637491/2_26/Stack.java
@@ -0,0 +1,44 @@
+import java.util.EmptyStackException;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){
+		elementData.add(o);
+	}
+	
+	public Object pop(){
+		if(!isEmpty())
+			return elementData.remove();
+		else 
+			throw new EmptyStackException();
+	}
+	public Object peek(){
+		int len = elementData.size();
+		if(!isEmpty())
+			return elementData.get(len-1);
+		throw new EmptyStackException();
+	}
+	public boolean isEmpty(){
+		if(elementData.size()==0)
+			return true;
+		else
+			return false;
+	}
+	public int size(){
+		return elementData.size();
+	}
+/*	public static void main(String[] args){
+		Stack s = new Stack();
+		s.push("123");
+		s.push("1");
+		s.push("1234");
+		s.push("1253");
+		s.push("1263");
+		System.out.println(s.size());
+		System.out.println(s.peek());
+		System.out.println(s.pop());
+		System.out.println(s.isEmpty());
+	}*/
+}
+
diff --git "a/group08/1226637491/2_26/\346\226\207\347\253\240\346\211\200\345\234\250\347\232\204\347\275\221\345\235\200.txt" "b/group08/1226637491/2_26/\346\226\207\347\253\240\346\211\200\345\234\250\347\232\204\347\275\221\345\235\200.txt"
new file mode 100644
index 0000000000..341713cd3c
--- /dev/null
+++ "b/group08/1226637491/2_26/\346\226\207\347\253\240\346\211\200\345\234\250\347\232\204\347\275\221\345\235\200.txt"
@@ -0,0 +1 @@
+https://note.youdao.com/web/#/file/recent/note/WEB4a6ed504d001e1753756740ae417e540/
\ No newline at end of file
diff --git a/group08/125980622/125980622.js b/group08/125980622/125980622.js
new file mode 100644
index 0000000000..bcea502ef8
--- /dev/null
+++ b/group08/125980622/125980622.js
@@ -0,0 +1 @@
+console.log('Hello~Coding2017')
diff --git a/group08/125980622/first_hw/ArrayList.java b/group08/125980622/first_hw/ArrayList.java
new file mode 100644
index 0000000000..862b426261
--- /dev/null
+++ b/group08/125980622/first_hw/ArrayList.java
@@ -0,0 +1,44 @@
+import java.util.Objects;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[100];
+	
+	public void add(Object o){
+		elementData[size++] = o;
+	}
+	public void add(int index, Object o){
+		for (int i = size; i >index; i++) {
+			elementData[i] = elementData[i - 1];
+		}
+		elementData[index] = o;
+	}
+	
+	public Object get(int index){
+		return elementData[index];
+	}
+
+	public Object removeLast() {
+        return elementData[size--];
+    }
+	
+	public Object remove(int index){
+		Object temp = elementData[index];
+		for (int i = index; i < size - 1; i++) {
+			elementData[i] = elementData[i + 1];
+		}
+		size -= 1;
+		return temp;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public Iterator iterator(){
+		return new myIterator(this);
+	}
+	
+}
diff --git a/group08/125980622/first_hw/BinaryTreeNode.java b/group08/125980622/first_hw/BinaryTreeNode.java
new file mode 100644
index 0000000000..0de773afd1
--- /dev/null
+++ b/group08/125980622/first_hw/BinaryTreeNode.java
@@ -0,0 +1,52 @@
+import com.sun.xml.internal.bind.v2.runtime.AttributeAccessor;
+
+public class BinaryTreeNode {
+	
+	private int data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+	
+	public int getData() {
+		return data;
+	}
+	public void setData(int 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(int o){
+	    BinaryTreeNode returnNode = null;
+		if (data < o) {
+			if (right == null) {
+				right = new BinaryTreeNode(o, null, null);
+				returnNode = right;
+			} else {
+		        returnNode = right.insert(o);
+			}
+		} else if (data > o) {
+			if (left == null) {
+				returnNode = left = new BinaryTreeNode(o, null, null);
+			} else {
+				returnNode = left.insert(o);
+			}
+		}
+        return returnNode;
+    }
+
+	BinaryTreeNode (int initData, BinaryTreeNode initLeft, BinaryTreeNode initRight) {
+		data = initData;
+		left = initLeft;
+		right = initRight;
+	}
+}
diff --git a/group08/125980622/first_hw/Iterator.java b/group08/125980622/first_hw/Iterator.java
new file mode 100644
index 0000000000..57b7ad9d11
--- /dev/null
+++ b/group08/125980622/first_hw/Iterator.java
@@ -0,0 +1,4 @@
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+}
diff --git a/group08/125980622/first_hw/LinkedList.java b/group08/125980622/first_hw/LinkedList.java
new file mode 100644
index 0000000000..f5477064bb
--- /dev/null
+++ b/group08/125980622/first_hw/LinkedList.java
@@ -0,0 +1,90 @@
+public class LinkedList implements List {
+	
+	private Node head;
+	private int size = 0;
+	
+	public void add(Object o){
+		if (head == null) {
+			head = new Node(o);
+		} else {
+			Node pointer = head.next;
+			while (pointer.next != null) {
+				pointer = pointer.next;
+			}
+			pointer.next = new Node(o);
+		}
+		size++;
+	}
+	public void add(int index , Object o){
+		Node pointer = head;
+		for (int i = 0; i < index - 1; i++) {
+			pointer = pointer.next;
+		}
+		Node nNode = new Node(o, pointer.next);
+		pointer.next = nNode;
+		size++;
+	}
+	public Object get(int index){
+		Node pointer = head;
+		for (int i= 0; i < index; i++) {
+			pointer = pointer.next;
+		}
+		return pointer;
+	}
+	public Object remove(int index){
+		Node pointer = head;
+		for (int i = 0; i < index - 1; i++) {
+			pointer = pointer.next;
+		}
+		Node temp = pointer.next;
+		pointer.next = temp.next;
+		size--;
+		return temp;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+        head = new Node(o, head);
+	}
+	public void addLast(Object o){
+		Node pointer = head;
+		while (pointer.next != null) {
+			pointer = pointer.next;
+		}
+		pointer.next = new Node(o);
+	}
+	public Object removeFirst(){
+		Node temp = head;
+		head = head.next;
+		return temp;
+	}
+	public Object removeLast(){
+		Node pointer = head;
+		while (pointer.next.next != null) {
+			pointer = pointer.next;
+		}
+		Node temp = pointer.next;
+		pointer.next = null;
+		return temp;
+	}
+	public myIterator iterator(){
+		return new myIterator(this);
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		Node (Object o, Node n) {
+			data = o;
+			next = n;
+		}
+		Node (Object o) {
+			data = o;
+			next = null;
+		}
+	}
+}
diff --git a/group08/125980622/first_hw/List.java b/group08/125980622/first_hw/List.java
new file mode 100644
index 0000000000..4f7bcc71a8
--- /dev/null
+++ b/group08/125980622/first_hw/List.java
@@ -0,0 +1,7 @@
+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/group08/125980622/first_hw/Queue.java b/group08/125980622/first_hw/Queue.java
new file mode 100644
index 0000000000..f176f2a256
--- /dev/null
+++ b/group08/125980622/first_hw/Queue.java
@@ -0,0 +1,21 @@
+
+public class Queue {
+
+    LinkedList queueList = new LinkedList();
+
+	public void enQueue(Object o){
+        queueList.addLast(o);
+	}
+	
+	public Object deQueue(){
+		return queueList.removeFirst();
+	}
+	
+	public boolean isEmpty(){
+        return queueList.size() <= 0;
+	}
+	
+	public int size(){
+        return queueList.size();
+	}
+}
diff --git a/group08/125980622/first_hw/Stack.java b/group08/125980622/first_hw/Stack.java
new file mode 100644
index 0000000000..e3c15480b8
--- /dev/null
+++ b/group08/125980622/first_hw/Stack.java
@@ -0,0 +1,24 @@
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+
+	private int size = 0;
+	
+	public void push(Object o){
+		elementData.add(o);
+		size++;
+	}
+	
+	public Object pop(){
+		return elementData.remove(size);
+	}
+	
+	public Object peek(){
+		return elementData.get(size);
+	}
+	public boolean isEmpty(){
+		return size <= 0;
+	}
+	public int size(){
+		return size;
+	}
+}
diff --git a/group08/125980622/first_hw/myIterator.java b/group08/125980622/first_hw/myIterator.java
new file mode 100644
index 0000000000..0a2f9bb13d
--- /dev/null
+++ b/group08/125980622/first_hw/myIterator.java
@@ -0,0 +1,37 @@
+import java.util.Objects;
+
+/**
+ * Created by Yusen Meng on 25/02/2017.
+ */
+public class myIterator implements Iterator {
+    int index = 0;
+    ArrayList _array = null;
+    LinkedList _list = null;
+    myIterator (LinkedList theList) {
+        _list = theList;
+    }
+    myIterator (ArrayList theArray) {
+        _array = theArray;
+    }
+    public boolean hasNext() {
+        boolean  result;
+        if (_array != null) {
+            result = index < _array.size();
+        } else {
+            result = index < _list.size();
+        }
+        return  result;
+    }
+
+    public Object next() {
+        Object returnValue;
+        if (_array != null) {
+            returnValue =  _array.get(index);
+            index++;
+        } else  {
+            returnValue = _list.get(index);
+            index++;
+        }
+        return returnValue;
+    }
+}
diff --git a/group08/1277959541/1277959541 b/group08/1277959541/1277959541
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/group08/1277959541/1277959541
@@ -0,0 +1 @@
+
diff --git a/group08/1287324781/1287324781 b/group08/1287324781/1287324781
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/group08/1287324781/1287324781
@@ -0,0 +1 @@
+
diff --git a/group08/1425809544/02-26/com/xuyangyang/util/MyArrayList.java b/group08/1425809544/02-26/com/xuyangyang/util/MyArrayList.java
new file mode 100644
index 0000000000..52036eb78d
--- /dev/null
+++ b/group08/1425809544/02-26/com/xuyangyang/util/MyArrayList.java
@@ -0,0 +1,113 @@
+package com;
+
+import java.util.NoSuchElementException;
+
+public class MyArrayList implements MyList {
+
+	private static final int DEFAULT_CAPACITY = 10;
+	private int size;
+	private Object[] elementData;
+
+	public MyArrayList() {
+		this.size = 0;
+
+	}
+
+	@Override
+	public boolean add(Object o) {
+		// TODO Auto-generated method stub
+		add(size(), o);
+		return true;
+	}
+
+	@Override
+	public void add(int index, Object o) {
+
+		if (elementData.length == size()) {
+			ensureCapacity(size() * 2 + 1);
+		}
+
+		for (int i = size(); i > index; i--) {
+			elementData[i] = elementData[i - 1];
+		}
+		elementData[2] = o;
+		size++;
+
+	}
+
+	@Override
+	public Object get(int index) {
+
+		if (index < 0 || index >= size()) {
+			throw new ArrayIndexOutOfBoundsException();
+		}
+
+		return elementData[index];
+
+	}
+
+	@Override
+	public Object remove(int index) {
+
+		if (index < 0 || index >= size()) {
+			throw new ArrayIndexOutOfBoundsException();
+		}
+		Object value = elementData[index];
+		for (int i = index; i < size() - 1; i++) {
+			elementData[i] = elementData[i + 1];
+		}
+		return value;
+
+	}
+
+	@Override
+	public int size() {
+		// TODO Auto-generated method stub
+		return size;
+	}
+
+	/**
+	 * �������
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��20��
+	 * @param newCapacity
+	 */
+	public void ensureCapacity(int newCapacity) {
+		if (newCapacity < size) {
+			return;
+		}
+		Object[] old = elementData;//
+
+		elementData = new Object[newCapacity];// �����µ�����
+
+		for (int i = 0; i < old.length; i++) {
+			elementData[i] = old[i];
+		}
+
+	}
+
+	private class InnerIterator implements MyIterator  {
+
+		private int current = 0;
+
+		public boolean hasNext() {
+			return current < size();
+		}
+
+		@Override
+		public Object next() {
+			if (!hasNext()) {
+				throw new NoSuchElementException();
+			}
+			return elementData[current++];
+		}
+
+		public void remove() {
+			MyArrayList.this.remove(--current);
+		}
+
+	}
+
+}
diff --git a/group08/1425809544/02-26/com/xuyangyang/util/MyIterator.java b/group08/1425809544/02-26/com/xuyangyang/util/MyIterator.java
new file mode 100644
index 0000000000..1b83f8988d
--- /dev/null
+++ b/group08/1425809544/02-26/com/xuyangyang/util/MyIterator.java
@@ -0,0 +1,8 @@
+package com;
+
+public interface MyIterator {
+	
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group08/1425809544/02-26/com/xuyangyang/util/MyLinkedList.java b/group08/1425809544/02-26/com/xuyangyang/util/MyLinkedList.java
new file mode 100644
index 0000000000..3d84ecd268
--- /dev/null
+++ b/group08/1425809544/02-26/com/xuyangyang/util/MyLinkedList.java
@@ -0,0 +1,277 @@
+package com;
+
+import java.util.NoSuchElementException;
+
+public class MyLinkedList implements MyList {
+
+	int size = 0;
+	Node first;
+	Node last;
+
+	private static class Node {
+		Object item;
+		Node next;// ָ����һ���ڵ�
+		Node prev;// ָ����һ���ڵ�
+
+		Node(Node prev, Object element, Node next) {
+			this.item = element;
+			this.next = next;
+			this.prev = prev;
+		}
+	}
+
+	public boolean add(Object o) {
+		linkLast(o);
+		return true;
+
+	}
+
+	/**
+	 * ��Ԫ�ز���ָ���±�
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��21��
+	 * @param index
+	 * @param o
+	 */
+	public void add(int index, Object o) {
+		checkPositionIndex(index);
+		if (index == size) {
+			linkLast(0);
+		} else {
+			LinkBefore(o, node(index));
+		}
+
+	}
+
+	public void addFirst(Object o) {
+		linkFirst(o);
+	}
+
+	public void addLast(Object o) {
+		linkLast(o);
+	}
+
+	private void linkFirst(Object o) {
+		final Node f = first;
+		final Node newNode = new Node(null, o, f);
+		first = newNode;
+		if (first == null) {
+			first = newNode;
+		} else {
+			f.prev = newNode;
+		}
+		size++;
+
+	}
+
+	void LinkBefore(Object o, Node succ) {
+		final Node pred = succ.prev;
+		final Node newNode = new Node(pred, o, succ);// �Ȱ��½��ڵ��ǰ��ָ�븳ֵ
+		succ.prev = newNode;// �Ѳ���ĺ�һ���ڵ��ǰָ��ָ���½ڵ�
+		if (pred == null) {
+			first = newNode;// �������ڵ�ǰָ��Ϊ��,��Ϊͷָ��
+		} else {
+			pred.next = newNode;// ��ǰһ���ڵ�ĺ�ָ��ָ���½ڵ�;
+		}
+		size++;
+	}
+
+	/**
+	 * ����ָ�뷵�ؽڵ���Ϣ
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��21��
+	 * @param index
+	 * @return
+	 */
+	Node node(int index) {
+
+		if (index < (size >> 1)) {// ����ڵ�������ǰ�벿��,
+			Node x = first;// ��ͷָ���x;
+			for (int i = 0; i < index; i++)
+				// ����ǰ�벿�ֽڵ�,
+				x = x.next;// Ѱ������index��ǰһ���ڵ�,����nextָ��
+			return x;
+		} else {
+			Node x = last;
+			for (int i = size - 1; i > index; i--)
+				x = x.prev;
+			return x;
+		}
+	}
+
+	/**
+	 * �������
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��21��
+	 * @param o
+	 */
+	private void linkLast(Object o) {
+		final Node l = last;
+		final Node newNode = new Node(l, o, null);
+		last = newNode;
+		if (last == null) {
+			first = newNode;
+		} else {
+			l.next = newNode;
+		}
+		size++;
+
+	}
+ 
+	public Object get(int index) {
+		checkElementIndex(index);
+		return node(index).item;
+
+	}
+
+	/**
+	 * ���Ԫ���Ǽ��
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��21��
+	 * @param index
+	 */
+	private void checkElementIndex(int index) {
+		if (index >= 0 && index < size) {
+
+		} else {
+			throw new IndexOutOfBoundsException();
+		}
+
+	}
+
+	/**
+	 * ����Ԫ��ʱ���ָ��
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��21��
+	 * @param index
+	 */
+	private void checkPositionIndex(int index) {
+		if (index >= 0 && index <= size)
+			throw new IndexOutOfBoundsException();
+	}
+
+	public boolean reomve(Object o) {
+
+		if (o == null) {
+			for (Node x = first; x != null; x = x.next) {
+				if (x.item == null) {
+					unlink(x);
+					return true;
+				}
+			}
+
+		} else {
+			for (Node x = first; x != null; x = x.next) {
+				if (o.equals(x.item)) {
+					unlink(x);
+					return true;
+				}
+			}
+
+		}
+
+		return false;
+
+	}
+
+	@Override
+	public Object remove(int index) {
+		checkElementIndex(index);
+		return unlink(node(index));
+
+	}
+
+	private Object unlink(Node x) {
+
+		final Object element = x.item;
+		final Node next = x.next;
+		final Node prev = x.prev;
+
+		if (prev == null) {
+			first = next;
+		} else {
+			prev.next = next;
+			x.prev = null;
+		}
+
+		if (next == null) {
+			last = prev;
+		} else {
+			next.prev = prev;
+			x.next = null;
+		}
+
+		x.item = null;
+		size--;
+		return element;
+
+	}
+
+	public Object removeFirst() {
+
+		final Node f = first;
+		if (f == null) {
+			throw new NoSuchElementException();
+		}
+
+		return unlinkFirst(f);
+
+	}
+
+	private Object unlinkFirst(Node f) {
+
+		final Object element = f.item;
+		final Node next = f.next;
+		f.item = null;
+		f.next = null;
+		first = next;
+		if (next == null) {
+			last = null;
+		} else {
+			next.prev = null;
+		}
+		size--;
+
+		return element;
+	}
+
+	public Object removeLast() {
+		Node l = last;
+		if (l == null) {
+			throw new NoSuchElementException();
+		}
+		return unLinkLast(l);
+	}
+
+	private Object unLinkLast(Node l) {
+		final Object element = l.item;
+		final Node prev = l.prev;
+		last = prev;
+		l.item = null;
+		l.prev = null;
+		if (prev == null) {
+			first = null;
+		} else {
+			prev.next = null;
+		}
+		size--;
+
+		return element;
+	}
+
+	public int size() {
+
+		return size;
+	}
+
+}
diff --git a/group08/1425809544/02-26/com/xuyangyang/util/MyList.java b/group08/1425809544/02-26/com/xuyangyang/util/MyList.java
new file mode 100644
index 0000000000..8a2c653c8b
--- /dev/null
+++ b/group08/1425809544/02-26/com/xuyangyang/util/MyList.java
@@ -0,0 +1,14 @@
+package com;
+
+public interface MyList {
+
+	public boolean add(Object o);
+
+	public void add(int index, Object o);
+
+	public Object get(int index);
+
+	public int size();
+
+	public Object remove(int index);
+}
diff --git a/group08/1425809544/02-26/com/xuyangyang/util/MyQueueArray.java b/group08/1425809544/02-26/com/xuyangyang/util/MyQueueArray.java
new file mode 100644
index 0000000000..248edbce26
--- /dev/null
+++ b/group08/1425809544/02-26/com/xuyangyang/util/MyQueueArray.java
@@ -0,0 +1,107 @@
+package com;
+
+import java.util.Arrays;
+
+/**
+ * ����ʵ�ֶ���
+ * 
+ * @Author xuyangyang
+ * @Describe
+ * @date 2017��2��23��
+ */
+public class MyQueueArray {
+
+	private int size;// ��С
+	private int head;// ͷ
+	private Object[] elementData;// ��Ŷ��е�����
+	private int initCapacity = 10;// ��ʼ����
+
+	/**
+	 * ��ʼ����������10
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��23��
+	 */
+	public MyQueueArray() {
+		elementData = new Object[initCapacity];
+	}
+
+	/**
+	 * ��ȡ���д�С
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��23��
+	 * @return
+	 */
+	public int size() {
+		return size;
+	}
+
+	/**
+	 * ���
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��23��
+	 * @param o
+	 */
+	public void enQueue(Object o) {
+		if (size + 1 > elementData.length) {
+			int oldLength = elementData.length;
+			int newLength = oldLength + oldLength >> 1;
+			elementData = Arrays.copyOf(elementData, newLength);
+		}
+		elementData[size++] = o;
+	}
+
+	/**
+	 * ����
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��23��
+	 * @return
+	 */
+	public Object deQueue() {
+		if (size == 0) {
+			throw new NullPointerException();
+		}
+		Object obj = elementData[head];
+		elementData[head] = 0;
+		head++;
+		size--;
+		return obj;
+	}
+
+	/**
+	 * ����
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��23��
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		MyQueueArray myQueue = new MyQueueArray();
+		MyQueueLinked myQueueLinked = new MyQueueLinked();
+		myQueue.enQueue("��1�����");
+		myQueue.enQueue("��2�����");
+		myQueue.enQueue("��3�����");
+		myQueue.enQueue("��4�����");
+		myQueue.enQueue("��5�����");
+		myQueue.enQueue("��6�����");
+		System.out.println(myQueue.size);
+
+		System.out.println(myQueue.deQueue());
+		System.out.println(myQueue.size);
+
+		System.out.println(myQueue.deQueue());
+		System.out.println(myQueue.size);
+
+		System.out.println(myQueue.size);
+
+	}
+
+}
diff --git a/group08/1425809544/02-26/com/xuyangyang/util/MyQueueLinked.java b/group08/1425809544/02-26/com/xuyangyang/util/MyQueueLinked.java
new file mode 100644
index 0000000000..5b4f443975
--- /dev/null
+++ b/group08/1425809544/02-26/com/xuyangyang/util/MyQueueLinked.java
@@ -0,0 +1,139 @@
+package com;
+
+/**
+ * ����ʵ�ֶ���---����
+ * 
+ * @Author xuyangyang
+ * @Describe
+ * @date 2017��2��23��
+ */
+public class MyQueueLinked {
+
+	private Node head;
+
+	private Node tail;
+	// ���еĳ���
+	private int size;
+
+	/**
+	 * ���ض��еĳ���
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��23��
+	 * @return
+	 */
+	public int size() {
+		return size;
+	}
+
+	/**
+	 * ���
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��23��
+	 */
+	public void enQueue(Object obj) {
+
+		// �������Ϊ��
+		if (head == null) {
+			head = new Node(obj, null);
+			tail = head;
+			size++;
+		} else {
+			Node oldNode = tail;
+			Node newNode = new Node(obj, null);
+			tail.next = newNode;
+			tail = newNode;
+			size++;
+		}
+
+	}
+
+	/**
+	 * ����
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��23��
+	 * @return
+	 */
+	public Object deQueue() {
+
+		if (head == null) {
+			throw new NullPointerException();
+		}
+		Object oldNode = head.element;
+		head = head.next;
+		size--;
+		return oldNode;
+	}
+
+	/**
+	 * ȡ����ɾ��
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��23��
+	 * @return
+	 */
+	public Object peek() {
+		if (head == null) {
+			throw new NullPointerException();
+		}
+		return head.element;
+	}
+
+	/**
+	 * �ڵ�
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��23��
+	 */
+	private class Node {
+		private Object element;
+		private Node next;
+
+		public Node() {
+
+		}
+
+		public Node(Object element, Node next) {
+			this.element = element;
+			this.next = next;
+		}
+
+	}
+
+	/**
+	 * ����
+	 * 
+	 * @Author xuyangyang
+	 * @Describe
+	 * @date 2017��2��23��
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		MyQueueLinked myQueueLinked = new MyQueueLinked();
+		myQueueLinked.enQueue("��1�����");
+		myQueueLinked.enQueue("��2�����");
+		myQueueLinked.enQueue("��3�����");
+		myQueueLinked.enQueue("��4�����");
+		myQueueLinked.enQueue("��5�����");
+		myQueueLinked.enQueue("��6�����");
+		System.out.println(myQueueLinked.size);
+
+		System.out.println(myQueueLinked.deQueue());
+		System.out.println(myQueueLinked.size);
+
+		System.out.println(myQueueLinked.deQueue());
+		System.out.println(myQueueLinked.size);
+
+		System.out.println(myQueueLinked.peek());
+		System.out.println(myQueueLinked.size);
+
+	}
+
+}
diff --git a/group08/1425809544/02-26/com/xuyangyang/util/MyStack.java b/group08/1425809544/02-26/com/xuyangyang/util/MyStack.java
new file mode 100644
index 0000000000..9c0a9a6149
--- /dev/null
+++ b/group08/1425809544/02-26/com/xuyangyang/util/MyStack.java
@@ -0,0 +1,95 @@
+package com;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EmptyStackException;
+
+public class MyStack {
+
+	private ArrayList elementDataArrayList = new ArrayList<>();
+
+	private Object[] elementData;
+	private int elementCount;
+	private int size;
+
+	public MyStack() {
+		this.elementData = new Object[10];
+
+	}
+
+	public Object push(Object o) {
+		addElement(o);
+		return o;
+
+	}
+
+	public void addElement(Object o) {
+		ensureCapacity(elementCount + 1);
+		elementData[elementCount++] = o;
+	}
+
+	private void ensureCapacity(int minCapacity) {
+		if (minCapacity - elementData.length > 0) {
+			grow(minCapacity);
+		}
+
+	}
+
+	private void grow(int minCapacity) {
+		int oldCapacity = elementData.length;
+		int newCapacity = oldCapacity + (oldCapacity >> 1);
+		if (newCapacity - minCapacity < 0) {
+			newCapacity = minCapacity;
+		}
+		elementData = Arrays.copyOf(elementData, newCapacity);
+
+	}
+
+	public synchronized Object pop() {
+		Object o;
+		int len = size();
+		o = peek();
+		removeElement(len - 1);
+
+		return o;
+
+	}
+
+	private void removeElement(int index) {
+
+		if (index >= elementCount) {
+			throw new ArrayIndexOutOfBoundsException();
+		} else if (index < 0) {
+			throw new ArrayIndexOutOfBoundsException();
+		}
+		int j = elementCount - index - 1;
+		if (j > 0) {
+			System.arraycopy(elementData, index + 1, elementData, index, j);
+		}
+		elementCount--;
+		elementData[elementCount] = null;
+	}
+
+	private Object peek() {
+
+		int len = size();
+		if (len == 0) {
+			throw new EmptyStackException();
+		}
+		return elementAt(len - 1);
+
+	}
+
+	private Object elementAt(int index) {
+		if (index > +elementCount) {
+			throw new ArrayIndexOutOfBoundsException();
+		}
+		return elementData[index];
+	}
+
+	private int size() {
+		// TODO Auto-generated method stub
+		return elementCount;
+	}
+
+}
diff --git a/group08/1425809544/02-26/com/xuyangyang/util/Test.java b/group08/1425809544/02-26/com/xuyangyang/util/Test.java
new file mode 100644
index 0000000000..0fc81acb8e
--- /dev/null
+++ b/group08/1425809544/02-26/com/xuyangyang/util/Test.java
@@ -0,0 +1,29 @@
+package com;
+
+import java.util.ArrayList;
+
+public class Test {
+
+	public static void main(String[] args) {
+
+		ArrayList<String> items = new ArrayList<>();
+			items.add("1");
+			items.add("2");
+			items.add("3");
+			items.add("4");
+			items.add("5");
+			items.add("6");
+			items.add("7");
+			items.add("8");
+			items.add("9");
+			items.add("10");
+			items.add("11");
+			items.add("12");
+			
+			
+		
+		
+		
+	}
+
+}
diff --git "a/group08/1425809544/02-26/cpu \345\206\205\345\255\230 \347\241\254\347\233\230 \345\222\214\346\214\207\344\273\244\347\232\204\345\205\263\347\263\273.txt" "b/group08/1425809544/02-26/cpu \345\206\205\345\255\230 \347\241\254\347\233\230 \345\222\214\346\214\207\344\273\244\347\232\204\345\205\263\347\263\273.txt"
new file mode 100644
index 0000000000..036bb225b0
--- /dev/null
+++ "b/group08/1425809544/02-26/cpu \345\206\205\345\255\230 \347\241\254\347\233\230 \345\222\214\346\214\207\344\273\244\347\232\204\345\205\263\347\263\273.txt"	
@@ -0,0 +1,16 @@
+
+
+CPU 相当于大脑,是由PC(程序计数器),运算器,控制器,寄存器三大部分组成;
+ 1.cpu从内存读取指令,有pc指定位置,放入指令寄存器;
+ 2,根据读取到的指令,由运算器执行加减命令,
+ 
+ 1.程序在cpu,内存和硬盘运行的速度依次递减,由快到慢,同样的他们价格成本由高到底;存储容量也是由大到小;
+ 
+ 2,cpu和内存中的数据断电后就会消失,硬盘不会消失,所以要把需要长期使用的程序放在硬盘中,程序是由指令组成的,
+ 当开机后,先加载需要的数据从硬盘中读取放到内存中,有cpu从内存中读取指令,要执行的指令和执行后的结果放入cpu的
+ 寄存器中;就相当于原料进机器之前排队一样,把半成品也要在这里放一下，再进去加工，它只是一个临时中转站(寄存器);
+ 
+ 3.CPU从内存中取出指令,放入指令寄存器,并对指令译码操作控制器,操作指令,指令在cpu中暂存在寄存器中;
+	但是,cpu不能直接操作硬盘,所以需要内存,要把硬盘中的数据先加载到内存;内存相当于中转站,内存的速度决定电脑程序运行的速度;
+	
+	有的网络文章形象比喻：“CPU是工厂，硬盘是大仓库，内存是正规中转中心
\ No newline at end of file
diff --git "a/group08/1425809544/02-26/\346\226\207\347\253\240\351\223\276\346\216\245-java\351\233\206\345\220\210 \345\256\271\345\231\250 \347\256\200\345\215\225\346\246\202\350\277\260" "b/group08/1425809544/02-26/\346\226\207\347\253\240\351\223\276\346\216\245-java\351\233\206\345\220\210 \345\256\271\345\231\250 \347\256\200\345\215\225\346\246\202\350\277\260"
new file mode 100644
index 0000000000..ff19095823
--- /dev/null
+++ "b/group08/1425809544/02-26/\346\226\207\347\253\240\351\223\276\346\216\245-java\351\233\206\345\220\210 \345\256\271\345\231\250 \347\256\200\345\215\225\346\246\202\350\277\260"	
@@ -0,0 +1 @@
+http://m.blog.csdn.net/article/details?id=56674070
diff --git a/group08/1425809544/1425809544.md b/group08/1425809544/1425809544.md
new file mode 100644
index 0000000000..61de0edff4
--- /dev/null
+++ b/group08/1425809544/1425809544.md
@@ -0,0 +1 @@
+测试
\ No newline at end of file
diff --git a/group08/1509102580/zzk.md b/group08/1509102580/zzk.md
new file mode 100644
index 0000000000..19fffff42b
--- /dev/null
+++ b/group08/1509102580/zzk.md
@@ -0,0 +1 @@
+I am zzk!
diff --git a/group08/2420826330/2420826330.md b/group08/2420826330/2420826330.md
new file mode 100644
index 0000000000..c55a78db43
--- /dev/null
+++ b/group08/2420826330/2420826330.md
@@ -0,0 +1 @@
+This is 2420826330.
diff --git a/group08/283677872/test b/group08/283677872/test
new file mode 100644
index 0000000000..3d8158f431
--- /dev/null
+++ b/group08/283677872/test
@@ -0,0 +1 @@
+283677872
diff --git "a/group08/286060098/2-26/blong/\345\237\272\346\234\254\347\273\223\346\236\204.md" "b/group08/286060098/2-26/blong/\345\237\272\346\234\254\347\273\223\346\236\204.md"
new file mode 100644
index 0000000000..23d6a12c12
--- /dev/null
+++ "b/group08/286060098/2-26/blong/\345\237\272\346\234\254\347\273\223\346\236\204.md"
@@ -0,0 +1,54 @@
+#指令集
+----
+通俗的理解，指令集就是CPU能认识的语言，指令集运行于一定的微架构之上.指令集有很多,比如复杂指令集AMD,INTEL用的,精简指令集ARM用的
+
+# CPU
+---
+CPU使整个计算机的核心,进行整体的逻辑操作,他的运算速度很快,我们在主机上的操作最终都会变成原子指令由CPU来执行
+
+历史上的CPU对程序的执行存在很多的执行方案,比如说时间片法,令牌环之类的的,每个程序依次交换执行,这样就存在一个问题,程序的换入换出需要保留当前执行情况的现场,还要加载历史程序的历史现场
+
+这些数据存储在哪里?由于CPU的速度过快,而我们是用的大规模的数据存储一般是价格较低速度较慢的磁盘.如果说CPU直接从磁盘加载,CPU的资源利用率会变的很低,会严重浪费了CPU的运算能力.因此我们需要缓存
+
+# 缓存
+---
+缓存的出是为加载相关的数据提供CPU路基运算的存储,CPU中的寄存器就是一种缓存,这是CPU本身对操作的优化.但是说这样高速的缓存本身的制造成本是非常高的,完全使用这样高性能的存储设备并不是一个具有性价比的解决方案
+
+因此出现了多级缓存,常见的如INTEL的L1,L2,L3,这是多级缓存的一种实现,随着层级的升高,存储空间在升高,速度在下将,通过诸如LFU、LRU的缓存置换算法优化相关的缓存命中率提高CPU利用率
+
+理解 Cache --> 传送门 `http://www.mouseos.com/arch/cache.html`
+
+即便是L3的缓存也以就是十分昂贵的,依旧是很难大规模使用的存储设备,因此需要速度相对较快,但是价格又是普通用户可以接收的中间设备,比如内存
+
+# 内存
+---
+内存的存在实际上解决了很多问题,他的价格相对高速缓存来说相对较低,能够提供较大的存储,也可以看作缓存的一种,将磁盘的数据预加载,供高速缓存加载.
+
+内存有很多的工作频率,内存主频越高在一定程度上代表着内存所能达到的速度越快,计算机系统的时钟速度是以频率来衡量的.晶体振荡器控制着时钟速度,在石英晶片上加上电压,其就以正弦波的形式震动起来,这一震动可以通过晶片的形变和大小记录下来。晶体的震动以正弦调和变化的电流的形式表现出来,这一变化的电流就是时钟信号.
+
+内存是一种断电后存储洗洗就会丢失的存储设备,这就尴尬了,对于宕机我们并无法预测,我们需要将众多的资源数据进行存储,这个时候我们需要硬盘.
+
+# 硬盘
+---
+硬盘对于我们而言他的速度反而是其次的,他最大的意义是数据的安全性.在数据安全的基础之上我们再去追求硬盘的速度.
+
+硬盘有很多比如说机械硬盘,固态硬盘,PCI硬盘.机械硬盘.机械硬盘的大体结构如下图,数据的读取需要磁头的移动读取扇区上的信息,这时候磁盘的转速就很重要了
+![yingpan.jpg-19.4kB][1]
+
+固态硬盘可以看作式闪存的堆积,闪存的制造价格的降低带来了他的春天,但是闪存的数据擦除次数有限,固态硬盘的寿命要注意
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  [1]: http://static.zybuluo.com/Haipop/finuq0bs9p1d90q38bccqjea/yingpan.jpg
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/AbstractCollection.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/AbstractCollection.java
new file mode 100644
index 0000000000..52b095dc23
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/AbstractCollection.java
@@ -0,0 +1,25 @@
+package com.pop.practice.homework.first.collection;
+
+/**
+ * @author haipop Date: 17-2-19 Time: 下午3:40
+ */
+public abstract class AbstractCollection<T> implements Collection<T> {
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void addAll(Collection<T> collection) throws IllegalAccessException {
+        Iterator iterator = collection.iterator();
+        while (iterator.hasNext()) {
+            add((T) iterator.next());
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void removeAll(Collection<T> collection) {
+        Iterator iterator = collection.iterator();
+        while (iterator.hasNext()) {
+            remove((T) iterator.next());
+        }
+    }
+}
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/Collection.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/Collection.java
new file mode 100644
index 0000000000..9355d7761f
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/Collection.java
@@ -0,0 +1,42 @@
+package com.pop.practice.homework.first.collection;
+
+/**
+ * @author haipop Date: 17-2-16 Time: 下午6:35
+ */
+public interface Collection<T> extends Iterator<T> {
+
+    /**
+     * 是否为空
+     */
+    boolean isEmpty();
+
+    /**
+     * 获取大小
+     */
+    int size();
+
+    /**
+     * 添加元素
+     */
+    void add(T element) throws IllegalAccessException;
+
+    /**
+     * 批量添加元素
+     */
+    void addAll(Collection<T> collection) throws IllegalAccessException;
+
+    /**
+     * 删除元素
+     */
+    void remove(T element);
+
+    /**
+     * 批量删除元素
+     */
+    void removeAll(Collection<T> collection);
+
+    /**
+     * 元素查找,返回索引,找不到返回-1
+     */
+    int contain(T element);
+}
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/Iterator.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/Iterator.java
new file mode 100644
index 0000000000..0bbe4fa605
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/Iterator.java
@@ -0,0 +1,23 @@
+package com.pop.practice.homework.first.collection;
+
+/**
+ * @author haipop Date: 17-2-16 Time: 下午6:34
+ */
+public interface Iterator<T> {
+
+    /**
+     * 实例化
+     */
+    Iterator iterator();
+
+    /**
+     * 是否存在下一个
+     */
+    boolean hasNext();
+
+    /**
+     * 获取下一个元素
+     */
+    T next();
+
+}
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/list/ArrayList.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/list/ArrayList.java
new file mode 100644
index 0000000000..9c355cc8b4
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/list/ArrayList.java
@@ -0,0 +1,166 @@
+package com.pop.practice.homework.first.collection.list;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+import com.pop.practice.homework.first.collection.AbstractCollection;
+import com.pop.practice.homework.first.collection.Iterator;
+import com.pop.practice.homework.utils.Math;
+
+/**
+ * @author haipop Date: 17-2-16 Time: 下午6:33
+ */
+public class ArrayList<T> extends AbstractCollection<T> implements List<T>, Serializable {
+
+    private static final long serialVersionUID = -3408657766857424074L;
+
+    /**
+     * 阈值
+     */
+    private static final double THRESHOLD = 0.75F;
+
+    /**
+     * 大小
+     */
+    private int size;
+
+    /**
+     * 当前的存储位置
+     */
+    private int flag;
+
+    /**
+     * 元素集合
+     */
+    private Object[] store;
+
+    /**
+     * 是否容量自增
+     */
+    private boolean autoIncrement;
+
+    /**
+     * 遍历器
+     */
+    private Iterator iterator;
+
+    /**
+     * 默认无参
+     */
+    public ArrayList() {
+        this.size = 8;
+        this.flag = 0;
+        this.autoIncrement = true;
+        this.store = new Object[this.size];
+    }
+
+    /**
+     * 指定大小,不可自增
+     */
+    public ArrayList(int size) {
+        this.size = size;
+        this.flag = 0;
+        this.autoIncrement = false;
+        this.store = new Object[size];
+    }
+
+    @Override
+    public Iterator iterator() {
+        this.iterator = new ArrayListIterator();
+        return iterator;
+    }
+
+    @Override
+    public boolean hasNext() {
+        return iterator.hasNext();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T next() {
+        return (T) iterator.next();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    public int size() {
+        return flag;
+    }
+
+    @Override
+    public void add(T element) throws IllegalAccessException {
+        assessStore(flag + 1, size, store, flag);
+        flag++;
+        this.store[flag] = element;
+    }
+
+    private void assessStore(int left, int size, Object[] store, int flag) throws IllegalAccessException {
+        if (!autoIncrement) {
+            return;
+        }
+        double coefficient = Math.div(left, size);
+        if (coefficient > THRESHOLD) {
+            // 达到阈值,拓展
+            Object[] newStore = new Object[this.size * 2];
+            System.arraycopy(store, 0, newStore, 0, flag);
+            this.store = newStore;
+            this.size = size * 2;
+        }
+    }
+
+    @Override
+    public void remove(T element) {
+        for (int i = 0; i < flag; i++) {
+            if (Objects.equals(this.store[i], element)) {
+                System.arraycopy(store, i + 1, store, i, flag - i);
+                flag--;
+                break;
+            }
+        }
+    }
+
+    @Override
+    public int contain(T element) {
+        int result = -1;
+        for (int i = 0; i < flag; i++) {
+            if (Objects.equals(element, store[i])) {
+                return i;
+            }
+        }
+        return result;
+    }
+
+    @Override
+    @SuppressWarnings("uncheckd")
+    public T get(int index) throws IndexOutOfBoundsException {
+        return (T) this.store[index];
+    }
+
+    private class ArrayListIterator implements Iterator {
+
+        private int index;
+
+        ArrayListIterator() {
+            index = 0;
+        }
+
+        @Override
+        public Iterator iterator() {
+            return new ArrayListIterator();
+        }
+
+        @Override
+        public boolean hasNext() {
+            return index < size;
+        }
+
+        @Override
+        public Object next() {
+            return store[index++];
+        }
+    }
+}
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/list/LinkedList.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/list/LinkedList.java
new file mode 100644
index 0000000000..874195596e
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/list/LinkedList.java
@@ -0,0 +1,240 @@
+package com.pop.practice.homework.first.collection.list;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+import com.pop.practice.homework.first.collection.AbstractCollection;
+import com.pop.practice.homework.first.collection.Iterator;
+
+/**
+ * @author haipop Date: 17-2-16 Time: 下午6:34
+ */
+public class LinkedList<T> extends AbstractCollection<T> implements List<T>, Serializable {
+
+    private static final long serialVersionUID = 365915684200725970L;
+
+    /**
+     * 头节点
+     */
+    private Node head;
+
+    /**
+     * 尾节点
+     */
+    private Node tail;
+
+    /**
+     * 标记位
+     */
+    private int flag;
+
+    /**
+     * 遍历器
+     */
+    private Iterator iterator;
+
+    public LinkedList() {
+        this.head = new Node();
+        this.tail = new Node();
+        this.flag = 0;
+        this.head.setNext(tail);
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return this.flag == 0;
+    }
+
+    @Override
+    public int size() {
+        return this.flag;
+    }
+
+    @Override
+    public void add(T element) throws IllegalAccessException {
+        if (this.head.getData() == null) {
+            this.head.setData(element);
+            flag++;
+            return;
+        }
+        if (this.tail.getData() == null) {
+            this.tail.setData(element);
+            this.tail.setBefore(this.head);
+            flag++;
+            return;
+        }
+        Node node = new Node(element);
+        node.setBefore(this.tail);
+        this.tail.next = node;
+        this.tail = node;
+        flag++;
+    }
+
+    @Override
+    public void remove(T element) {
+        if (this.head == null) {
+            return;
+        }
+        Node tmp = this.head;
+        while (tmp.next != null) {
+            if (Objects.equals(tmp.getData(), element)) {
+                if (tmp == this.head) {
+                    if (this.tail.getData() == null) {
+                        this.head.setData(null);
+                    } else {
+                        this.head = this.head.next;
+                        this.head.before = null;
+                    }
+                    flag--;
+                    return;
+                }
+                Node next = tmp.next;
+                Node before = tmp.before;
+                if (next == null) {
+                    before.setNext(null);
+                } else {
+                    before.setNext(next);
+                }
+                next.setBefore(before);
+                flag--;
+                tmp = null;
+            }
+            tmp = tmp.next;
+        }
+    }
+
+    @Override
+    public int contain(T element) {
+        Node tmp = this.head;
+        int index = 0;
+        while (tmp.next != null) {
+            if (Objects.equals(tmp.getData(), element)) {
+                return index;
+            } else {
+                tmp = tmp.next;
+                index++;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public T get(int index) throws IndexOutOfBoundsException {
+        Node tmp = this.head;
+        for (int i = 1; i < index; i++) {
+            if (tail == tmp) {
+                // 到最后还没到指定位置,越界
+                throw new IndexOutOfBoundsException();
+            }
+            tmp = tmp.getNext();
+        }
+        return tmp.getData();
+    }
+
+    @Override
+    public Iterator iterator() {
+        this.iterator = new LinkListIterator();
+        return iterator;
+    }
+
+    @Override
+    public boolean hasNext() {
+        return iterator.hasNext();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T next() {
+        return (T) iterator.next();
+    }
+
+    private class LinkListIterator implements Iterator {
+
+        private Node cache;
+
+        LinkListIterator() {
+            cache = head;
+        }
+
+        @Override
+        public Iterator iterator() {
+            return new LinkListIterator();
+        }
+
+        @Override
+        public boolean hasNext() {
+            return cache.getNext() == null;
+        }
+
+        @Override
+        public Object next() {
+            return cache.getNext();
+        }
+    }
+
+    /**
+     * 链表节点类 --> 这里做了双向链表，这里如果是一个跳表的话查询性能会更好一点
+     */
+    private class Node implements Serializable {
+
+        private static final long serialVersionUID = 6327349429030778592L;
+        /**
+         * 数据
+         */
+        private T data;
+
+        /**
+         * 下一节点
+         */
+        private Node before;
+
+        /**
+         * 下一节点
+         */
+        private Node next;
+
+        Node() {
+        }
+
+        Node(T data) {
+            this.data = data;
+            this.next = null;
+        }
+
+        Node(T data, Node before) {
+            this.data = data;
+            this.before = before;
+        }
+
+        Node(T data, Node before, Node next) {
+            this.data = data;
+            this.before = before;
+            this.next = next;
+        }
+
+        T getData() {
+            return data;
+        }
+
+        void setData(T data) {
+            this.data = data;
+        }
+
+        Node getBefore() {
+            return before;
+        }
+
+        void setBefore(Node before) {
+            this.before = before;
+        }
+
+        Node getNext() {
+            return next;
+        }
+
+        void setNext(Node next) {
+            this.next = next;
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/list/List.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/list/List.java
new file mode 100644
index 0000000000..7be9392b75
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/list/List.java
@@ -0,0 +1,14 @@
+package com.pop.practice.homework.first.collection.list;
+
+import com.pop.practice.homework.first.collection.Collection;
+
+/**
+ * @author haipop Date: 17-2-19 Time: 下午4:03
+ */
+public interface List<T> extends Collection<T> {
+
+    /**
+     * 获取指定位置元素
+     */
+    T get(int index) throws IndexOutOfBoundsException;
+}
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/queue/LinkQueue.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/queue/LinkQueue.java
new file mode 100644
index 0000000000..bb371d64ca
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/queue/LinkQueue.java
@@ -0,0 +1,202 @@
+package com.pop.practice.homework.first.collection.queue;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+import com.pop.practice.homework.first.collection.AbstractCollection;
+import com.pop.practice.homework.first.collection.Collection;
+import com.pop.practice.homework.first.collection.Iterator;
+
+/**
+ * @author haipop Date: 17-2-16 Time: 下午6:34
+ */
+public class LinkQueue<T> extends AbstractCollection<T> implements Queue<T>, Serializable {
+
+    private static final long serialVersionUID = 7942321140756962637L;
+
+    /**
+     * 头节点
+     */
+    private Node head;
+
+    /**
+     * 尾节点,伪节点,这个节点指用来指上一个
+     */
+    private Node tail;
+
+    /**
+     * 现有的元素个数
+     */
+    private int size;
+
+    /**
+     * 遍历器
+     */
+    private Iterator iterator;
+
+    public LinkQueue() {
+        this.size = 0;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public void add(T element) throws IllegalAccessException {
+        if (this.head == null) {
+            this.head = new Node(element);
+            this.tail.setBefore(this.head);
+            this.size++;
+            return;
+        }
+        Node node = new Node(element);
+        node.setBefore(null);
+        node.setNext(this.head.getNext());
+        this.head.getNext().setBefore(node);
+        this.head = node;
+        this.size++;
+    }
+
+    @Override
+    public void remove(T element) {
+        if (isEmpty()) {
+            throw new IndexOutOfBoundsException();
+        }
+        Node tmp = this.head;
+        while (tmp.getNext() == null && tmp.getNext() != this.tail) {
+            if (Objects.equals(tmp.getData(), element)) {
+                Node before = tmp.getBefore();
+                Node next = tmp.getNext();
+                before.setNext(next);
+                next.setBefore(before);
+                tmp = null;
+                break;
+            }
+            tmp = tmp.getNext();
+        }
+    }
+
+    @Override
+    public void push(T element) throws IllegalAccessException {
+        add(element);
+    }
+
+    @Override
+    public void push(Collection<T> collection) throws IllegalAccessException {
+        addAll(collection);
+    }
+
+    @Override
+    public int contain(T element) {
+        Node tmp = this.head;
+        int index = 0;
+        while (tmp.next != null && tmp != this.tail) {
+            if (Objects.equals(tmp.getData(), element)) {
+                return index;
+            } else {
+                tmp = tmp.next;
+                index++;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public T pull() {
+        if (isEmpty()) {
+            throw new IndexOutOfBoundsException();
+        }
+        Node node = this.tail.getBefore();
+        this.tail.setBefore(node.getBefore());
+        size--;
+        return node.getData();
+    }
+
+    @Override
+    public Iterator iterator() {
+        this.iterator = new LinkQueueIterator();
+        return iterator;
+    }
+
+    @Override
+    public boolean hasNext() {
+        return this.iterator.hasNext();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T next() {
+        return (T) this.iterator.next();
+    }
+
+    private class LinkQueueIterator implements Iterator {
+
+        private Node cache;
+
+        LinkQueueIterator() {
+            this.cache = head;
+        }
+
+        @Override
+        public Iterator iterator() {
+            return new LinkQueueIterator();
+        }
+
+        @Override
+        public boolean hasNext() {
+            return cache.getNext() == tail;
+        }
+
+        @Override
+        public T next() {
+            return cache.getNext().getData();
+        }
+    }
+
+    private class Node implements Serializable {
+
+        private static final long serialVersionUID = 6400564182277299061L;
+
+        private T data;
+
+        private Node before;
+
+        private Node next;
+
+        Node(T data) {
+            this.data = data;
+        }
+
+        T getData() {
+            return data;
+        }
+
+        void setData(T data) {
+            this.data = data;
+        }
+
+        Node getBefore() {
+            return before;
+        }
+
+        void setBefore(Node before) {
+            this.before = before;
+        }
+
+        Node getNext() {
+            return next;
+        }
+
+        void setNext(Node next) {
+            this.next = next;
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/queue/Queue.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/queue/Queue.java
new file mode 100644
index 0000000000..92f46378e0
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/queue/Queue.java
@@ -0,0 +1,26 @@
+package com.pop.practice.homework.first.collection.queue;
+
+import com.pop.practice.homework.first.collection.Collection;
+
+/**
+ * 更符合Queue语义的方法
+ * 
+ * @author haipop Date: 17-2-19 Time: 下午3:23
+ */
+public interface Queue<T> extends Collection<T> {
+
+    /**
+     * 添加元素
+     */
+    void push(T element) throws IllegalAccessException;
+
+    /**
+     * 添加元素
+     */
+    void push(Collection<T> collection) throws IllegalAccessException;
+
+    /**
+     * 取元素,删除最后一个并返回
+     */
+    T pull();
+}
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/stack/LinkStack.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/stack/LinkStack.java
new file mode 100644
index 0000000000..c9a0edd124
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/stack/LinkStack.java
@@ -0,0 +1,94 @@
+package com.pop.practice.homework.first.collection.stack;
+
+import java.io.Serializable;
+
+import com.pop.practice.homework.first.collection.AbstractCollection;
+import com.pop.practice.homework.first.collection.Iterator;
+import com.pop.practice.homework.first.collection.list.LinkedList;
+import com.pop.practice.homework.first.collection.list.List;
+
+/**
+ * @author haipop Date: 17-2-16 Time: 下午6:33
+ */
+public class LinkStack<T> extends AbstractCollection<T> implements Stack<T>, Serializable {
+
+    private static final long serialVersionUID = -2813631170103864318L;
+
+    /**
+     * 数据存储
+     */
+    private List<T> cache;
+
+    /**
+     * 数据量
+     */
+    private int size;
+
+    /**
+     * 遍历器
+     */
+    private Iterator iterator;
+
+    public LinkStack() {
+        this.size = 0;
+        this.cache = new LinkedList<T>();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public void push(T element) throws IllegalAccessException {
+        this.cache.add(element);
+        size++;
+    }
+
+    @Override
+    public void add(T element) throws IllegalAccessException {
+        this.cache.add(element);
+        size++;
+    }
+
+    @Override
+    public T pull() throws IndexOutOfBoundsException {
+        T result = this.cache.get(size - 1);
+        size--;
+        return result;
+    }
+
+    @Override
+    public void remove(T element) {
+        cache.remove(element);
+        size--;
+    }
+
+    @Override
+    public int contain(T element) {
+        return cache.contain(element);
+    }
+
+    @Override
+    public Iterator iterator() {
+        this.iterator = this.cache.iterator();
+        return iterator;
+    }
+
+    @Override
+    public boolean hasNext() {
+        return this.iterator.hasNext();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T next() {
+        return (T) this.iterator.next();
+    }
+
+}
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/stack/Stack.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/stack/Stack.java
new file mode 100644
index 0000000000..c9ea66dd2b
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/collection/stack/Stack.java
@@ -0,0 +1,22 @@
+package com.pop.practice.homework.first.collection.stack;
+
+import com.pop.practice.homework.first.collection.Collection;
+
+/**
+ * 
+ * 更符合Stack语义的方法
+ * 
+ * @author haipop Date: 17-2-19 Time: 下午3:50
+ */
+public interface Stack<T> extends Collection<T> {
+
+    /**
+     * 添加元素
+     */
+    void push(T element) throws IllegalAccessException;
+
+    /**
+     * 取元素
+     */
+    T pull();
+}
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/AbstractTree.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/AbstractTree.java
new file mode 100644
index 0000000000..4e86940103
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/AbstractTree.java
@@ -0,0 +1,29 @@
+package com.pop.practice.homework.first.tree;
+
+import com.pop.practice.homework.first.collection.Iterator;
+import com.pop.practice.homework.first.collection.list.List;
+
+/**
+ * @author haipop Date: 17-2-20 Time: 上午9:53
+ */
+public abstract class AbstractTree<T extends Comparable> implements Tree<T> {
+
+    @Override
+    public void addNode(T[] elements) throws IllegalAccessException {
+        for (T ele : elements) {
+            addNode(ele);
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void addNode(List<T> elements) throws IllegalAccessException {
+        Iterator iterator = elements.iterator();
+        while (iterator.hasNext()) {
+            addNode((T) iterator.next());
+        }
+    }
+
+
+    protected abstract void addNode(T elements) throws IllegalAccessException;
+}
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/BinaryNode.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/BinaryNode.java
new file mode 100644
index 0000000000..db34c48460
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/BinaryNode.java
@@ -0,0 +1,40 @@
+package com.pop.practice.homework.first.tree;
+
+class BinaryNode<T> {
+
+    private T data;
+
+    private BinaryNode left;
+
+    private BinaryNode right;
+
+    public BinaryNode(T data, BinaryNode left, BinaryNode right) {
+        this.data = data;
+        this.left = left;
+        this.right = right;
+    }
+
+    public T getData() {
+        return data;
+    }
+
+    public void setData(T data) {
+        this.data = data;
+    }
+
+    public BinaryNode getLeft() {
+        return left;
+    }
+
+    public void setLeft(BinaryNode left) {
+        this.left = left;
+    }
+
+    public BinaryNode getRight() {
+        return right;
+    }
+
+    public void setRight(BinaryNode right) {
+        this.right = right;
+    }
+}
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/BinaryTree.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/BinaryTree.java
new file mode 100644
index 0000000000..eff95ec6f9
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/BinaryTree.java
@@ -0,0 +1,125 @@
+package com.pop.practice.homework.first.tree;
+
+import java.io.Serializable;
+
+import com.pop.practice.homework.first.collection.queue.LinkQueue;
+import com.pop.practice.homework.first.collection.queue.Queue;
+
+/**
+ * 左大右小
+ * 
+ * @author haipop Date: 17-2-20 Time: 上午9:42
+ */
+public class BinaryTree<T extends Comparable> extends AbstractTree<T> implements Serializable {
+
+    private static final long serialVersionUID = -1467347526158258388L;
+
+    /**
+     * 根节点
+     */
+    private BinaryNode root;
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected void addNode(T elements) throws IllegalAccessException {
+        if (root == null) {
+            root = new BinaryNode<T>(elements, null, null);
+        }
+        BinaryNode<T> newNode = new BinaryNode<>(elements, null, null);
+        Queue<BinaryNode> queue = new LinkQueue<>();
+        queue.add(root);
+        while (queue.isEmpty()) {
+            BinaryNode node = queue.pull();
+            if (((Comparable) node.getData()).compareTo(elements) > 0) {
+                if (node.getRight() == null) {
+                    node.setRight(newNode);
+                    break;
+                } else {
+                    queue.add(node.getRight());
+                }
+            } else if (((Comparable) node.getData()).compareTo(elements) < 0) {
+                if (node.getLeft() == null) {
+                    node.setLeft(newNode);
+                    break;
+                } else {
+                    queue.add(node.getLeft());
+                }
+            }
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void removeNode(T elements) throws IllegalAccessException {
+        if (root == null) {
+            return;
+        }
+        root = removeNode(elements, root);
+    }
+
+    @SuppressWarnings("unchecked")
+    private BinaryNode removeNode(T element, BinaryNode<T> node) {
+        BinaryNode left = node.getLeft();
+        BinaryNode right = node.getRight();
+        if (node.getData().compareTo(element) > 0) {
+            BinaryNode removeNode = removeNode(element, right);
+            moveNode(element, node, left, right, removeNode);
+            node.setRight(removeNode);
+        } else if (node.getData().compareTo(element) < 0) {
+            BinaryNode removeNode = removeNode(element, left);
+            moveNode(element, node, left, right, removeNode);
+            node.setLeft(removeNode);
+        }
+        if (left != null) {
+            return left;
+        } else if (right != null) {
+            return right;
+        } else {
+            return null;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private void moveNode(T element, BinaryNode<T> node, BinaryNode<T> left, BinaryNode<T> right,
+            BinaryNode<T> removeNode) {
+        if (removeNode.getData().compareTo(right) > 0) {
+            BinaryNode tmp = removeNode.getRight();
+            while (tmp != null) {
+                tmp = tmp.getRight();
+            }
+            tmp.setRight(left.getRight());
+        } else if (node.getData().compareTo(element) < 0) {
+            BinaryNode tmp = removeNode.getLeft();
+            while (tmp != null) {
+                tmp = tmp.getLeft();
+            }
+            tmp.setLeft(right.getLeft());
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public boolean contain(T data) throws IllegalAccessException {
+        if (root == null) {
+            return false;
+        }
+        Queue<BinaryNode> queue = new LinkQueue<>();
+        queue.add(root);
+        while (queue.isEmpty()) {
+            BinaryNode node = queue.pull();
+            if (((Comparable) node.getData()).compareTo(data) > 0) {
+                if (node.getRight() != null) {
+                    queue.add(node.getRight());
+                }
+            } else if (((Comparable) node.getData()).compareTo(data) < 0) {
+                if (node.getLeft() == null) {
+                    queue.add(node.getLeft());
+                }
+            } else {
+                return true;
+            }
+        }
+        return false;
+    }
+
+}
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/Tree.java b/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/Tree.java
new file mode 100644
index 0000000000..174a98bc2c
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/first/tree/Tree.java
@@ -0,0 +1,30 @@
+package com.pop.practice.homework.first.tree;
+
+import com.pop.practice.homework.first.collection.list.List;
+
+/**
+ * @author haipop Date: 17-2-19 Time: 下午5:12
+ */
+public interface Tree<T extends Comparable> {
+
+    /**
+     * 添加节点
+     */
+    void addNode(T... elements) throws IllegalAccessException;
+
+    /**
+     * 添加节点
+     */
+    void addNode(List<T> elements) throws IllegalAccessException;
+
+    /**
+     * 删除节点
+     */
+    void removeNode(T element) throws IllegalAccessException;
+
+    /**
+     * 节点查找,找到返回节点信息,找不到返回null
+     */
+    boolean contain(T data) throws IllegalAccessException;
+
+}
\ No newline at end of file
diff --git a/group08/286060098/2-26/src/com/pop/practice/homework/utils/Math.java b/group08/286060098/2-26/src/com/pop/practice/homework/utils/Math.java
new file mode 100644
index 0000000000..b20c1bb486
--- /dev/null
+++ b/group08/286060098/2-26/src/com/pop/practice/homework/utils/Math.java
@@ -0,0 +1,29 @@
+package com.pop.practice.homework.utils;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+/**
+ * @author haipop Date: 17-2-18 Time: 下午1:00
+ */
+public class Math {
+
+    public static double div(int left, int right) throws IllegalAccessException {
+        return div((double) left, (double) right, 2);
+    }
+
+    public static double div(int left, int right, int scale) throws IllegalAccessException {
+        return div((double) left, (double) right, scale);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static double div(double left, double right, int scale) throws IllegalAccessException {
+        // 如果精确范围小于0，抛出异常信息
+        if (scale < 0) {
+            throw new IllegalAccessException("精确度不能小于0");
+        }
+        BigDecimal divisor = new BigDecimal(left);
+        BigDecimal dividend = new BigDecimal(right);
+        return divisor.divide(dividend, scale, RoundingMode.HALF_EVEN).doubleValue();
+    }
+}
\ No newline at end of file
diff --git a/group08/286060098/readme.md b/group08/286060098/readme.md
new file mode 100644
index 0000000000..a6325e29da
--- /dev/null
+++ b/group08/286060098/readme.md
@@ -0,0 +1,17 @@
+# Module说明
+
+---
+
+### 文件夹说明
+| 文件夹        | 描述   　  |
+| --------   |  :----:  |
+| blong     |相关的说明文档,博客 |
+| script  | 相关的脚本信息，如有sql脚本也请在这里查找   |
+| src     | 代码目录｜
+
+### 代码说明
+
+> 作业在homework目录下
+
+
+
diff --git a/group08/406166841/2-26/CPU.md b/group08/406166841/2-26/CPU.md
new file mode 100644
index 0000000000..0184372f60
--- /dev/null
+++ b/group08/406166841/2-26/CPU.md
@@ -0,0 +1,76 @@
+CPU：中央处理单元(Cntral Pocessing Uit)的缩写，也叫处理器，是计算机的运算核心和控制核心。人靠大脑思考，电脑靠CPU来运算、控制。让电脑的各个部件顺利工作，起到协调和控制作用。
+
+内存：1. 负责硬盘等硬件上的数据与CPU之间数据交换处理；2. 缓存系统中的临时数据。3. 断电后数据丢失。
+硬盘：存储资料和软件等数据的设备，有容量大，断电数据不丢失的特点。也被人们称之为“数据仓库”。
+
+现在我们来说一下CPU、硬盘、内存三者之间的关系。 
+
+首先 ,我们先回想一下三者的作用：
+
+CPU：是计算机的运算核心和控制核心，让电脑的各个部件顺利工作，起到协调和控制作用。
+硬盘：存储资料和软件等数据的设备，有容量大，断电数据不丢失的特点。也被人们称之为“数据仓库”。
+内存：1. 负责硬盘等硬件上的数据与CPU之间数据交换处理；2. 缓存系统中的临时数据。3. 断电后数据丢失。
+
+然后， 我们再来看一下程序是如何执行起来的。
+
+当我们在电脑上打开QQ时（右键-打开 或者双击QQ图标），其实是通过鼠标（输入设备）向CPU发送了一条命令，CPU接收到这条命令后，QQ程序就从硬盘里被加载到内存（加载时不通过处理器，直接从硬盘加载程序到内存里），加载完成后，CPU就开始执行QQ程序。程序执行起来后，CPU可以让QQ程序显示在我们的在显示器上。也就是你看到了QQ 程序运行起来了。如果这个时候，你用QQ截取了一张屏幕的图片，那么这张图片会首先保存到内存，在没有退出截屏状态时，你可以在这张图片上写字、画线条，等你右键保存这张图片的时候，这张图片就会保存到硬盘里。
+
+通过了解一个程序是如何运行起来的，我们就可以了解三者是如何工作的 。
+
+可能有些人会不明白，如果程序是这样执行起来的话，那么为什么CPU不直接在硬盘里执行程序，而非要把程序放到内存后在执行呢？
+
+因为速度差别太大：
+内存存取数据的速度比硬盘的存取速度快了10倍， 在某些环境里，硬盘和内存之间的速度差距可能会更大。
+
+而CPU的速度比内存不知还要快多少倍。当我们把程序从硬盘放到内存以后，CPU就直接在内存运行程序，这样比CPU直接在硬盘运行程序就要快很多。
+
+内存解决了一部分CPU运行过快，而硬盘数据存取太慢的问题。 提高了我们的电脑的运行速度。
+
+内存就如同一条“高速车道”一般，数据由传输速度较慢的硬盘通过这条高速车道传送至CPU进行处理！
+
+但内存是带电存储的(一旦断电数据就会消失)，而且容量有限，所以要长时间储存程序或数据就需要使用硬盘。
+
+其实内存在这里起了两个作用：
+
+1.  保存从硬盘读取的数据，提供给CPU使用
+
+2. 保存CPU的一些临时执行结果，以便CPU下次使用或保存到硬盘
+
+
+
+数字电子中有各种逻辑功能,最简单的是与或非,数字电子中用01表示数据比如你表示 12(10进制)
+
+12 = 8*1+4*1+2*0+1*0表示为 1100你可以试试所有数字都可以这么表示出来,而1和0在数电中用"高电平","低电平"表示,说白了就是通电表示1断电表示0.
+
+硅片上的集成电路可以把这些门电路作到非常小,这样人们用各种逻辑电路就能实现复杂的计算器功能,
+
+我们姑且认为只能算加减乘除吧.你想算什么算式都可以用逻辑电路来实现.但是人们往往想算的东西都比较复杂比如这个
+
+1*1+2*2+3*3+4*4...10000000*10000000
+
+如果一次运算需要一个逻辑电路,那么这就需要2*10000000个逻辑电路,
+
+额,恕我直言,这个成本有点高,
+
+于是人们想到了一个好办法,就是做一个逻辑器件,有2个输入,分别是数据输入,指令输入,数据输入就是输入要运算的两个数据,指令输入输入让这个器件干什么,比如00就是做加法,01就是做减法,10是乘法,11是除法,然后给他配个储存设备用来保存数据,这样我们让这一个设备不断的运行,按照一定规则把输出的数据送回输入就能完成上面提到的运算了.
+
+后来这个设备被称为CPU,
+
+CPU除了运算逻辑以外,还能执行: 1 移动数据 2 逻辑运算 3 跳转指令 还有些杂七杂八的指令
+
+移动数据就是把输出的数据送回输入的指令,通常数据存储在寄存器或者RAM中,储存器就像游泳馆的柜子,上面有个编号,里面存了个数字.后来编号被程序猿称为地址.
+
+有了这些我们还有一件事没做,想想是什么?
+
+就是告诉CPU,今天要做的指令,最开始指令是存储在穿孔纸带上的,现在是储存在硬盘里的
+
+CPU一个一个地读进来,读一个执行一个操作.因此执行上面的操作要在纸带上打 2*10000000个以上的孔,这也有点麻烦
+
+幸好我们的运算是有规律的,因此我们可以让纸带走一走倒带再走一走,直到某个条件满足了为止.这样的指令就是转移指令。
+
+from：
+
+http://www.guokr.com/question/482025/
+
+
+
diff --git a/group08/406166841/2-26/CustomArrayList.java b/group08/406166841/2-26/CustomArrayList.java
new file mode 100644
index 0000000000..46dbe3d40d
--- /dev/null
+++ b/group08/406166841/2-26/CustomArrayList.java
@@ -0,0 +1,92 @@
+package net.iyouqu.bruceretrofit.util.java;
+
+import java.util.Arrays;
+
+/**
+ * Created by liq on 2017/2/25.
+ */
+
+public class CustomArrayList implements List {
+
+    private int size = 0;
+
+    private final static int DEFAULT_CAPACITY = 10;
+    private final static int MAX_ARRAY_LENGTH = Integer.MAX_VALUE - 8;
+
+    private Object[] elementData = new Object[DEFAULT_CAPACITY];
+    private String desc = "index超过界限";
+
+    @Override
+    public void add(Object o) {
+        isCapacityEnough(size + 1);
+        elementData[size++] = o;
+    }
+
+    @Override
+    public void add(int index, Object o) {
+        checkRangeForAdd(index);
+        isCapacityEnough(size + 1);
+        System.arraycopy(elementData, index, elementData, index + 1, size - index);
+        elementData[index] = o;
+        size++;
+    }
+
+    @Override
+    public Object get(int index) {
+        checkRange(index);
+        return elementData[index];
+    }
+
+    @Override
+    public Object remove(int index) {
+        Object value = get(index);
+        int moveSize = size - index - 1;
+        if (moveSize > 0){
+            System.arraycopy(elementData,index + 1, elementData,index,size - index - 1);
+        }
+        elementData[--size] = null;
+        return value;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    private void checkRange(int index) {
+        if (index >= size || index < 0) {
+            throw new IndexOutOfBoundsException(desc);
+        }
+    }
+
+    private void checkRangeForAdd(int index) {
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException(desc);
+        }
+    }
+
+    private void explicitCapacity(int capacity) {
+        int newLength = elementData.length * 2;
+        if (newLength - capacity < 0) {
+            newLength = capacity;
+        }
+        if (newLength > (MAX_ARRAY_LENGTH)) {
+            newLength = (capacity > MAX_ARRAY_LENGTH ? Integer.MAX_VALUE : MAX_ARRAY_LENGTH);
+        }
+        elementData = Arrays.copyOf(elementData, newLength);
+    }
+
+    private void isCapacityEnough(int size) {
+        if (size > DEFAULT_CAPACITY) {
+            explicitCapacity(size);
+        }
+        if (size < 0) {
+            throw new OutOfMemoryError();
+        }
+    }
+
+    public Iterator iterator() {
+        return null;
+    }
+
+}
diff --git a/group08/406166841/2-26/CustomLinkedList.java b/group08/406166841/2-26/CustomLinkedList.java
new file mode 100644
index 0000000000..532b9b8eaf
--- /dev/null
+++ b/group08/406166841/2-26/CustomLinkedList.java
@@ -0,0 +1,172 @@
+package net.iyouqu.bruceretrofit.util.java;
+
+/**
+ * Created by liq on 2017/2/25.
+ */
+
+public class CustomLinkedList<E> implements List {
+
+    //链表长度
+    private int size = 0;
+    //链表头指针
+    private Node<Object> first;
+    //链表尾部指针
+    private Node<Object> last;
+    //操作次数
+    private int modCount;
+
+    @Override
+    public void add(Object o) {
+        linkLast(o);
+    }
+
+    @Override
+    public void add(int index, Object o) {
+        checkPositionIndex(index);
+        if (index == size) {
+            linkLast(o);
+        } else {
+            linkBefore(o, node(index));
+        }
+    }
+
+    @Override
+    public Object get(int index) {
+        checkPositionIndex(index);
+        return node(index).data;
+    }
+
+    @Override
+    public Object remove(int index) {
+        checkPositionIndex(index);
+        return unlink(node(index));
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    /**
+     * 添加节点到链表尾部
+     */
+    public void addLast(Object e) {
+        linkLast(e);
+    }
+
+    /**
+     * 解除传入节点的属性,并且将传入节点的上一个和下一个节点 链接。使传入节点的属性 全部为 null
+     */
+    private Object unlink(Node<Object> node) {
+        //获取当前节点node的属性
+        final Object element = node.data;
+        final Node<Object> next = node.next;
+        final Node<Object> prev = node.prev;
+        if (prev == null) {
+            //上一个节点为null将首节点设置为下一个节点
+            first = next;
+        } else {
+            //上一个节点有 将上一个节点的下一个节点 设置为当前节点的下一个节点
+            prev.next = next;
+            //将当前节点的上一个节点设置为null
+            node.prev = null;
+        }
+        if (next == null) {
+            //下一个节点为null将末尾节点设置为上一个节点
+            last = prev;
+        } else {
+            //将下一个节点的上一个节点 设置为当前节点的上一个节点
+            next.prev = prev;
+            node.next = null;
+        }
+        node.data = null;
+        size--;
+        modCount++;
+        return element;
+    }
+
+    /**
+     * 获取一个节点
+     * 判断index 在前半区间还是后半区间。而不是一直从头到尾搜索
+     * 将节点访问复杂度从O(n)变为O(n/2)
+     */
+    private Node<Object> node(int index) {
+        checkPositionIndex(index);
+        if (index < (size / 2)) {
+            Node<Object> x = first;
+            for (int i = 0; i < index; i++) {
+                x = x.next;
+            }
+            return x;
+        } else {
+            Node<Object> x = last;
+            for (int i = size - 1; i > index; i--) {
+                x = x.prev;
+            }
+            return x;
+        }
+    }
+
+    /**
+     * 在参数节点之前插入一个节点
+     */
+    private void linkBefore(Object element, Node<Object> node) {
+        //获取添加节点的上一个节点
+        final Node<Object> pred = node.prev;
+        //创建一个新节点
+        final Node<Object> newNode = new Node<>(pred, element, node);
+        //添加节点的上一个节点为 新节点
+        node.prev = newNode;
+        //判断上一个节点是否为null
+        if (pred == null) {
+            //首节点设置为新创建的节点
+            first = newNode;
+        } else {
+            //上个节点不为null。将其下个节点设置为新创建的节点。
+            pred.next = newNode;
+        }
+        size++;
+        modCount++;
+    }
+
+    /**
+     * 链接 节点到 last
+     */
+    private void linkLast(Object e) {
+        final Node<Object> l = last;
+        final Node<Object> newNode = new Node<>(l, e, null);
+        last = newNode;
+        //判断链表last是否为null
+        if (l == null) {
+            //链表first指向新添加的 节点
+            first = newNode;
+        } else {
+            //链表last不为null将链表last节点的的next设置为新节点
+            l.next = newNode;
+        }
+        size++;
+        modCount++;
+    }
+
+    /**
+     * 检查index是否越界
+     */
+    private void checkPositionIndex(int index) {
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException("index超过界限");
+        }
+    }
+
+    private static class Node<E> {
+        Object data;
+        //下一个节点
+        Node<Object> next;
+        //上一个节点
+        Node<Object> prev;
+        public Node(Node<Object> prev, Object item, Node<Object> next) {
+            this.data = item;
+            this.next = next;
+            this.prev = prev;
+        }
+    }
+}
diff --git a/group08/406166841/2-26/CustomQueue.java b/group08/406166841/2-26/CustomQueue.java
new file mode 100644
index 0000000000..00f3d89f6d
--- /dev/null
+++ b/group08/406166841/2-26/CustomQueue.java
@@ -0,0 +1,51 @@
+package net.iyouqu.bruceretrofit.util.java;
+
+/**
+ * Created by liq on 2017/2/25.
+ */
+
+public class CustomQueue<E> {
+
+    Object[] data = null;
+    //容量
+    private int capacity;
+    //队尾指针
+    private int tail;
+
+    CustomQueue(int initSize) {
+        if (initSize >= 0) {
+            this.capacity = initSize;
+            data = new Object[initSize];
+            tail = 0;
+        } else {
+            throw new RuntimeException("初始化大小不能小于0" + initSize);
+        }
+    }
+
+    public void enQueue(E o){
+        ensureCapacity();
+        data[tail] = o;
+        tail++;
+    }
+
+    public E deQueue(){
+        return (E) data[0];
+    }
+
+    public boolean isEmpty(){
+        return tail == 0;
+    }
+
+    public int size(){
+        return tail;
+    }
+
+    private void ensureCapacity() {
+        if (tail == capacity) {
+            capacity *= 2;
+            Object[] newData = new Object[capacity];
+            System.arraycopy(data, 0, newData, 0, tail);
+            data = newData;
+        }
+    }
+}
diff --git a/group08/406166841/2-26/CustomStack.java b/group08/406166841/2-26/CustomStack.java
new file mode 100644
index 0000000000..c83c7aee78
--- /dev/null
+++ b/group08/406166841/2-26/CustomStack.java
@@ -0,0 +1,70 @@
+package net.iyouqu.bruceretrofit.util.java;
+
+import java.util.ArrayList;
+
+/**
+ * Created by liq on 2017/2/25.
+ */
+
+public class CustomStack<E> {
+
+    //重载因子
+    private static final float LOAD_FACTOR = 0.75f;
+    //需要扩充容量时的大小
+    private int resizeCapacity;
+    private Object[] data = null;
+    //栈容量
+    private int capacity;
+    //栈顶
+    private int top;
+
+    public CustomStack(int initSize) {
+        if (initSize >= 0) {
+            this.capacity = initSize;
+            data = new Object[initSize];
+            top = 0;
+            this.resizeCapacity = (int) (capacity * LOAD_FACTOR);
+        } else {
+            throw new RuntimeException("初始化大小不能小于0:" + initSize);
+        }
+    }
+
+    private ArrayList elementData = new ArrayList();
+
+    public void push(E o){
+        checkStackCapacity();
+        data[top] = o;
+        top++;
+    }
+
+    public E pop(){
+        if(top<=0)
+            throw new RuntimeException("没有元素不能弹出");
+        E e = (E) data[top - 1];
+        data[top-1] = null;
+        --top;
+        return e;
+    }
+
+    public E peek(){
+
+        return (E) data[top - 1];
+
+    }
+    public boolean isEmpty(){
+        return top == 0;
+    }
+    public int size(){
+        return top;
+    }
+
+    private void checkStackCapacity() {
+        if (top == resizeCapacity) {
+            capacity = capacity * 2;
+            Object[] newData = new Object[capacity];
+            System.arraycopy(data, 0, newData, 0, top);
+            data = newData;
+        }
+    }
+
+}
diff --git a/group08/406166841/2-26/Iterator.java b/group08/406166841/2-26/Iterator.java
new file mode 100644
index 0000000000..2a90aac57b
--- /dev/null
+++ b/group08/406166841/2-26/Iterator.java
@@ -0,0 +1,10 @@
+package net.iyouqu.bruceretrofit.util.java;
+
+/**
+ * Created by liq on 2017/2/25.
+ */
+
+public interface Iterator {
+    public boolean hasNext();
+    public Object next();
+}
diff --git a/group08/406166841/2-26/List.java b/group08/406166841/2-26/List.java
new file mode 100644
index 0000000000..b302910fb0
--- /dev/null
+++ b/group08/406166841/2-26/List.java
@@ -0,0 +1,13 @@
+package net.iyouqu.bruceretrofit.util.java;
+
+/**
+ * Created by liq on 2017/2/25.
+ */
+
+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/group08/406166841/406166841.md b/group08/406166841/406166841.md
new file mode 100644
index 0000000000..aef5098754
--- /dev/null
+++ b/group08/406166841/406166841.md
@@ -0,0 +1 @@
+406166841
\ No newline at end of file
diff --git "a/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/ArrayList.java" "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/ArrayList.java"
new file mode 100644
index 0000000000..4e31d64920
--- /dev/null
+++ "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/ArrayList.java"
@@ -0,0 +1,92 @@
+package com.coding.basic;
+
+public class ArrayList implements List {
+	// size不仅是ArrayList中实际存值得体现，直接add时，也是在elementData[size]处进行
+	private int size = 0;
+	// 数组是连续且有序的
+	private Object[] elementData;
+
+	private void resize(int newSize) {
+		Object[] newArray = new Object[newSize];
+		System.arraycopy(elementData, 0, newArray, 0, size);
+		elementData = newArray;
+	}
+
+	public ArrayList() {
+		elementData = new Object[10];
+	}
+
+	// 添加指定元素至列表尾
+	public void add(Object o) {
+		if (size == elementData.length) {
+			resize(size * 2);
+		}
+		elementData[size++] = o;
+	}
+
+	// 将指定元素插入列表中的指定位置。移动当前位置的元素（如果有的话）和右边的后续元素（向索引添加一个元素）
+	public void add(int index, Object o) {
+		rangeCheck(index);
+		if (size == elementData.length / 4) {
+			resize(elementData.length / 2);
+		}
+		System.arraycopy(elementData, index, elementData, index + 1, size - index);
+		elementData[index] = o;
+		size++;
+	}
+	
+	/*
+	 * 获取指定位置元素
+	 * (non-Javadoc)
+	 * @see com.coding.basic.List#get(int)
+	 */
+	public Object get(int index) {
+		rangeCheck(index);
+		return elementData[index];
+	}
+	
+	/*
+	 * 删除指定位置元素
+	 * (non-Javadoc)
+	 * @see com.coding.basic.List#remove(int)
+	 */
+	public Object remove(int index) {
+		rangeCheck(index);
+		Object oldValue = elementData[index];
+		System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
+		size--;
+		return oldValue;
+	}
+
+	public int size() {
+		return this.size;
+	}
+
+	public Iterator iterator() {
+		return new ArrayListIterator();
+	}
+
+	// 检测索引值，当前有size个元素，占了elementData[0]至elementData[size-1],add时，只能在已有[0,size-1]处插入，或者在列表尾size处add
+	// 所以index在[0,size之间]
+	private void rangeCheck(int index) {
+		if (index < 0 || index > size) {
+			throw new IndexOutOfBoundsException();
+		}
+	}
+
+	class ArrayListIterator implements Iterator {
+		int i = 0;
+
+		@Override
+		public boolean hasNext() {
+			return i < size;
+		}
+
+		@Override
+		public Object next() {
+			return elementData[i++];
+		}
+
+	}
+
+}
diff --git "a/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/BinaryTreeNode.java" "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/BinaryTreeNode.java"
new file mode 100644
index 0000000000..d7ac820192
--- /dev/null
+++ "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/BinaryTreeNode.java"
@@ -0,0 +1,32 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git "a/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/Iterator.java" "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/Iterator.java"
new file mode 100644
index 0000000000..06ef6311b2
--- /dev/null
+++ "b/group08/529757467/2017-02-26\344\275\234\344\270\232/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/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/LinkedList.java" "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/LinkedList.java"
new file mode 100644
index 0000000000..b036d5ba91
--- /dev/null
+++ "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/LinkedList.java"
@@ -0,0 +1,143 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+
+	private int size = 0;
+	// 头结点
+	private Node head;
+	// 尾结点
+	private Node tail;
+
+	private void rangeCheck(int index) {
+		if (index < 0 || index > size) {
+			throw new IndexOutOfBoundsException();
+		}
+	}
+
+	public void add(Object o) {
+		Node node = new Node(o, null);
+		if (head == null) {
+			head = tail = node;
+		}
+		Node oldTail = tail;
+		tail = node;
+		oldTail.next = tail;
+		size++;
+	}
+
+	public void add(int index, Object o) {
+		rangeCheck(index);
+		if (index == size) {
+			this.add(o);
+		} else {
+			// 保存index处节点
+			Node x = head;
+			// 保存index-1处的节点
+			Node y = null;
+			for (int i = 0; i < index; i++) {
+				y = x;
+				x = x.next;
+			}
+			Node node = new Node(o, x);
+			y.next = node;
+			size++;
+		}
+	}
+
+	public Object get(int index) {
+		rangeCheck(index);
+		Node x = head;
+		for (int i = 0; i < index; i++) {
+			x = x.next;
+		}
+		return x.data;
+	}
+
+	public Object remove(int index) {
+		rangeCheck(index);
+		Object removeData;
+		if (index == 0) {
+			removeData = removeFirst();
+		} else if (index == size - 1) {
+			removeData = removeLast();
+		} else {
+			Node x = head;
+			Node y = head;
+			for (int i = 0; i < index; i++) {
+				y = x;
+				x = x.next;
+			}
+			y.next = x.next;
+			size--;
+			removeData = x.data;
+		}
+		return removeData;
+	}
+
+	public int size() {
+		return this.size;
+	}
+
+	public void addFirst(Object o) {
+		Node oldHead = head;
+		head = new Node(o, oldHead);
+		size++;
+	}
+
+	public void addLast(Object o) {
+		Node oldTail = tail;
+		tail = new Node(o, null);
+		oldTail.next = tail;
+		size++;
+	}
+
+	public Object removeFirst() {
+		Node oldHead = head;
+		head = oldHead.next;
+		size--;
+		return oldHead.data;
+	}
+
+	public Object removeLast() {
+		Node oldTail = tail;
+		Node temp = head;
+		for (int i = 0; i < size - 2; i++) {
+			temp = temp.next;
+		}
+		tail = temp;
+		size--;
+		return oldTail.data;
+	}
+
+	public Iterator iterator() {
+		return new LinkedListIterator();
+	}
+
+	private static class Node {
+		Object data;
+		Node next;
+
+		Node(Object data, Node next) {
+			this.data = data;
+			this.next = next;
+		}
+
+	}
+
+	private class LinkedListIterator implements Iterator {
+		Node x = head;
+
+		@Override
+		public boolean hasNext() {
+			return x != null;
+		}
+
+		@Override
+		public Object next() {
+			Object data = x.data;
+			x = x.next;
+			return data;
+		}
+
+	}
+}
diff --git "a/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/List.java" "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/List.java"
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ "b/group08/529757467/2017-02-26\344\275\234\344\270\232/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/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/Queue.java" "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/Queue.java"
new file mode 100644
index 0000000000..5190e1b798
--- /dev/null
+++ "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/Queue.java"
@@ -0,0 +1,25 @@
+package com.coding.basic;
+
+public class Queue {
+	private LinkedList linkedList;
+
+	public Queue() {
+		linkedList = new LinkedList();
+	}
+
+	public void enQueue(Object o) {
+		linkedList.add(o);
+	}
+
+	public Object deQueue() {
+		return linkedList.removeFirst();
+	}
+
+	public boolean isEmpty() {
+		return linkedList.size() == 0;
+	}
+
+	public int size() {
+		return linkedList.size();
+	}
+}
diff --git "a/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/Stack.java" "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/Stack.java"
new file mode 100644
index 0000000000..a39871d1b4
--- /dev/null
+++ "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/Stack.java"
@@ -0,0 +1,30 @@
+package com.coding.basic;
+
+public class Stack {
+
+	private LinkedList linkedList;
+
+	public Stack() {
+		linkedList = new LinkedList();
+	}
+
+	public void push(Object o) {
+		linkedList.add(o);
+	}
+
+	public Object pop() {
+		return linkedList.removeLast();
+	}
+
+	public Object peek() {
+		return linkedList.get(linkedList.size()-1);
+	}
+
+	public boolean isEmpty() {
+		return linkedList.size() == 0;
+	}
+
+	public int size() {
+		return linkedList.size();
+	}
+}
diff --git "a/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/Test.java" "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/Test.java"
new file mode 100644
index 0000000000..b26a11be8a
--- /dev/null
+++ "b/group08/529757467/2017-02-26\344\275\234\344\270\232/com/coding/basic/Test.java"
@@ -0,0 +1,15 @@
+package com.coding.basic;
+
+public class Test {
+	public static void main(String[] args) {
+		LinkedList linkedList = new LinkedList();
+		for (int i = 0; i < 10; i++) {
+			linkedList.add(i);
+		}
+		for (int i = 0; i < 10; i++) {
+			linkedList.removeLast();
+		}
+		linkedList.removeLast();
+	}
+
+}
diff --git "a/group08/529757467/2017-02-26\344\275\234\344\270\232/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206.doc" "b/group08/529757467/2017-02-26\344\275\234\344\270\232/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206.doc"
new file mode 100644
index 0000000000..f518f0f97f
Binary files /dev/null and "b/group08/529757467/2017-02-26\344\275\234\344\270\232/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206.doc" differ
diff --git "a/group08/619057560/2-26/article/CPU\357\274\214\345\206\205\345\255\230\357\274\214\347\241\254\347\233\230\357\274\214\346\214\207\344\273\244\344\271\213\351\227\264\347\232\204\345\205\263\347\263\273.pdf" "b/group08/619057560/2-26/article/CPU\357\274\214\345\206\205\345\255\230\357\274\214\347\241\254\347\233\230\357\274\214\346\214\207\344\273\244\344\271\213\351\227\264\347\232\204\345\205\263\347\263\273.pdf"
new file mode 100644
index 0000000000..f310b09e2d
Binary files /dev/null and "b/group08/619057560/2-26/article/CPU\357\274\214\345\206\205\345\255\230\357\274\214\347\241\254\347\233\230\357\274\214\346\214\207\344\273\244\344\271\213\351\227\264\347\232\204\345\205\263\347\263\273.pdf" differ
diff --git a/group08/619057560/2-26/code/com/coding/basic/ArrayList.java b/group08/619057560/2-26/code/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..5fe3123515
--- /dev/null
+++ b/group08/619057560/2-26/code/com/coding/basic/ArrayList.java
@@ -0,0 +1,80 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[100];
+	
+	public void add(Object o){
+		if (size + 1 > elementData.length) {
+			elementData = Arrays.copyOf(elementData, elementData.length * 3 / 2 + 1);
+		}
+		elementData[size++] = o;
+	}
+	public void add(int index, Object o){
+		if (index < 0 || index > size) {
+			throw new IndexOutOfBoundsException();
+		}
+		
+		if (size + 1 > elementData.length) {
+			elementData = Arrays.copyOf(elementData, elementData.length * 3 / 2 + 1);
+		}
+		
+		System.arraycopy(elementData, index, elementData, index+1, size-index);
+		elementData[index] = o;
+		size++;
+	}
+	
+	public Object get(int index){
+		if (index < 0 || index >= size) {
+			throw new IndexOutOfBoundsException();
+		}
+		
+		return elementData[index];
+	}
+	
+	public Object remove(int index){
+		if (index < 0 || index >= size) {
+			throw new IndexOutOfBoundsException();
+		}
+		
+		Object old = elementData[index];
+		size--;
+		System.arraycopy(elementData, index+1, elementData, index, size-index);
+		elementData[size] = null;
+		
+		return old;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public Iterator iterator(){
+		return new Itr();
+	}
+	
+	private class Itr implements Iterator {
+		
+		int cursor = 0;
+
+		@Override
+		public boolean hasNext() {
+			return (cursor < size);
+		}
+
+		@Override
+		public Object next() {
+			if (cursor < 0 || cursor >= size) {
+				throw new NoSuchElementException();
+			}
+			return elementData[cursor++];
+		}
+		
+	}
+	
+}
diff --git a/group08/619057560/2-26/code/com/coding/basic/BinaryTreeNode.java b/group08/619057560/2-26/code/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..af940807e6
--- /dev/null
+++ b/group08/619057560/2-26/code/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,47 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	
+	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 (data == null || ((Integer)data).intValue() == ((Integer)o).intValue()) {
+			data = o;
+			return this;
+		}
+		else if (((Integer)o).intValue() < ((Integer)data).intValue()) {
+			if (left == null) {
+				left = new BinaryTreeNode();
+			}
+			return left.insert(o);
+		}
+		else {
+			if (right == null) {
+				right = new BinaryTreeNode();
+			}
+			return right.insert(o);
+		}
+	}
+	
+}
diff --git a/group08/619057560/2-26/code/com/coding/basic/Iterator.java b/group08/619057560/2-26/code/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..dbe8b9afb2
--- /dev/null
+++ b/group08/619057560/2-26/code/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/group08/619057560/2-26/code/com/coding/basic/LinkedList.java b/group08/619057560/2-26/code/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..d2f1422cfb
--- /dev/null
+++ b/group08/619057560/2-26/code/com/coding/basic/LinkedList.java
@@ -0,0 +1,137 @@
+package com.coding.basic;
+
+import java.util.NoSuchElementException;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	
+	public void add(Object o){
+		Node pNewNode = new Node();
+		pNewNode.data = o;
+		
+		Node pNode = head;
+		
+		if (head == null) {
+			head = pNewNode;
+			return;
+		}
+		
+		while (pNode.next != null) {
+			pNode = pNode.next;
+		}
+		
+		pNode.next = pNewNode;
+	}
+	
+	public void add(int index , Object o){
+		if (index < 0 && index > size()) {
+			throw new IndexOutOfBoundsException();
+		}
+		
+		Node pNewNode = new Node();
+		pNewNode.data = o;
+		
+		if (index == 0) {
+			pNewNode.next = head;
+			head = pNewNode;
+			return;
+		}
+		
+		Node pNode = head;
+		while (--index > 0) {
+			pNode = pNode.next;
+		}
+		pNewNode.next = pNode.next;
+		pNode.next = pNewNode;
+	}
+	
+	public Object get(int index){
+		if (index < 0 && index >= size()) {
+			throw new IndexOutOfBoundsException();
+		}
+		
+		Node pNode = head;
+		while (index-- > 0) {
+			pNode = pNode.next;
+		}
+		
+		return pNode.data;
+	}
+	
+	public Object remove(int index){
+		if (index < 0 && index >= size()) {
+			throw new IndexOutOfBoundsException();
+		}
+		
+		Node pNode = head;
+		if (index == 0) {
+			head = head.next;
+			return pNode.data;
+		}
+		
+		while (--index > 0) {
+			pNode = pNode.next;
+		}
+		Node pTargetNode = pNode.next;
+		pNode.next = pTargetNode.next;
+		
+		return pTargetNode.data;
+	}
+	
+	public int size(){
+		Node pNode = head;
+		int num = 0;
+		while (pNode != null) {
+			pNode = pNode.next;
+			num++;
+		}
+		return num;
+	}
+	
+	public void addFirst(Object o){
+		add(0, o);
+	}
+	
+	public void addLast(Object o){
+		add(o);
+	}
+	
+	public Object removeFirst(){
+		if (head == null) {
+			throw new NoSuchElementException();
+		}
+		return remove(0);
+	}
+	
+	public Object removeLast(){
+		if (head == null) {
+			throw new NoSuchElementException();
+		}
+		
+		Node pNode = head;
+		Node pPrevNode = null;
+		while (pNode.next != null) {
+			pPrevNode = pNode;
+			pNode = pNode.next;
+		}
+		if (pPrevNode != null) {
+			pPrevNode.next = pNode.next;
+		}
+		else {
+			head = null;
+		}
+		return pNode.data;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		
+	}
+}
diff --git a/group08/619057560/2-26/code/com/coding/basic/List.java b/group08/619057560/2-26/code/com/coding/basic/List.java
new file mode 100644
index 0000000000..396b1f6416
--- /dev/null
+++ b/group08/619057560/2-26/code/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/group08/619057560/2-26/code/com/coding/basic/Queue.java b/group08/619057560/2-26/code/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..67a080f408
--- /dev/null
+++ b/group08/619057560/2-26/code/com/coding/basic/Queue.java
@@ -0,0 +1,22 @@
+package com.coding.basic;
+
+public class Queue {
+	
+	private LinkedList queueList = new LinkedList();
+	
+	public void enQueue(Object o){		
+		queueList.addFirst(o);
+	}
+	
+	public Object deQueue(){
+		return queueList.removeLast();
+	}
+	
+	public boolean isEmpty(){
+		return queueList.size() == 0;
+	}
+	
+	public int size(){
+		return queueList.size();
+	}
+}
diff --git a/group08/619057560/2-26/code/com/coding/basic/Stack.java b/group08/619057560/2-26/code/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..481c88bed7
--- /dev/null
+++ b/group08/619057560/2-26/code/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/group08/619057560/2-26/code/com/coding/test/Main.java b/group08/619057560/2-26/code/com/coding/test/Main.java
new file mode 100644
index 0000000000..c4b5b4b74d
--- /dev/null
+++ b/group08/619057560/2-26/code/com/coding/test/Main.java
@@ -0,0 +1,103 @@
+package com.coding.test;
+
+import com.coding.basic.ArrayList;
+import com.coding.basic.BinaryTreeNode;
+import com.coding.basic.Iterator;
+import com.coding.basic.LinkedList;
+import com.coding.basic.Queue;
+import com.coding.basic.Stack;
+
+public class Main {
+	
+	private static void printArrayList(ArrayList list) {
+		for (int i = 0; i < list.size(); i++) {
+			System.out.println(list.get(i));
+		}
+		Iterator itr = list.iterator();
+		while (itr.hasNext()) {
+			System.out.println(itr.next());
+		}
+	}
+	
+	private static void printLinkedList(LinkedList list) {
+		for (int i = 0; i < list.size(); i++) {
+			System.out.println(list.get(i));
+		}
+	}
+	
+	private static void printBinaryTree(BinaryTreeNode node) {
+		if (node == null)
+			return;
+		
+		printBinaryTree(node.getLeft());
+		if (node.getData() != null)
+			System.out.println(node.getData());
+		printBinaryTree(node.getRight());
+	}
+	
+	private static void testArrayList() {
+		ArrayList arrayList = new ArrayList();
+		arrayList.add(new Integer(1));
+		arrayList.add(new Integer(2));
+		arrayList.add(new Integer(3));
+		arrayList.remove(2);
+		arrayList.add(new Integer(4));
+		arrayList.add(0,new Integer(5));
+		printArrayList(arrayList);
+	}
+	
+	private static void testLinkedList() {
+		LinkedList linkedList = new LinkedList();
+		linkedList.add(new Integer(1));
+		linkedList.add(new Integer(2));
+		linkedList.add(new Integer(3));
+		linkedList.remove(2);
+		linkedList.add(new Integer(4));
+		linkedList.add(0,new Integer(5));
+		linkedList.removeFirst();
+		printLinkedList(linkedList);
+	}
+	
+	private static void testStack() {
+		Stack stack = new Stack();
+		stack.push(new Integer(1));
+		stack.push(new Integer(2));
+		stack.push(new Integer(3));
+		System.out.println(stack.peek());
+		System.out.println(stack.peek());
+		System.out.println(stack.pop());
+		System.out.println(stack.pop());
+		stack.push(new Integer(4));
+		System.out.println(stack.pop());
+		System.out.println(stack.pop());
+		//System.out.println(stack.pop());
+	}
+	
+	private static void testQueue() {
+		Queue queue = new Queue();
+		queue.enQueue(new Integer(1));
+		queue.enQueue(new Integer(2));
+		queue.enQueue(new Integer(3));
+		System.out.println(queue.deQueue());
+		System.out.println(queue.deQueue());
+		System.out.println(queue.deQueue());
+		//System.out.println(queue.deQueue());
+	}
+	
+	private static void testBinaryTree() {
+		BinaryTreeNode root = new BinaryTreeNode();
+		root.insert(new Integer(4));
+		root.insert(new Integer(3));
+		root.insert(new Integer(5));
+		root.insert(new Integer(1));
+		root.insert(new Integer(8));
+		root.insert(new Integer(2));
+		root.insert(new Integer(7));
+		root.insert(new Integer(6));
+		printBinaryTree(root);
+	}
+	
+	public static void main(String[] args) {
+		testBinaryTree();
+	}
+}
diff --git a/group08/619057560/CHHSAlex.md b/group08/619057560/CHHSAlex.md
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/group08/619057560/CHHSAlex.md
@@ -0,0 +1 @@
+
diff --git a/group08/648354678/README.md b/group08/648354678/README.md
new file mode 100644
index 0000000000..20b57abd22
--- /dev/null
+++ b/group08/648354678/README.md
@@ -0,0 +1,4 @@
+# 测试上传文件到git
+## 第一次上传以作学习
+## QQ：648354678
+### 希望跟大家共同学习进步
\ No newline at end of file
diff --git a/group08/649859235/2-26/article.md b/group08/649859235/2-26/article.md
new file mode 100644
index 0000000000..556350e58d
--- /dev/null
+++ b/group08/649859235/2-26/article.md
@@ -0,0 +1,2 @@
+文章地址
+http://note.youdao.com/noteshare?id=a0345eff655b1cfc5877cc267452eed0&sub=FE5CD301B3C742269D04973B0DD2393C
diff --git a/group08/649859235/2-26/com/vvv/base/ArrayList.java b/group08/649859235/2-26/com/vvv/base/ArrayList.java
new file mode 100644
index 0000000000..e250afe294
--- /dev/null
+++ b/group08/649859235/2-26/com/vvv/base/ArrayList.java
@@ -0,0 +1,68 @@
+package com.vvv.base;
+
+public class ArrayList implements IList {
+
+	private static final int DEFAULT_SIZE = 100;
+
+	private int size;
+	private Object[] data = new Object[DEFAULT_SIZE];
+
+	@Override
+	public void add(Object o) {
+		if (size > data.length) {
+			increase();
+		}
+		data[size] = o;
+		size++;
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		check(index);
+
+		if (index > data.length - 1) {
+			increase();
+		}
+		System.arraycopy(data, index, data, index + 1, size - index);
+		data[index] = o;
+		size++;
+	}
+
+	private void check(int index) {
+		if (index < 0 || index > size)
+			throw new IndexOutOfBoundsException("index: " + index + ", size: "
+					+ size);
+	}
+
+	private void increase() {
+		Object[] newData = new Object[DEFAULT_SIZE * 2];
+		System.arraycopy(data, 0, newData, 0, size);
+		data = newData;
+	}
+
+	@Override
+	public Object get(int index) {
+		check(index);
+		return data[index];
+	}
+
+	@Override
+	public Object remove(int index) {
+		if (index > 0 && index < size) {
+			Object d = data[index];
+			int diff = size - index - 1;
+			if (diff > 0)
+				System.arraycopy(data, index + 1, data, index, size - index - 1);
+			size--;
+			data[size] = null;
+			return d;
+		}
+		return null;
+	}
+
+	@Override
+	public int size() {
+		return this.size;
+	}
+
+}
diff --git a/group08/649859235/2-26/com/vvv/base/BinaryTreeNode.java b/group08/649859235/2-26/com/vvv/base/BinaryTreeNode.java
new file mode 100644
index 0000000000..a5d5ee1d2a
--- /dev/null
+++ b/group08/649859235/2-26/com/vvv/base/BinaryTreeNode.java
@@ -0,0 +1,37 @@
+package com.vvv.base;
+
+public class BinaryTreeNode {
+
+	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) {
+		return null;
+	}
+
+}
diff --git a/group08/649859235/2-26/com/vvv/base/IList.java b/group08/649859235/2-26/com/vvv/base/IList.java
new file mode 100644
index 0000000000..3b449fab3f
--- /dev/null
+++ b/group08/649859235/2-26/com/vvv/base/IList.java
@@ -0,0 +1,9 @@
+package com.vvv.base;
+
+public interface IList {
+	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/group08/649859235/2-26/com/vvv/base/LinkedList.java b/group08/649859235/2-26/com/vvv/base/LinkedList.java
new file mode 100644
index 0000000000..fa03aba962
--- /dev/null
+++ b/group08/649859235/2-26/com/vvv/base/LinkedList.java
@@ -0,0 +1,117 @@
+package com.vvv.base;
+
+public class LinkedList implements IList {
+	private int size;
+	private Node<Object> head;
+	private Node<Object> tail;
+
+	@Override
+	public void add(Object o) {
+		Node<Object> node = new Node<Object>(o);
+		if (head == null) {
+			head = node;
+			tail = node;
+		} else {
+			tail.next = node;
+			node.prev = tail;
+			tail = node;
+		}
+		size++;
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		check(index);
+		Node<Object> node = new Node<Object>(o);
+		Node<Object> temp = head;
+		for (int i = 0; i < index; i++) {
+			temp = temp.next;
+		}
+		if (temp.prev != null && temp.next != null) {
+			Node<Object> prevNode = temp.prev;
+			prevNode.next = node;
+			node.prev = prevNode;
+			node.next = temp;
+			temp.prev = node;
+		} else if (temp.prev == null) {
+			head = node;
+			temp.prev = node;
+			node.next = temp;
+		} else if (temp.next == null) {
+			temp.next = node;
+			node.prev = temp;
+			tail = node;
+		}
+		size++;
+	}
+
+	@Override
+	public Object get(int index) {
+		check(index);
+		Node<Object> temp = head;
+		for (int i = 0; i < index; i++) {
+			temp = temp.next;
+		}
+		return temp.data;
+	}
+
+	@Override
+	public Object remove(int index) {
+		check(index);
+		Node<Object> temp = head;
+		for (int i = 0; i < index; i++) {
+			temp = temp.next;
+		}
+		Object oldValue = temp.data;
+		if (temp.prev != null && temp.next != null) {
+			temp.prev.next = temp.next;
+			temp.next.prev = temp.prev;
+			temp = null;
+		} else if (temp.prev == null) {
+			head = temp.next;
+			temp.next.prev = null;
+			temp = null;
+		} else if (temp.next == null) {
+			tail = temp.prev;
+			temp.prev.next = null;
+			temp = null;
+		}
+		size--;
+		return oldValue;
+	}
+
+	public boolean remove(Object obj) {
+		Node<Object> temp = head;
+		for (int i = 0; i < size; i++) {
+			if (obj.equals(temp.data)) {
+				remove(i);
+				return true;
+			}
+			temp = temp.next;
+		}
+		return false;
+	}
+
+	private void check(int index) {
+		if (index < 0 || index > size)
+			throw new IndexOutOfBoundsException("index: " + index + ", size: "
+					+ size);
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+
+	@SuppressWarnings("hiding")
+	private static class Node<Object> {
+		Object data;
+		Node<Object> next;
+		Node<Object> prev;
+
+		public Node(Object data) {
+			this.data = data;
+		}
+	}
+
+}
diff --git a/group08/649859235/2-26/com/vvv/base/Queue.java b/group08/649859235/2-26/com/vvv/base/Queue.java
new file mode 100644
index 0000000000..f97bd9d298
--- /dev/null
+++ b/group08/649859235/2-26/com/vvv/base/Queue.java
@@ -0,0 +1,73 @@
+package com.vvv.base;
+
+public class Queue {
+
+    QueueNode head; 
+    QueueNode tail;  
+    private int size;
+    
+    public Queue() {  
+        this.head = null;  
+        this.tail = null;  
+    }   
+    
+	public void enQueue(Object o) {
+        if (head == null && tail == null) {  
+        	tail = new QueueNode(o);  
+            head = tail;  
+        } else {  
+            QueueNode node = new QueueNode(o);  
+            tail.next = node;  
+            tail = tail.next;  
+        }  
+        size++;
+	}
+
+	public Object deQueue() {
+		if (head == null) {  
+            return null;  
+        }  
+		
+        if (head == tail && tail != null) {  
+            QueueNode node = head;  
+            tail = null;  
+            head = null;  
+            size--;
+            return node.data;  
+        }  
+        
+        Object obj = head.data;  
+        head = head.next;
+        size--;
+        return obj;  
+	}
+
+	public boolean isEmpty() {
+		if(head==null && tail == null)
+			return true;
+		return false;
+	}
+
+	public int size() {
+		return size;
+	}
+	
+}
+
+class QueueNode {  
+    Object data;  
+    QueueNode next; 
+ 
+    public QueueNode() {  
+        this(null, null);  
+    }  
+ 
+    public QueueNode(Object data) {  
+        this(data, null);  
+    }  
+ 
+    public QueueNode(Object data, QueueNode next) {  
+        this.data = data;  
+        this.next = next;  
+    }  
+}  
diff --git a/group08/649859235/2-26/com/vvv/base/Stack.java b/group08/649859235/2-26/com/vvv/base/Stack.java
new file mode 100644
index 0000000000..5e3ed32e14
--- /dev/null
+++ b/group08/649859235/2-26/com/vvv/base/Stack.java
@@ -0,0 +1,30 @@
+package com.vvv.base;
+
+public class Stack {
+	private ArrayList data = new ArrayList();
+
+	public void push(Object o) {
+		data.add(o);
+	}
+
+	public Object pop() {
+		return data.remove(data.size() - 1);
+	}
+
+	public Object peek() {
+		if (data.size() > 0) {
+			return data.get(data.size() - 1);
+		}
+		return null;
+	}
+
+	public boolean isEmpty() {
+		if (data.size() > 0)
+			return false;
+		return true;
+	}
+
+	public int size() {
+		return data.size();
+	}
+}
diff --git a/group08/649859235/README.md b/group08/649859235/README.md
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/group08/649859235/README.md
@@ -0,0 +1 @@
+
diff --git a/group08/729770920/.gitignore b/group08/729770920/.gitignore
new file mode 100644
index 0000000000..6b468b62a9
--- /dev/null
+++ b/group08/729770920/.gitignore
@@ -0,0 +1 @@
+*.class
diff --git a/group08/729770920/2-26/resource/report.txt b/group08/729770920/2-26/resource/report.txt
new file mode 100644
index 0000000000..f256165498
--- /dev/null
+++ b/group08/729770920/2-26/resource/report.txt
@@ -0,0 +1,5 @@
+CPU是计算机的大脑，由运算器和寄存器组成。可以储存指令和数据，并执行指令进行简单的计算。
+指令是CPU可以直接执行的命令。
+内存是所谓的RAM，读写速度较快。常用来作为CPU和硬盘之间数据交换的缓存。
+硬盘容量极大，但是读写速度比内存慢很多。用来存放程序的二进制码，音频，视频等等数据资源。
+程序运行时，数据由硬盘拷贝到内存，CPU再从内存里加载包含指令的数据，逐一执行。
\ No newline at end of file
diff --git a/group08/729770920/2-26/src/com/coding/basic/ArrayList.java b/group08/729770920/2-26/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..8fe149f4ad
--- /dev/null
+++ b/group08/729770920/2-26/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,111 @@
+package com.coding.basic;
+
+public class ArrayList<E> implements List<E> {
+	
+	private int size;
+	
+	private E[] data;
+	
+	public void add(E e){
+	    add(size, e);	
+	}
+
+    public ArrayList() {
+        clear();
+    }
+
+    public ArrayList(int capacity) {
+        clear();
+        ensureCapacity(capacity);
+    }
+
+	public void add(int index, E e){
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException(Integer.toString(index));
+        }
+		if (data.length == size) {
+            ensureCapacity(size * 2 + 1);
+        }
+        for (int i = size++; i > index; --i) {
+            data[i] = data[i - 1];
+        }
+        data[index] = e;
+	}
+	
+	public E get(int index){
+		return data[index];
+	}
+	
+	public E remove(int index){
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException(Integer.toString(index));
+        }
+        E copy = data[index];
+        --size;
+        for (int i = index; i < size; ++i) {
+            data[i] = data[i + 1];
+        }
+        return copy;
+	}
+
+    public boolean contains(E e) {
+        for (int i = 0; i < size; ++i) {
+            if (data[i] == e) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void clear() {
+        size = 0;
+        data = (E[]) new Object[0];
+    }
+	
+	public int size(){
+		return size;
+	}
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+	
+	public Iterator<E> iterator(){
+		return new ArrayListIterator();
+	}
+
+    public void ensureCapacity(int capacity) {
+        E[] newData = (E[]) new Object[capacity];
+        for (int i = 0; i < size; ++i) {
+            newData[i] = data[i];
+        }
+        data = newData;
+    }
+
+    public void trimToSize() {
+        E[] newData = (E[]) new Object[size];
+        for (int i = 0; i < size; ++i) {
+            newData[i] = data[i];
+        }
+        data = newData;
+    }
+
+    private class ArrayListIterator implements Iterator<E> {
+        int current = 0;
+
+        public boolean hasNext() {
+            return current < size;
+        }
+
+        public E next() {
+            if (!hasNext()) {
+                throw new java.util.NoSuchElementException();
+            }
+            return data[current++];
+        }
+
+        public void remove() {
+            ArrayList.this.remove(current);
+        }
+    }
+}
diff --git a/group08/729770920/2-26/src/com/coding/basic/Iterator.java b/group08/729770920/2-26/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..f0e2eddde8
--- /dev/null
+++ b/group08/729770920/2-26/src/com/coding/basic/Iterator.java
@@ -0,0 +1,9 @@
+package com.coding.basic;
+
+public interface Iterator<E> {
+	boolean hasNext();
+
+	E next();
+
+    void remove();
+}
diff --git a/group08/729770920/2-26/src/com/coding/basic/LinkedList.java b/group08/729770920/2-26/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..899e0be08e
--- /dev/null
+++ b/group08/729770920/2-26/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,164 @@
+package com.coding.basic;
+
+public class LinkedList<E> implements List<E> {
+    private int size = 0;
+	private Node<E> head = new Node<>();
+    private Node<E> tail = new Node<>();
+	
+    public LinkedList() {
+        head.next = tail;
+        tail.prev = head;
+    }
+
+	public void add(E e) {
+        addLast(e);
+	}
+
+	public void add(int index, E e) {
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException(Integer.toString(index));
+        }
+        Node<E> cursor;
+        if (index < size/2) {
+            cursor = head;
+            for (int i = 0, num = index; i < num; ++i) {
+                cursor = cursor.next;
+            }
+        } else {
+            cursor = tail.prev;
+            for (int i = 0, num = size-index; i < num; ++i) {
+                cursor = cursor.prev;
+            }
+        }
+        cursor.next = cursor.next.prev = new Node<E>(e, cursor, cursor.next);
+        ++size;
+	}
+
+	public E get(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException(Integer.toString(index));
+        }
+        Node<E> cursor;
+        if (index < size/2) {
+            cursor = head.next;
+            for (int i = 0; i < index; ++i) {
+                cursor = cursor.next;
+            }
+        } else {
+            cursor = tail.prev;
+            for (int i = 0, num = size-index-1; i < num; ++i) {
+                cursor = cursor.prev;
+            }
+        }
+        return cursor.data;
+	}
+
+	public E remove(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException(Integer.toString(index));
+        }
+        Node<E> cursor;
+        if (index < size/2) {
+            cursor = head.next;
+            for (int i = 0; i < index; ++i) {
+                cursor = cursor.next;
+            }
+        } else {
+            cursor = tail.prev;
+            for (int i = 0, num = size-index-1; i < num; ++i) {
+                cursor = cursor.prev;
+            }
+        }
+        cursor.prev.next = cursor.next;
+        cursor.next.prev = cursor.prev;
+        --size;
+        return cursor.data;
+	}
+	
+	public int size() {
+		return size;
+	}
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+	
+	public void addFirst(E e) {
+        add(0, e);
+	}
+
+	public void addLast(E e) {
+        add(size, e);
+	}
+
+	public E removeFirst() {
+        return remove(0);
+	}
+
+	public E removeLast() {
+        return remove(size-1);
+	}
+
+    public void clear() {
+        while (!isEmpty()) {
+            removeFirst();
+        }
+    }
+
+    public boolean contains(E e) {
+        Iterator it = this.iterator();
+        while (it.hasNext()) {
+            if (it.next() == e) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+	public Iterator iterator() {
+		return new LinkedListIterator();
+	}
+	
+	private static class Node<E> {
+		E data = null;
+        Node<E> prev = null;
+		Node<E> next = null;
+
+        public Node() {
+        }
+
+        public Node(E e, Node p, Node n) {
+            data = e;
+            prev = p;
+            next = n;
+        }
+	}
+
+    private class LinkedListIterator implements Iterator<E> {
+        Node<E> currentNode = head.next;
+
+        public boolean hasNext() {
+            return currentNode != tail;
+        }
+
+        public E next() {
+            if (!hasNext()) {
+                throw new java.util.NoSuchElementException();
+            }
+            E data = currentNode.data;
+            currentNode = currentNode.next;
+            return data;
+        }
+
+        public void remove() {
+            if (!hasNext()) {
+                throw new java.util.NoSuchElementException();
+            }
+            Node<E> nextNode = currentNode.next;
+            currentNode.next.prev = currentNode.prev;
+            currentNode.prev.next = currentNode.next;
+            currentNode = nextNode;
+            --size;
+        }
+    }
+}
diff --git a/group08/729770920/2-26/src/com/coding/basic/List.java b/group08/729770920/2-26/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..babed5a71f
--- /dev/null
+++ b/group08/729770920/2-26/src/com/coding/basic/List.java
@@ -0,0 +1,19 @@
+package com.coding.basic;
+
+public interface List<E> {
+	void add(E e);
+
+	void add(int index, E e);
+
+    void clear();
+
+	E get(int index);
+
+	E remove(int index);
+
+	int size();
+
+    boolean contains(E e);
+
+    Iterator<E> iterator();
+}
diff --git a/group08/729770920/2-26/src/com/coding/basic/Queue.java b/group08/729770920/2-26/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..a660ad6729
--- /dev/null
+++ b/group08/729770920/2-26/src/com/coding/basic/Queue.java
@@ -0,0 +1,21 @@
+package com.coding.basic;
+
+public class Queue<E> {
+    private LinkedList<E> data = new LinkedList<>();
+    
+    public void enQueue(E e){
+        data.addFirst(e);
+    }
+    
+    public Object deQueue() {
+        return data.removeLast();
+    }
+    
+    public boolean isEmpty() {
+        return data.size() == 0;
+    }
+
+    public int size(){
+        return data.size();
+    }
+}
diff --git a/group08/729770920/2-26/src/com/coding/basic/Stack.java b/group08/729770920/2-26/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..c7e7773de5
--- /dev/null
+++ b/group08/729770920/2-26/src/com/coding/basic/Stack.java
@@ -0,0 +1,25 @@
+package com.coding.basic;
+
+public class Stack<E> {
+    private LinkedList<E> data = new LinkedList<>();
+
+    public void push(E e) {        
+        data.addFirst(e);
+    }
+    
+    public Object pop() {
+        return data.removeFirst();
+    }
+    
+    public Object peek() {
+        return data.get(0);
+    }
+
+    public boolean isEmpty() {
+        return data.size() == 0;
+    }
+
+    public int size() {
+        return data.size();
+    }
+}
diff --git a/group08/729770920/README.md b/group08/729770920/README.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/group08/769638826/769638826.md b/group08/769638826/769638826.md
new file mode 100644
index 0000000000..4573496090
--- /dev/null
+++ b/group08/769638826/769638826.md
@@ -0,0 +1,2 @@
+###自我介绍
+
diff --git a/group08/782476895/20170225/ArrayList.java b/group08/782476895/20170225/ArrayList.java
new file mode 100644
index 0000000000..7b94eebd36
--- /dev/null
+++ b/group08/782476895/20170225/ArrayList.java
@@ -0,0 +1,55 @@
+package com.sl.test20170221;
+
+import java.util.Arrays;
+
+public class ArrayList implements List{
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[100];
+	
+	@Override
+	public void add(Object o) {	
+		grow(elementData);
+		elementData[size] = o;
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		grow(elementData);
+		for(int i = size - 1;i >= index;i--){
+			elementData[i+1] = elementData[i];
+		}
+		elementData[index] = o;
+	}
+
+	@Override
+	public Object get(int index) {
+		return elementData[index];
+	}
+
+	@Override
+	public Object remove(int index) {
+		size--;
+		for(int i = index;i < size;i++){
+			elementData[i] = elementData[i+1];
+		}
+		elementData[size] = null;
+		return elementData;
+	}
+
+	@Override
+	public int size() {
+		
+		return size;
+	}
+	
+	private void grow(Object[] elementData){
+		size++;
+		if(size >= elementData.length){
+			int newSize = elementData.length + 100;
+			elementData = Arrays.copyOf(elementData, newSize);
+		}
+	}
+
+}
diff --git a/group08/782476895/20170225/LinkedList.java b/group08/782476895/20170225/LinkedList.java
new file mode 100644
index 0000000000..30ba21046f
--- /dev/null
+++ b/group08/782476895/20170225/LinkedList.java
@@ -0,0 +1,127 @@
+package com.sl.test20170221;
+
+public class LinkedList implements List{
+	private Node root;
+	int index;
+	
+	public void addNode(String name){
+		if(root == null){
+			root = new Node(name);
+		}else{
+			root.add(name);
+		}
+	}
+	
+	
+	
+	
+	class Node{
+		Object data;
+		Node next;
+		
+		
+		Node(Object data){
+			this.data = data;
+		}
+		//添加节点
+		public void add(Object data){
+			if(this.next == null){
+				this.next = new Node(data);
+			}else{
+				this.next.add(data);
+			}
+		}
+		//删除节点
+		public Object del(int i){
+			if(this.next != null){
+				index++;
+				if(i == index){
+					this.next = this.next.next;
+					return this.next.data;
+				}else{
+					this.next.del(i);
+				}
+			}
+			return null;
+		}
+	
+		
+		//遍历
+		public void traversal(){
+			if(this.next != null){
+				index++;
+				this.next.traversal();
+			}
+		}
+		//指定位置增加
+		public void add(int i, Object o){
+			if(this.next != null){
+				if(i == index){
+					Node node = new Node(data);
+					node.next = this.next.next;
+					this.next = node;
+					return ;
+				}else{
+					this.next.add(i,o);
+				}
+				index++;
+			}
+		}
+		
+		//得到指定的节点
+		public Object get(int i){
+			if(this.next != null){
+				
+				if(i == index){
+					return this.data;
+				}else{
+					this.next.get(i);
+				}
+				index++;
+			}
+			return null;
+		}
+		
+	}
+	
+	@Override
+	public void add(Object data) {
+		if(root == null){
+			root = new Node(data);
+		}else{
+			root.add(data);
+		}
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		if(root != null){
+			root.add(index, o);
+		}
+	}
+
+	@Override
+	public Object get(int index) {
+		if(root.next != null){
+			return root.get(index);
+		}
+		return null;
+	}
+
+	@Override
+	public Object remove(int index) {
+		if(root != null){
+			return root.del(index);
+		}
+		return null;
+	}
+
+	@Override
+	public int size() {
+		if(root != null){
+			root.traversal();
+		}
+		return index;
+	}
+	
+}
diff --git a/group08/782476895/20170225/List.java b/group08/782476895/20170225/List.java
new file mode 100644
index 0000000000..08160598b8
--- /dev/null
+++ b/group08/782476895/20170225/List.java
@@ -0,0 +1,9 @@
+package com.sl.test20170221;
+
+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/group08/782476895/20170225/Queue.java b/group08/782476895/20170225/Queue.java
new file mode 100644
index 0000000000..3c4a3c8256
--- /dev/null
+++ b/group08/782476895/20170225/Queue.java
@@ -0,0 +1,65 @@
+package com.sl.test20170221;
+
+import com.sl.test20170221.LinkedList.Node;
+
+public class Queue {
+	
+	private Node first;
+	private int index;
+	
+	class Node{
+		Object data;
+		Node next;
+		
+		
+		Node(Object data){
+			this.data = data;
+		}
+		//添加节点
+		public void add(Object data){
+			if(this.next == null){
+				this.next = new Node(data);
+			}else{
+				this.next.add(data);
+			}
+		}
+		
+		//遍历
+		public void traversal(){
+			if(this.next != null){
+				index++;
+				this.next.traversal();
+			}
+		}
+	}
+	
+	public void enQueue(Object o){		
+		if(first != null){
+			first.add(o);
+		}
+	}
+	
+	public Object deQueue(){
+		if(first != null){
+			Object obj = first.data;
+			first = first.next;
+			return obj;
+		}
+		return null;
+	}
+	
+	public boolean isEmpty(){
+		if(first == null){
+			return true;
+		}else{
+			return false;
+		}
+	}
+	
+	public int size(){
+		if(first != null){
+			first.traversal();
+		}
+		return index;
+	}
+}
diff --git a/group08/782476895/20170225/Stack.java b/group08/782476895/20170225/Stack.java
new file mode 100644
index 0000000000..50739dc7f3
--- /dev/null
+++ b/group08/782476895/20170225/Stack.java
@@ -0,0 +1,31 @@
+package com.sl.test20170221;
+
+public class Stack {
+	private List elementData = new ArrayList();
+	
+	public void push(Object o){
+		elementData.add(o);
+	}
+	
+	public Object pop(){
+		int size = elementData.size();
+		Object obj = elementData.remove(size--);
+		return obj;
+	}
+	
+	public Object peek(){
+		int size = elementData.size();
+		return elementData.get(size - 1);
+	}
+	public boolean isEmpty(){
+		int size = elementData.size();
+		if(size == 0){
+			return true;
+		}else{
+			return false;
+		}
+	}
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git "a/group08/782476895/20170225/\346\217\217\350\277\260CPU\357\274\214\345\206\205\345\255\230\357\274\214 \347\241\254\347\233\230\357\274\214\346\214\207\344\273\244\344\271\213\351\227\264\347\232\204\345\205\263\347\263\273.docx" "b/group08/782476895/20170225/\346\217\217\350\277\260CPU\357\274\214\345\206\205\345\255\230\357\274\214 \347\241\254\347\233\230\357\274\214\346\214\207\344\273\244\344\271\213\351\227\264\347\232\204\345\205\263\347\263\273.docx"
new file mode 100644
index 0000000000..0449ce2f36
Binary files /dev/null and "b/group08/782476895/20170225/\346\217\217\350\277\260CPU\357\274\214\345\206\205\345\255\230\357\274\214 \347\241\254\347\233\230\357\274\214\346\214\207\344\273\244\344\271\213\351\227\264\347\232\204\345\205\263\347\263\273.docx" differ
diff --git a/group08/875325254/2-26/ArrayList.java b/group08/875325254/2-26/ArrayList.java
new file mode 100644
index 0000000000..d90caa7d50
--- /dev/null
+++ b/group08/875325254/2-26/ArrayList.java
@@ -0,0 +1,37 @@
+import java.util.Arrays;
+
+/**
+ * Created by Great on 2017/2/25.
+ */
+public class ArrayList {
+    private final int DEFAULT_SIZE = 20;
+    int[] array = new int[DEFAULT_SIZE];
+    int size = 0;
+    public void add(int e) {
+        if (size == array.length) {
+            array = Arrays.copyOf(array, array.length + DEFAULT_SIZE);
+        }
+        array[size] = e;
+        ++size;
+    }
+
+    public Integer get(int i) {
+        if(i < 0 || i >= size) return null;
+        return array[i];
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public void remove(int i) {
+        if (i < 0 || i >= size) return;
+        for (int j = i; j < size; j++) {
+            array[j] = array[j + 1];
+        }
+        --size;
+    }
+    public boolean isEmpty() {
+        return size == 0;
+    }
+}
diff --git a/group08/875325254/2-26/LinkList.java b/group08/875325254/2-26/LinkList.java
new file mode 100644
index 0000000000..a6b785ee79
--- /dev/null
+++ b/group08/875325254/2-26/LinkList.java
@@ -0,0 +1,73 @@
+/**
+ * Created by Great on 2017/2/24.
+ */
+public class LinkList {
+    private class Node{
+        Node next;
+        int data;
+    }
+    private Node rear;
+    private Node top;
+    private int size = 0;
+    public void add(int e) {
+        if (rear == null) {
+            rear = new Node();
+            top = rear;
+        }else {
+            rear.next = new Node();
+            rear = rear.next;
+        }
+        rear.data = e;
+        ++size;
+    }
+
+    public Integer getReciprocal(int count) {
+        if (top == null || count < 1) return null;
+        Node node = top;
+        int size = 0;
+        while( node.next != null) {
+            node = node.next;
+            size++;
+        }
+        if (size+1 < count) return null;
+        return get(size+1-count);
+    }
+
+    public Integer get(int i) {
+        if (i < 0 || i >= size) return null;
+        return getNode(i).data;
+    }
+
+    public void remove(int i) {
+        if (i < 0 || i >= size) return;
+        if (i == 0 ) {
+            top = top.next;
+            return;
+        }
+        if (i == size - 1) {
+            getNode(i - 1).next = null;
+        }
+        Node front = getNode(i - 1);
+        Node back = getNode(i + 1);
+        front.next = back;
+        --size;
+    }
+
+    private Node getNode(int i) {
+        if (i < 0 || i >= size) return null;
+        Node node = top;
+        for (int j = 0; j < size; j++) {
+            if (j == i) return node;
+            node = node.next;
+        }
+        return null;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+}
diff --git a/group08/875325254/2-26/Queue.java b/group08/875325254/2-26/Queue.java
new file mode 100644
index 0000000000..6e3b80d7d2
--- /dev/null
+++ b/group08/875325254/2-26/Queue.java
@@ -0,0 +1,41 @@
+import java.util.Arrays;
+
+/**
+ * Created by Great on 2017/2/23.
+ */
+public class Queue {
+    private class Node{
+        Node next;
+        int data;
+    }
+    private int size;
+    private Node front;
+    private Node rear;
+    public void add(int e) {
+        if (front == null) {
+            front = new Node();
+            rear = front;
+        }else {
+            front.next = new Node();
+            front = front.next;
+        }
+        front.data = e;
+        ++size;
+    }
+
+    public Integer poll() {
+        if (rear == null) return null;
+        int data = rear.data;
+        rear = rear.next;
+        --size;
+        return data;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public int size() {
+        return size;
+    }
+}
diff --git a/group08/875325254/2-26/Stack.java b/group08/875325254/2-26/Stack.java
new file mode 100644
index 0000000000..78b9884ccb
--- /dev/null
+++ b/group08/875325254/2-26/Stack.java
@@ -0,0 +1,29 @@
+import java.util.Arrays;
+
+/**
+ * Created by Great on 2017/2/23.
+ */
+public class Stack {
+    private final int DEFAULT_SIZE = 20;
+    private int base;
+    private int top;
+    private int[] array = new int[DEFAULT_SIZE];
+    public void push(Integer e) {
+        if (top == array.length){
+            array = Arrays.copyOf(array, array.length + DEFAULT_SIZE);
+        }
+        array[top] = e;
+        ++top;
+    }
+    public Integer pop(){
+        if (top == 0) return null;
+        top--;
+        return array[top];
+    }
+    public int size() {
+        return top;
+    }
+    public boolean isEmpty(){
+        return top == 0;
+    }
+}
diff --git a/group08/875325254/2-26/Test.java b/group08/875325254/2-26/Test.java
new file mode 100644
index 0000000000..b397fd3e16
--- /dev/null
+++ b/group08/875325254/2-26/Test.java
@@ -0,0 +1,35 @@
+import java.util.List;
+
+/**
+ * Created by Great on 2017/2/23.
+ */
+public class Test {
+    public static void main(String[] args) {
+        ArrayList arrayList = new ArrayList();
+        LinkList linkList = new LinkList();
+        Queue queue = new Queue();
+        Stack stack = new Stack();
+        for (int i = 0; i < 10; i++) {
+            arrayList.add(i);
+            linkList.add(i);
+            queue.add(i);
+            stack.push(i);
+        }
+        System.out.println("ArrayList:");
+        for (int i = 0; i < arrayList.size(); i++) {
+            System.out.println(arrayList.get(i));
+        }
+        System.out.println("LinkList:");
+        for (int i = 0; i < linkList.size(); i++) {
+            System.out.println(linkList.get(i));
+        }
+        System.out.println("Queue:");
+        while (!queue.isEmpty()) {
+            System.out.println(queue.poll());
+        }
+        System.out.println("Stack:");
+        while (!stack.isEmpty()) {
+            System.out.println(stack.pop());
+        }
+    }
+}
diff --git a/group08/875325254/875325254.md b/group08/875325254/875325254.md
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/group08/875325254/875325254.md
@@ -0,0 +1 @@
+
diff --git a/group12/2258659044/readme.txt b/group12/2258659044/readme.txt
new file mode 100644
index 0000000000..59c627dd7e
--- /dev/null
+++ b/group12/2258659044/readme.txt
@@ -0,0 +1 @@
+this is my projectWorkcpace!
\ No newline at end of file
diff --git a/group12/2258659044/zj-2017/src/com/coding/basic/ArrayList.java b/group12/2258659044/zj-2017/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..5de89da950
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,94 @@
+package com.coding.basic;
+
+import java.util.NoSuchElementException;
+
+public class ArrayList implements List {
+	
+	private int size = 0;	
+	/*扩容因子*/
+	private static final int GENE = 10;
+	
+	private Object[] elementData = new Object[10];	
+	/*扩容引用*/
+	private Object[] newElementData;
+	
+	public void add(Object o){
+		grow();
+		elementData[size] = o;		
+		size ++;
+	}
+	public void add(int index, Object o){
+		
+		if(index>size){
+			throw new IndexOutOfBoundsException("Index: "+index+",Size:"+size);
+		}
+		grow(); 
+		if(index<size){//长度足够需要移动
+			newElementData = new Object[elementData.length];
+			System.arraycopy(elementData, 0, newElementData, 0, index);
+			System.arraycopy(elementData, index, newElementData, index+1, size-index);
+			elementData = newElementData;
+		}
+		elementData[index] = o;	
+		size ++;
+	}
+	
+	public Object get(int index){
+		
+		if(index>size){
+			throw new IndexOutOfBoundsException("Index: "+index+",Size:"+size);
+		}
+		return elementData[index];
+	}
+	
+	public Object remove(int index){
+		
+		Object o = elementData[index];
+		System.arraycopy(elementData, index+1, elementData, index, size-(index+1));		
+		size --;
+		return o;
+	}
+	
+	public int size(){
+		return size;
+	}
+			
+	/**
+	 * 扩容，扩容因子为10
+	 */
+	private void grow(){
+		
+		if(size>=elementData.length){//长度不够需要扩容
+			newElementData = new Object[size+GENE];
+			System.arraycopy(elementData, 0, newElementData, 0, elementData.length);
+			elementData = newElementData;		
+		}		
+	}
+	
+	
+    public Iterator iterator(){
+		
+		return new Itr();
+	}
+    
+    private class Itr implements Iterator{
+
+    	int cursor;   	
+		@Override
+		public boolean hasNext() {
+			return cursor != ArrayList.this.size;
+		}
+
+		@Override
+		public Object next() {
+			
+			int i = this.cursor;
+			if (i >= ArrayList.this.size){
+				throw new NoSuchElementException();
+			}			
+			this.cursor = (i + 1);
+			return ArrayList.this.elementData[i];
+		}
+    	
+    }
+}
diff --git a/group12/2258659044/zj-2017/src/com/coding/basic/BinaryTree.java b/group12/2258659044/zj-2017/src/com/coding/basic/BinaryTree.java
new file mode 100644
index 0000000000..e5fae50203
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/com/coding/basic/BinaryTree.java
@@ -0,0 +1,64 @@
+package com.coding.basic;
+
+public class BinaryTree {
+	
+	//根节点
+	private BinaryTreeNode root;	
+	    
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	public <T extends Comparable<? super T>> BinaryTreeNode insert(T o){
+		
+		BinaryTreeNode treeNode = new BinaryTreeNode();
+		treeNode.setData(o);
+		if(root == null){
+			root =  treeNode;
+		}else{				
+			BinaryTreeNode currentNode = root;
+			BinaryTreeNode parent;
+			while(true){
+				parent = currentNode;
+				if(((Comparable)currentNode.getData()).compareTo(o)>0){//向左放					
+					currentNode = currentNode.getLeft();
+					if(currentNode == null){
+						parent.setLeft(treeNode);
+						treeNode.setParent(parent);
+						break;
+					}					
+				}else{//向右放
+					currentNode = currentNode.getRight();
+					if(currentNode == null){
+						parent.setRight(treeNode);
+						treeNode.setParent(parent);
+						break;
+					}
+				}
+			}			
+		}
+		return treeNode;
+	}
+
+	/**
+	 * 先序遍历
+	 * @param node
+	 * @return
+	 */
+	public List traversalBefore(BinaryTreeNode node){
+		//所有数据集合
+	    List datas = new ArrayList();
+	    return traversal(node,datas);
+	}
+	private List traversal(BinaryTreeNode node,List datas){
+		
+		if(node !=null){
+			datas.add(node.getData());
+			traversal(node.getLeft(),datas);
+			traversal(node.getRight(),datas);
+		}
+		return datas;
+	}
+
+	public BinaryTreeNode getRoot() {
+		return root;
+	}
+		
+}
diff --git a/group12/2258659044/zj-2017/src/com/coding/basic/BinaryTreeNode.java b/group12/2258659044/zj-2017/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..557728a02a
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,37 @@
+package com.coding.basic;
+public class BinaryTreeNode {
+	
+	private Object data;
+	//父节点
+	private BinaryTreeNode parent;
+	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 getParent() {
+		return parent;
+	}
+	public void setParent(BinaryTreeNode parent) {
+		this.parent = parent;
+	}
+}
diff --git a/group12/2258659044/zj-2017/src/com/coding/basic/Iterator.java b/group12/2258659044/zj-2017/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..c854120212
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/com/coding/basic/Iterator.java
@@ -0,0 +1,8 @@
+package com.coding.basic;
+
+public interface Iterator {
+	
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group12/2258659044/zj-2017/src/com/coding/basic/LinkedList.java b/group12/2258659044/zj-2017/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..460298ff56
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,137 @@
+package com.coding.basic;
+
+import java.util.NoSuchElementException;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	
+	private int size = 0;
+	
+	public void add(Object o){
+		
+		Node addNode = new Node();
+		addNode.data = o;
+	    if(size==0){	    	
+	    	head = addNode;
+	    }else{
+	    	//获取最后一个节点
+	    	Node lastNode = getPointNode(size-1);
+	    	lastNode.next = addNode;	    		    	
+	    }
+	    size++;
+	}
+	public void add(int index , Object o){
+		
+		Node addNode = new Node();
+		addNode.data = o;
+		if(index == 0){			
+			addFirst(o);
+			return;
+		}		
+        if(index == size){
+			Node lastNode = getPointNode(size-1);
+			lastNode.next = addNode;
+		}else{
+			Node pointNode = getPointNode(index);
+			Node prePointNode = getPointNode(index-1);			
+			prePointNode.next = addNode;
+			addNode.next = pointNode;			
+		}	
+		size ++;
+	}
+	public Object get(int index){
+
+		Node node = getPointNode(index);
+		return node.data;
+	}
+	
+	public Object remove(int index){
+		
+		Node pointNode = getPointNode(index);
+		Node nextPointNode = getPointNode(index+1);
+		if(index ==0){
+			head = nextPointNode;			 
+		}else{
+			Node prePointNode = getPointNode(index-1);			
+			prePointNode.next = nextPointNode;
+		}						
+		size --;
+		return pointNode.data;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){	
+		
+		Node secondNode = head;	
+		head = new Node();
+		head.data = o;
+		if(size>0){		
+			head.next = secondNode;
+		}				
+		size ++;
+	}
+	
+	public void addLast(Object o){
+		add(o);
+	}
+	
+	public Object removeFirst(){
+
+		return remove(0);
+	}
+	
+	public Object removeLast(){
+		
+		return remove(size-1);
+	}
+	public Iterator iterator(){
+		return new Itr();
+	}
+	
+	private class Itr implements Iterator{
+
+		int cursor;
+		@Override
+		public boolean hasNext() {
+			return cursor != LinkedList.this.size;
+		}
+
+		@Override
+		public Object next() {
+			
+			int i = this.cursor;
+			if (i >= LinkedList.this.size){
+				throw new NoSuchElementException();
+			}			
+			this.cursor = (i + 1);
+			return LinkedList.this.get(i);
+		}
+		
+	}
+	
+	/**
+	 * 获取指定的节点
+	 * @return
+	 */
+	private Node getPointNode(int index){
+
+		if(index>size){
+			throw new IndexOutOfBoundsException("Index: "+index+",Size:"+size+"");	
+		}
+		Node node = head;
+		for (int i = 0; i < index; i++) {
+			node = node.next;
+		}
+		return node;
+	}
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		
+	}	
+}
\ No newline at end of file
diff --git a/group12/2258659044/zj-2017/src/com/coding/basic/List.java b/group12/2258659044/zj-2017/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..a5a3688eb6
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/com/coding/basic/List.java
@@ -0,0 +1,10 @@
+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();
+}
\ No newline at end of file
diff --git a/group12/2258659044/zj-2017/src/com/coding/basic/Queue.java b/group12/2258659044/zj-2017/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..e29ff65ddf
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/com/coding/basic/Queue.java
@@ -0,0 +1,26 @@
+package com.coding.basic;
+
+public class Queue {
+	
+	private LinkedList element = new LinkedList();
+	
+	public void enQueue(Object o){	
+		
+		element.add(o);
+	}
+	
+	public Object deQueue(){
+		
+		return element.removeFirst();
+	}
+	
+	public boolean isEmpty(){
+		
+		return element.size()==0;
+	}
+	
+	public int size(){
+		
+		return element.size();
+	}
+}
diff --git a/group12/2258659044/zj-2017/src/com/coding/basic/Stack.java b/group12/2258659044/zj-2017/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..03709097e5
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/com/coding/basic/Stack.java
@@ -0,0 +1,28 @@
+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(size()-1);
+	}
+	
+	public Object peek(){
+		
+		return elementData.get(size()-1);
+	}
+	public boolean isEmpty(){
+
+		return size()==0;
+	}
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group12/2258659044/zj-2017/src/test/com/coding/basic/ArrayListTest.java b/group12/2258659044/zj-2017/src/test/com/coding/basic/ArrayListTest.java
new file mode 100644
index 0000000000..badcb2968f
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/test/com/coding/basic/ArrayListTest.java
@@ -0,0 +1,109 @@
+package test.com.coding.basic;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.coding.basic.ArrayList;
+import com.coding.basic.Iterator;
+
+public class ArrayListTest {
+
+	ArrayList ls ;
+	@Before
+    public void setup() {
+        ls = new ArrayList();       
+    }
+	
+	/**
+	 * 测试一个参数的add方法
+	 * ArrayList当数据超过10时进行第一次扩容
+	 */
+	@Test
+	public void add(){
+		
+		ls.add(3);
+		ls.add("a");
+		for (int i = 0; i < 10; i++) {
+			ls.add(i);
+		}
+		Assert.assertEquals(ls.size(), 12);
+		Assert.assertEquals(ls.get(1), "a");
+	}
+
+	/**
+	 *  两个参数的add方法
+	 */
+	@Test//(expected = IndexOutOfBoundsException.class)
+	public void add4ToPramter(){
+		
+		ls.add(0, 0);
+		ls.add(1,1);
+		ls.add(2, 2);
+		ls.add(3,3);
+		for (int i = 0; i < 10; i++) {
+			ls.add(3,i);
+		}
+		Assert.assertEquals(ls.size(), 14);
+		Assert.assertEquals(ls.get(3), 9);
+		Assert.assertEquals(ls.get(13), 3);
+		//打开下面操作抛出异常
+		//ls.add(15, "a");
+	}
+
+	/**
+	 * get(i)
+	 */
+	@Test//(expected = IndexOutOfBoundsException.class)
+	public void get(){
+		
+		for (int i = 0; i < 10; i++) {
+			ls.add(i);
+		}
+		
+		Assert.assertEquals(ls.get(9), 9);	
+		//打开下面操作抛出异常
+		//ls.get(12);
+	}
+	
+	@Test
+	public void remove(){
+		
+		for (int i = 0; i < 10; i++) {
+			ls.add(i);
+		}	
+		Assert.assertEquals(ls.remove(5),5);
+		Assert.assertEquals(ls.size(),9);
+		Assert.assertEquals(ls.remove(8),9);
+		Assert.assertEquals(ls.size(),8);
+	}
+	
+	@Test
+	public void size(){
+		
+		Assert.assertEquals(ls.size(),0);
+		ls.add("a");
+		Assert.assertEquals(ls.size(),1);
+		ls.add(0,0);
+		Assert.assertEquals(ls.size(),2);
+		ls.remove(0);
+		Assert.assertEquals(ls.size(),1);
+		
+	}
+	
+	@Test//(expected = NoSuchElementException.class)
+	public void iterator(){
+		
+		for (int i = 0; i < 10; i++) {
+			ls.add(i);
+		}
+		Iterator it = ls.iterator();
+		Assert.assertEquals(it.hasNext(),true);
+		for (int i = 0; i < 10; i++) {
+			it.next();
+		}		
+		Assert.assertEquals(it.hasNext(),false);
+		//打开下面操作抛出异常
+		//it.next();
+	}
+}
diff --git a/group12/2258659044/zj-2017/src/test/com/coding/basic/BinaryTreeTest.java b/group12/2258659044/zj-2017/src/test/com/coding/basic/BinaryTreeTest.java
new file mode 100644
index 0000000000..0f343ed895
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/test/com/coding/basic/BinaryTreeTest.java
@@ -0,0 +1,58 @@
+package test.com.coding.basic;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.coding.basic.BinaryTree;
+import com.coding.basic.BinaryTreeNode;
+import com.coding.basic.List;
+
+public class BinaryTreeTest {
+
+	BinaryTree tree ;
+	
+	@Before
+    public void setup() {
+		
+		tree = new BinaryTree();
+		Assert.assertEquals(tree.getRoot(), null);
+		tree.insert(5);
+		tree.insert(2);
+		tree.insert(7);
+		tree.insert(1);
+		tree.insert(6);
+    }
+	@Test
+	public void insert(){
+		
+		BinaryTreeNode  node = tree.insert(4);
+		Assert.assertEquals(node.getParent().getData(), 2);
+		Assert.assertEquals(node.getParent().getLeft().getData(), 1);
+		
+		BinaryTreeNode node2 = tree.insert(8);
+		Assert.assertEquals(node2.getParent().getData(), 7);
+		Assert.assertEquals(node2.getParent().getLeft().getData(), 6);
+	}
+	
+	@Test
+	public void traversal(){
+		
+		insert();
+		//以根节点为起点先序遍历
+		List  treeList = tree.traversalBefore(tree.getRoot());
+		//expected value
+		int[] exValue = {5,2,1,4,7,6,8};
+		for (int i = 0; i < exValue.length; i++) {
+			Assert.assertEquals(treeList.get(i),exValue[i]);
+		}
+		
+		//以数据2位起点先序遍历
+		List  treeList2 = tree.traversalBefore(tree.getRoot().getLeft());
+		//expected value
+		int[] exValue2 = {2,1,4};
+		for (int i = 0; i < exValue2.length; i++) {
+			Assert.assertEquals(treeList2.get(i),exValue2[i]);
+		}
+	}
+}
diff --git a/group12/2258659044/zj-2017/src/test/com/coding/basic/LinkedListTest.java b/group12/2258659044/zj-2017/src/test/com/coding/basic/LinkedListTest.java
new file mode 100644
index 0000000000..a55b2d5a3f
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/test/com/coding/basic/LinkedListTest.java
@@ -0,0 +1,109 @@
+package test.com.coding.basic;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.coding.basic.Iterator;
+import com.coding.basic.LinkedList;
+
+public class LinkedListTest {
+
+	LinkedList ls ;
+	@Before
+    public void setup() {
+        ls = new LinkedList();       
+    }
+	
+	/**
+	 * 测试一个参数的add方法
+	 * ArrayList当数据超过10时进行第一次扩容
+	 */
+	@Test
+	public void add(){
+		
+		ls.add(3);
+		ls.add("a");
+		for (int i = 0; i < 10; i++) {
+			ls.add(i);
+		}
+		Assert.assertEquals(ls.size(), 12);
+		Assert.assertEquals(ls.get(1), "a");
+	}
+
+	/**
+	 *  两个参数的add方法
+	 */
+	@Test//(expected = IndexOutOfBoundsException.class)
+	public void add4ToPramter(){
+		
+		ls.add(0, 0);
+		ls.add(1,1);
+		ls.add(2, 2);
+		ls.add(3,3);
+		for (int i = 0; i < 10; i++) {
+			ls.add(3,i);
+		}
+		Assert.assertEquals(ls.size(), 14);
+		Assert.assertEquals(ls.get(3), 9);
+		Assert.assertEquals(ls.get(13), 3);
+		//打开下面操作抛出异常
+		//ls.add(15, "a");
+	}
+
+	/**
+	 * get(i)
+	 */
+	@Test//(expected = IndexOutOfBoundsException.class)
+	public void get(){
+		
+		for (int i = 0; i < 10; i++) {
+			ls.add(i);
+		}
+		
+		Assert.assertEquals(ls.get(9), 9);	
+		//打开下面操作抛出异常
+		//ls.get(12);
+	}
+	
+	@Test
+	public void remove(){
+		
+		for (int i = 0; i < 10; i++) {
+			ls.add(i);
+		}	
+		Assert.assertEquals(ls.remove(5),5);
+		Assert.assertEquals(ls.size(),9);
+		Assert.assertEquals(ls.remove(8),9);
+		Assert.assertEquals(ls.size(),8);
+	}
+	
+	@Test
+	public void size(){
+		
+		Assert.assertEquals(ls.size(),0);
+		ls.add("a");
+		Assert.assertEquals(ls.size(),1);
+		ls.add(0,0);
+		Assert.assertEquals(ls.size(),2);
+		ls.remove(0);
+		Assert.assertEquals(ls.size(),1);
+		
+	}
+	
+	@Test//(expected = NoSuchElementException.class)
+	public void iterator(){
+		
+		for (int i = 0; i < 10; i++) {
+			ls.add(i);
+		}
+		Iterator it = ls.iterator();
+		Assert.assertEquals(it.hasNext(),true);
+		for (int i = 0; i < 10; i++) {
+			it.next();
+		}		
+		Assert.assertEquals(it.hasNext(),false);
+		//打开下面操作抛出异常
+		//it.next();
+	}
+}
diff --git a/group12/2258659044/zj-2017/src/test/com/coding/basic/QueueTest.java b/group12/2258659044/zj-2017/src/test/com/coding/basic/QueueTest.java
new file mode 100644
index 0000000000..e688d9b41f
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/test/com/coding/basic/QueueTest.java
@@ -0,0 +1,64 @@
+package test.com.coding.basic;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.coding.basic.Queue;
+
+public class QueueTest {
+
+	Queue qe ;
+	
+	@Before
+    public void setup() {
+		qe = new Queue();
+		for (int i = 0; i < 10; i++) {
+			qe.enQueue(i);
+		}		
+    }
+
+	@Test
+	public void enQueue(){
+		
+		Assert.assertEquals(qe.size(), 10);
+		qe.enQueue("abcd");
+		Assert.assertEquals(qe.size(), 11);
+	}
+	
+	@Test//(expected = IndexOutOfBoundsException.class)
+	public void deQueue(){
+		
+		Assert.assertEquals(qe.size(), 10);		
+		for (int i = 0; i < 10; i++) {
+			Assert.assertEquals(qe.deQueue(), i);
+		}
+		Assert.assertEquals(qe.size(), 0);
+		//打开下列语句与期望异常测试
+		//qe.deQueue();
+	}
+	
+	public void isEmpty(){
+		
+		Assert.assertEquals(qe.isEmpty(),false);
+		for (int i = 0; i < 10; i++) {
+			qe.deQueue();
+		}
+		Assert.assertEquals(qe.isEmpty(),true);
+		Queue qe1 = new Queue();
+		Assert.assertEquals(qe1.isEmpty(), true);
+	}
+	
+	public void size(){
+		
+		Assert.assertEquals(qe.size(),10);
+		qe.enQueue("lk");
+		qe.enQueue('h');
+		Assert.assertEquals(qe.size(),12);
+		for (int i = 0; i < 12; i++) {
+			qe.deQueue();
+		}
+		Assert.assertEquals(qe.size(),0);
+		Queue qe1 = new Queue();
+		Assert.assertEquals(qe1.size(), 0);
+	}
+}
diff --git a/group12/2258659044/zj-2017/src/test/com/coding/basic/StackTest.java b/group12/2258659044/zj-2017/src/test/com/coding/basic/StackTest.java
new file mode 100644
index 0000000000..a0875c8f3c
--- /dev/null
+++ b/group12/2258659044/zj-2017/src/test/com/coding/basic/StackTest.java
@@ -0,0 +1,76 @@
+package test.com.coding.basic;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.coding.basic.Stack;
+
+public class StackTest {
+
+	Stack st ;
+	
+	@Before
+    public void setup() {
+		st = new Stack();
+		for (int i = 0; i < 10; i++) {
+			st.push(i);
+		}		
+    }
+
+	@Test
+	public void push(){
+		
+		Assert.assertEquals(st.size(), 10);
+		st.push(10);
+		st.push('a');
+		Assert.assertEquals(st.size(), 12);
+	}
+	
+	@Test//(expected = IndexOutOfBoundsException.class)
+	public void pop(){
+		
+		Assert.assertEquals(st.size(), 10);
+		for (int i = 9; i >= 0; i--) {
+			Assert.assertEquals(st.pop(), i);
+		}
+		//打开下列语句抛出期望异常
+		//st.pop();
+	}
+	
+	@Test
+	public void peek(){
+		
+		Assert.assertEquals(st.size(), 10);
+		Assert.assertEquals(st.peek(), 9);
+		Assert.assertEquals(st.size(), 10);
+	}
+	
+	@Test
+	public void isEmpty(){
+		
+		Assert.assertEquals(st.isEmpty(), false);
+		for (int i = 0; i < 10; i++) {
+			st.pop();
+		}
+		Assert.assertEquals(st.isEmpty(), true);
+		Stack st1 = new Stack();
+		Assert.assertEquals(st1.isEmpty(), true);
+	}
+	
+    public void size(){
+		
+		Assert.assertEquals(st.size(),10);
+		st.push("lk");
+		st.push('h');
+		Assert.assertEquals(st.size(),12);
+		for (int i = 0; i < 12; i++) {
+			st.pop();
+		}
+		Assert.assertEquals(st.size(),0);
+		st.peek();
+		Assert.assertEquals(st.size(),0);
+		Stack st1 = new Stack();
+		Assert.assertEquals(st1.size(), 0);
+	}
+}
diff --git a/group12/247565311/week1/ArrayList.java b/group12/247565311/week1/ArrayList.java
new file mode 100644
index 0000000000..c2643af683
--- /dev/null
+++ b/group12/247565311/week1/ArrayList.java
@@ -0,0 +1,249 @@
+package week1;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+
+public class ArrayList<E> implements List<E> {
+	private int size=0,offset=10;
+	private Object[] data = null;
+    public ArrayList(){
+    	data = new Object[offset];
+    }
+    public ArrayList(int arg0){
+    	if(arg0<0) arg0=0;
+    	size = arg0;
+    	data = new Object[size];
+    }
+	@Override
+	public boolean add(E arg0) {
+		if(arg0 == null) return false;
+		size += 1;
+		int leng = data.length;
+		if(size>leng){
+			Object[] newdata = new Object[size + offset];
+			for(int i=0;i<leng;i++){
+				newdata[i] = data[i];
+			}
+			data = newdata;
+		}
+		data[leng] = arg0;
+		return true;
+	}
+
+	@Override
+	public void add(int arg0, E arg1) {
+		if( arg0>size || 0<arg0) return ;
+		size += 1;
+		int leng = data.length;
+		if(size>leng){
+			Object[] newdata = new Object[size + offset];
+			for(int i=0;i<leng;i++){
+				newdata[i] = data[i];
+			}
+			data = newdata;
+		}
+		for (int i=1;i<size-arg0;i++){
+			data[size-i] = data[size-i-1];
+		}
+		data[arg0] = arg1;
+		return ;
+	}
+
+	@Override
+	public boolean addAll(Collection<? extends E> arg0) {
+		if (arg0 == null) return false;
+		int leng = data.length,newobjnum = arg0.size(),lastsize=size;
+		size += newobjnum;
+		if(size>leng){
+			Object[] newdata = new Object[size + offset];
+			for(int i=0;i<leng;i++){
+				newdata[i] = data[i];
+			}
+			data = newdata;
+		}
+		int i=lastsize;
+		for(E e : arg0){
+			data[i] = e;
+		}
+		return true;
+	}
+
+	@Override
+	public boolean addAll(int arg0, Collection<? extends E> arg1) {
+		int newobjnum = arg1.size(),lastsize = size;
+		if(arg1 == null || arg0>size+1 || 0>arg0 || newobjnum==0) return false;
+		size += newobjnum;
+		int leng = data.length;
+		if(size>leng){
+			Object[] newdata = new Object[size + offset];
+			for(int i=0;i<leng;i++){
+				newdata[i] = data[i];
+			}
+			data = newdata;
+		}
+		for (int i=1;i<size-arg0;i++){
+			data[size-i] = data[size-i-newobjnum];
+		}
+		int i = arg0;
+		for (E e:arg1){
+			data[i] = e;
+			i += 1;
+		}
+		return true;
+	}
+
+	@Override
+	public void clear() {
+		size=0;
+		data = new Object[offset];
+	}
+
+	@Override
+	public boolean contains(Object arg0) {
+		for(Object e:data){
+			if(e.equals(arg0)) return true;
+		}
+		return false;
+	}
+
+	@Override
+	public boolean containsAll(Collection<?> arg0) {
+		for(Object o:arg0){
+			if(!this.contains(o)) return false;
+		}
+		return true;
+	}
+
+	@Override
+	public E get(int arg0) {
+        if(arg0 >-1 && arg0<this.size) return (E)data[arg0];
+		return null;
+	}
+
+	@Override
+	public int indexOf(Object arg0) {
+		for(int i=0;i<this.size;i++){
+			if(this.data[i].equals(arg0)) return i;
+		}
+		return -1;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return this.size==0;
+	}
+	@Override
+	public int lastIndexOf(Object arg0) {
+		for(int i=this.size-1;i>-1;i--){
+			if(this.data[i].equals(arg0)) return i;
+		}
+		return -1;
+	}
+	
+	@Override
+	public Iterator<E> iterator() {
+
+		return null;
+	}
+	
+	@Override
+	public ListIterator<E> listIterator() {
+
+		return null;
+	}
+
+	@Override
+	public ListIterator<E> listIterator(int arg0) {
+
+		return null;
+	}
+
+	@Override
+	public boolean remove(Object arg0) {
+		for(int i=0;i<this.size;i++){
+			if(this.data[i].equals(arg0)){
+				this.remove(i);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public E remove(int arg0) {
+		if(arg0<0 ||arg0>this.size-1) return null;
+		E res = (E)data[arg0];
+		for(int i=arg0;i<this.size-1;i++){
+			this.data[i] = this.data[i+1];
+		}
+		this.size -= 1;
+		return res;
+	}
+
+	@Override
+	public boolean removeAll(Collection<?> arg0) {
+		int toberemovednums = arg0.size();
+		if(!this.containsAll(arg0)) return false;
+		int index=0;
+		for(int i=0;i<this.size;i++){
+			if(arg0.contains(data[i])){
+				this.remove(i);
+			}
+		}
+		return true;
+	}
+
+	@Override
+	public boolean retainAll(Collection<?> arg0) {
+        // what does this mean?
+		return false;
+	}
+
+	@Override
+	public E set(int arg0, E arg1) {
+		if(arg0<0||arg0>this.size-1) return null;
+		this.data[arg0] = arg1;
+		return arg1;
+	}
+
+	@Override
+	public int size() {
+		return this.size;
+	}
+
+	@Override
+	public List<E> subList(int arg0, int arg1) {
+		if(arg0>=arg1 || arg0<0 || arg1>this.size-1) return null;
+		List<E> res = new ArrayList<E>();
+		for(int i=arg0;i<arg1;i++){
+			// ��λ�ȡ������
+            
+            
+		}
+		
+		return null;
+	}
+//////////////////////////////////////////////
+	@Override
+	public Object[] toArray() {
+		if(this.size == 0) return null;
+		Object[] res = new Object[this.size];
+		for(int i=0;i<this.size;i++){
+			res[i] = this.data[i].getClass();
+		}
+		return null;
+	}
+
+	@Override
+	public <T> T[] toArray(T[] arg0) {
+		T[] res = (T[])(new Object[this.size]);
+		for(int i=0;i<this.size;i++){
+			
+		}
+		return null;
+	}
+}
diff --git a/group12/247565311/week1/Deque.java b/group12/247565311/week1/Deque.java
new file mode 100644
index 0000000000..b71c4b9fac
--- /dev/null
+++ b/group12/247565311/week1/Deque.java
@@ -0,0 +1,34 @@
+package week1;
+public class Deque<E> {
+     private LinkedList<E> data = new LinkedList<E>();
+     private int size = 0;
+     
+     
+     public Deque(){
+         
+     }
+     public Deque(int arg0){
+         data = new LinkedList<E>(arg0);
+     }
+     public boolean push(E arg0){
+         data.add(data.size(),arg0);
+         size += 1;
+         return true;
+     }
+     public E pop(){
+         size -= 1;
+         E res = data.get(0);
+         data.remove(0);
+         return res;
+     }
+     public E peek(){
+         return data.get(0);
+     }
+     public int size(){
+         return this.size;
+     }
+     public boolean isEmpty(){
+         return this.size==0;
+     }
+     
+}
diff --git a/group12/247565311/week1/Link.java b/group12/247565311/week1/Link.java
new file mode 100644
index 0000000000..e2910e53d3
--- /dev/null
+++ b/group12/247565311/week1/Link.java
@@ -0,0 +1,5 @@
+package week1;
+
+public class Link {
+
+}
diff --git a/group12/247565311/week1/LinkedList.java b/group12/247565311/week1/LinkedList.java
new file mode 100644
index 0000000000..c3f0ca2eb8
--- /dev/null
+++ b/group12/247565311/week1/LinkedList.java
@@ -0,0 +1,266 @@
+package week1;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class LinkedList<E> implements List<E>,Cloneable {
+	private Node head = null;
+	private Node tail = null;
+	private int size = 0;
+	
+	public LinkedList(){
+        head = new Node(null);
+        tail = new Node(null);
+        head.next = tail;
+        tail.ahead = head;
+        size = 0;
+	}
+	public LinkedList(int arg0){
+        head = new Node(null);
+        tail = new Node(null);
+        head.next = tail;
+        tail.ahead = head;
+        size = 0;
+	}
+	public Object clone(){
+		LinkedList<E> clone = null;
+		try {
+			clone = (LinkedList<E>)(super.clone());
+		} catch (CloneNotSupportedException e) {
+			e.printStackTrace();
+		}
+		clone.head = new Node(null);
+		clone.tail = new Node(null);
+		clone.size = 0;
+		for(Node x = head.next;x!=null;x = x.next){
+			clone.add(x.val);
+		}
+		return clone;
+	}
+	@Override
+	public boolean add(Object val) {
+		Node n = new Node(val);
+		n.next = tail;
+		n.ahead = tail.ahead;
+		tail.ahead.next = n;
+		tail.ahead = n;
+		size += 1;
+		return true;
+	}
+
+	@Override
+	public void add(int arg0, E arg1) {
+		if(arg0<0 || arg0>size) arg0=0;
+		Node n=new Node(arg1),p=head;
+		for(int i=0;i<arg0;i++){
+			p = p.next;
+		}
+		n.next = p.next;
+		n.ahead = p;
+		p.next.ahead = n;
+		p.next = n;
+		size += 1;
+	}
+
+	@Override
+	public boolean addAll(Collection<? extends E> arg0) {
+        for(E o:arg0){
+        	this.add(o);
+        }
+		return true;
+	}
+
+	@Override
+	public boolean addAll(int arg0, Collection<? extends E> arg1) {
+        for(E e:arg1){
+        	this.add(arg0,e);
+        	arg0+=1;
+        }
+		return true;
+	}
+
+	@Override
+	public void clear() {
+        head = new Node(null);
+        tail = new Node(null);
+        head.next = tail;
+        tail.ahead = head;
+        size = 0;
+	}
+
+	@Override
+	public boolean contains(Object arg0) {
+		boolean flag = arg0==null;
+        Node n = head;
+        for(int i=0;i<size;i++){
+        	n = n.next;
+        	if(flag){
+        		if( n.val == null) return true;
+        	}else{
+        		if(arg0.equals(n.val)) return true;
+        	}
+        }
+		return false;
+	}
+
+	@Override
+	public boolean containsAll(Collection<?> arg0) {
+        for(Object e:arg0){
+        	if(!this.contains(e)) return false;
+        }
+		return true;
+	}
+
+	@Override
+	public E get(int arg0) {
+		E res = null;
+        if(arg0>-1 && arg0 < size){
+        	Node n = head;
+        	for(int i=0;i<arg0;i++){
+        		n = n.next;
+        	}
+        	res = (E) n.val;
+        }
+		return res;
+	}
+
+	@Override
+	public int indexOf(Object arg0) {
+        boolean flag = arg0 == null;
+        Node n=head;
+        for(int i=0;i<size;i++){
+            n = n.next;
+        	if(flag){
+        		if(n.val == null) return i;
+        	}else{
+        		if(arg0.equals(n.val)) return i;
+        	}
+        }
+		return -1;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return size==0;
+	}
+
+	@Override
+	public Iterator<E> iterator() {
+
+		return null;
+	}
+
+	@Override
+	public int lastIndexOf(Object arg0) {
+		boolean flag = arg0==null;
+		Node n = tail;
+		for(int i=size-1;i>-1;i--){
+			n = n.ahead;
+			if(flag){
+				if(n.val == null) return i;
+			}else{
+				if(arg0.equals(n.val)) return i;
+			}
+		}
+		return -1;
+	}
+
+	@Override
+	public ListIterator<E> listIterator() {
+
+		return null;
+	}
+
+	@Override
+	public ListIterator<E> listIterator(int arg0) {
+
+		return null;
+	}
+
+	@Override
+	public boolean remove(Object arg0) {
+        Node n = head;
+        int index = this.indexOf(arg0);
+        if(index == -1) return false;
+        for(int i=0;i<index;i++){
+        	n = n.next;
+        }
+        Node d = n.next;
+        n.next = d.next;
+        d.next.ahead = n;
+		return true;
+	}
+
+	@Override
+	public E remove(int arg0) {
+        Node n = head;
+        if(arg0 <0 || arg0>size-1) return null;
+        for(int i=0;i<arg0;i++){
+        	n = n.next;
+        }
+        Node d = n.next;
+        n.next = d.next;
+        d.next.ahead = n;
+		return (E)(d.val);
+	}
+
+	@Override
+	public boolean removeAll(Collection<?> arg0) {
+		for(Object o:arg0){
+			if(!this.remove(o)) return false;
+		}
+		return true;
+	}
+
+	@Override
+	public boolean retainAll(Collection<?> arg0) {
+		// ?
+		return false;
+	}
+
+	@Override
+	public E set(int arg0, E arg1) {
+        if(arg0<0 || arg0>size-1) return null;
+        Node n=head;
+        for(int i=0;i<arg0;i++){
+        	n = n.next;
+        }
+        n.next.val = arg1;
+		return (E)(n.next.val);
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+
+	@Override
+	public List<E> subList(int arg0, int arg1) {
+
+		return null;
+	}
+
+	@Override
+	public Object[] toArray() {
+		Object[]res = new Object[size];
+		Node n = head;
+		for(int i=0;i<size;i++){
+			n = n.next;
+			res[i] = n.val;		// if we change res[],will this list be changed?
+		}
+		return res;
+	}
+
+	@Override
+	public <T> T[] toArray(T[] arg0) {
+
+		return null;
+	}
+	private static class Node{
+		Object val = null;
+		Node next = null,ahead=null;
+		public Node(Object arg0){val = arg0;}
+	}
+}
diff --git a/group12/247565311/week1/Stack.java b/group12/247565311/week1/Stack.java
new file mode 100644
index 0000000000..5672274d81
--- /dev/null
+++ b/group12/247565311/week1/Stack.java
@@ -0,0 +1,39 @@
+package week1;
+
+import java.util.List;
+
+public class Stack<E> {
+    private List<E> data = new ArrayList<E>();
+    private int size = 0;
+    
+    public Stack(){
+        
+    }
+    
+    public Stack(int arg0){
+        if(arg0 < 0) arg0 = 0;
+        size = arg0;
+        data = new ArrayList<E>(size);
+        
+    }
+    public boolean isEmpty(){
+    	return size==0;
+    }
+    public boolean push(E arg0){
+        size += 1;
+        data.add(arg0);
+        return true;
+    }
+    public E pop(){
+    	if(this.isEmpty()) return null;
+    	size -= 1;
+    	E res = data.get(size);
+    	data.remove(size);
+    	return res;
+    }
+    public E peek(){
+    	if(this.isEmpty()) return null;
+    	E res = data.get(size-1);
+    	return res;
+    }
+}
diff --git a/group12/251822722/ArrayList.java b/group12/251822722/ArrayList.java
new file mode 100755
index 0000000000..77b8052cc7
--- /dev/null
+++ b/group12/251822722/ArrayList.java
@@ -0,0 +1,87 @@
+import java.util.Arrays;
+
+public class ArrayList implements List {
+
+    private int size = 0;
+
+    private int index =0;
+
+    private Object[] elementData = new Object[100];
+
+    public void add(Object o) {
+        elementData[size] = o;
+        size = size+1;
+
+    }
+
+    public void add(int index, Object o) {
+
+        Object[] elementDataNew =null;
+        if(size<elementData.length+1){
+             elementDataNew = new Object[elementData.length];
+        }else {
+             elementDataNew = new Object[elementData.length+1];
+        }
+
+        for(int i =0;i<index;i++){
+            elementDataNew[i]=elementData[i];
+        }
+
+        elementDataNew[index]=o;
+
+        for(int j= index+1;j<elementData.length;j++){
+            elementDataNew[j]=elementData[j];
+        }
+        elementData = elementDataNew;
+        size=size+1;
+
+        return;
+
+    }
+
+    public Object get(int index) {
+        return elementData[index];
+    }
+
+    public Object remove(int index) {
+        Object[]  elementDataNew = new Object[elementData.length+1];
+
+        for(int i =0;i<index;i++){
+            elementDataNew[i]=elementData[i];
+        }
+
+        for(int j= index+1;j<elementData.length;j++){
+            elementDataNew[j-1]=elementData[j];
+        }
+
+        elementData = elementDataNew;
+        size=size-1;
+         return this;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public Iterator iterator() {
+        return null;
+    }
+
+    @Override
+    public String toString() {
+        return "ArrayList{" +
+                "size=" + size +
+                ", index=" + index +
+                ", elementData=" + Arrays.toString(elementData) +
+                '}';
+    }
+
+    public static void main(String[] args) {
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(1);
+        arrayList.add(2,2);
+        arrayList.remove(0);
+
+        arrayList.toString();
+    }
+}
diff --git a/group12/251822722/BinaryTreeNode.java b/group12/251822722/BinaryTreeNode.java
new file mode 100755
index 0000000000..42555b1cec
--- /dev/null
+++ b/group12/251822722/BinaryTreeNode.java
@@ -0,0 +1,35 @@
+public class BinaryTreeNode {
+
+    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) {
+        return null;
+    }
+
+}
diff --git a/group12/251822722/Iterator.java b/group12/251822722/Iterator.java
new file mode 100755
index 0000000000..dfb39722c0
--- /dev/null
+++ b/group12/251822722/Iterator.java
@@ -0,0 +1,6 @@
+public interface Iterator {
+    public boolean hasNext();
+
+    public Object next();
+
+}
diff --git a/group12/251822722/LinkedList.java b/group12/251822722/LinkedList.java
new file mode 100755
index 0000000000..90018af9d6
--- /dev/null
+++ b/group12/251822722/LinkedList.java
@@ -0,0 +1,51 @@
+public class LinkedList implements List {
+
+    private Node head;
+
+    public void add(Object o) {
+
+    }
+
+    public void add(int index, Object o) {
+
+    }
+
+    public Object get(int index) {
+        return null;
+    }
+
+    public Object remove(int index) {
+        return null;
+    }
+
+    public int size() {
+        return -1;
+    }
+
+    public void addFirst(Object o) {
+
+    }
+
+    public void addLast(Object o) {
+
+    }
+
+    public Object removeFirst() {
+        return null;
+    }
+
+    public Object removeLast() {
+        return null;
+    }
+
+    public Iterator iterator() {
+        return null;
+    }
+
+
+    private static class Node {
+        Object data;
+        Node next;
+
+    }
+}
diff --git a/group12/251822722/List.java b/group12/251822722/List.java
new file mode 100755
index 0000000000..f1ef71d8d5
--- /dev/null
+++ b/group12/251822722/List.java
@@ -0,0 +1,11 @@
+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/group12/251822722/Queue.java b/group12/251822722/Queue.java
new file mode 100755
index 0000000000..40cae21c2f
--- /dev/null
+++ b/group12/251822722/Queue.java
@@ -0,0 +1,38 @@
+public class Queue {
+
+
+    private Object[] elementData = new Object[100];
+
+    private int size =0;
+
+    public void enQueue(Object o) {
+
+        elementData[size]=o;
+        size=size+1;
+    }
+
+    public Object deQueue() {
+
+        Object a = elementData[0];
+
+        Object[] newElementData = new Object[100];
+
+        for (int i = 1; i < elementData.length; i++)
+        {
+            newElementData[i-1]=elementData[i];
+        }
+        elementData=newElementData;
+        return a;
+    }
+
+    public boolean isEmpty() {
+        if(size==0){
+            return true;
+        }
+        return false;
+    }
+
+    public int size() {
+        return elementData.length;
+    }
+}
diff --git a/group12/251822722/Stack.java b/group12/251822722/Stack.java
new file mode 100755
index 0000000000..a45944296a
--- /dev/null
+++ b/group12/251822722/Stack.java
@@ -0,0 +1,33 @@
+
+public class Stack {
+    private Object[] elementData = new Object[100];
+
+    private int size =0;
+    public void push(Object o) {
+        elementData[size()]=o;
+        size=size+1;
+    }
+
+    public Object pop() {
+        Object a = elementData[size];
+        elementData[size]=null;
+        size = size-1;
+        return a;
+    }
+
+    public Object peek() {
+        return  elementData[size];
+    }
+
+    public boolean isEmpty() {
+
+        if(size==0){
+            return true;
+        }
+        return false;
+    }
+
+    public int size() {
+        return elementData.length;
+    }
+}
diff --git a/group12/377401843/learning_1/.gitignore b/group12/377401843/learning_1/.gitignore
new file mode 100644
index 0000000000..9c47ca7e58
--- /dev/null
+++ b/group12/377401843/learning_1/.gitignore
@@ -0,0 +1,3 @@
+/bin/
+/.project
+/.classpath
diff --git a/group12/377401843/learning_1/src/com/guodong/datastructure/ArrayList.java b/group12/377401843/learning_1/src/com/guodong/datastructure/ArrayList.java
new file mode 100644
index 0000000000..a1ee0ee339
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/ArrayList.java
@@ -0,0 +1,171 @@
+package com.guodong.datastructure;
+
+import java.util.Arrays;
+
+public class ArrayList implements List {
+
+	private int size = 0;
+
+	private Object[] elementData = new Object[100];
+	
+	/**
+	 * 按下标顺序新增元素
+	 *
+	 * @Method add
+	 * @param o
+	 * @see com.guodong.datastructure.List#add(java.lang.Object)
+	 */
+	public void add(Object o) {
+		ensureCapacityInternal(size + 1);
+		elementData[size] = o;
+		size++;
+	}
+
+	/**
+	 * 在指定下标位置插入元素
+	 *
+	 * @Method add
+	 * @param index
+	 * @param o
+	 * @see com.guodong.datastructure.List#add(int, java.lang.Object)
+	 */
+	public void add(int index, Object o) {
+		checkRangeForAdd(index);
+		
+		ensureCapacityInternal(size + 1);
+		
+		System.arraycopy(elementData, index, elementData, index + 1, size - index);
+		
+		elementData[index] = o;
+		size++;
+	}
+
+	/**
+	 * 根据下标获取列表数据 
+	 *
+	 * @Method get
+	 * @param index
+	 * @return
+	 * @see com.guodong.datastructure.List#get(int)
+	 */
+	public Object get(int index) {
+		checkRangeForGetOrRemove(index);
+		
+		return elementData[index];
+	}
+
+	/**
+	 * 根据下标移除元素，并返回移除的元素值
+	 *
+	 * @Method remove
+	 * @param index
+	 * @return
+	 * @see com.guodong.datastructure.List#remove(int)
+	 */
+	public Object remove(int index) {
+		checkRangeForGetOrRemove(index);
+		
+		Object oldValue = elementData[index];
+		
+		System.arraycopy(elementData, index + 1, elementData, index, size - index -1);
+		
+		size--;
+		elementData[size] = null;
+		
+		return oldValue;
+	}
+
+	/**
+	 * 获得列表长度
+	 *
+	 * @Method size
+	 * @return
+	 * @see com.guodong.datastructure.List#size()
+	 */
+	public int size() {
+		return size;
+	}
+
+	/**
+	 * 获取ArrayList的迭代器
+	 *
+	 * @MethodName iterator
+	 * @author zhaogd
+	 * @date 2017年2月21日 下午8:19:28
+	 * @return
+	 */
+	public Iterator iterator() {
+		return new ArrayListIterator();
+	}
+
+	/**
+	 * 确保数组容量足够，如果不够则扩充数组
+	 *
+	 * @MethodName ensureCapacityInternal
+	 * @author zhaogd
+	 * @date 2017年2月21日 下午5:06:46
+	 * @param minCapacity
+	 */
+	private void ensureCapacityInternal(int minCapacity) {
+		if(minCapacity > elementData.length){
+			grow(minCapacity);
+		}
+	}
+
+	/**
+	 * 数组扩充，每次扩充原数组一半的长度，然后把原数组拷贝到新数组
+	 *
+	 * @MethodName grow
+	 * @author zhaogd
+	 * @date 2017年2月21日 下午5:20:55
+	 * @param minCapacity
+	 */
+	private void grow(int minCapacity) {
+		minCapacity = elementData.length + elementData.length / 2;
+		elementData = Arrays.copyOf(elementData, minCapacity);
+	}
+	
+	/**
+	 * 检查Add方法的下标范围是否合法
+	 *
+	 * @MethodName checkRangeForAdd
+	 * @author zhaogd
+	 * @date 2017年2月21日 下午7:32:55
+	 * @param index
+	 */
+	private void checkRangeForAdd(int index) {
+		if(index > size || index < 0){
+			throw new IndexOutOfBoundsException("Index:" + index + ",Size:" + size);
+		}
+	}
+	
+	/**
+	 * 检查Get或者Remove方法的下标范围是否合法
+	 *
+	 * @MethodName checkRangeForGetOrRemove
+	 * @author zhaogd
+	 * @date 2017年2月21日 下午7:33:21
+	 * @param index
+	 */
+	private void checkRangeForGetOrRemove(int index) {
+		if(index >= size || index < 0){
+			throw new IndexOutOfBoundsException("Index:" + index + ",Size:" + size);
+		}
+	}
+	
+	
+	private class ArrayListIterator implements Iterator{
+
+		private int lastIndex = 0;
+		
+		@Override
+		public boolean hasNext() {
+			return lastIndex < size;
+		}
+
+		@Override
+		public Object next() {
+			return elementData[lastIndex++];
+		}
+	}
+}
diff --git a/group12/377401843/learning_1/src/com/guodong/datastructure/BinaryTreeNode.java b/group12/377401843/learning_1/src/com/guodong/datastructure/BinaryTreeNode.java
new file mode 100644
index 0000000000..677eff3dab
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/BinaryTreeNode.java
@@ -0,0 +1,58 @@
+package com.guodong.datastructure;
+
+public class BinaryTreeNode {
+
+	private int data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+
+	public BinaryTreeNode(int data) {
+		this.data = data;
+	}
+
+	public int getData() {
+		return data;
+	}
+
+	public void setData(int 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(int o) {
+
+		if (o < data) {
+			if (left != null) {
+				left.insert(o);
+			} else {
+				left = new BinaryTreeNode(o);
+				return left;
+			}
+		} else {
+			if (right != null) {
+				right.insert(o);
+			} else {
+				right = new BinaryTreeNode(o);
+				return right;
+			}
+		}
+
+		return null;
+	}
+
+}
diff --git a/group12/377401843/learning_1/src/com/guodong/datastructure/Iterator.java b/group12/377401843/learning_1/src/com/guodong/datastructure/Iterator.java
new file mode 100644
index 0000000000..1a9bc5ad8a
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/Iterator.java
@@ -0,0 +1,7 @@
+package com.guodong.datastructure;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group12/377401843/learning_1/src/com/guodong/datastructure/LinkedList.java b/group12/377401843/learning_1/src/com/guodong/datastructure/LinkedList.java
new file mode 100644
index 0000000000..a7dc12694e
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/LinkedList.java
@@ -0,0 +1,285 @@
+package com.guodong.datastructure;
+
+import java.util.NoSuchElementException;
+
+public class LinkedList implements List {
+
+	private int size;
+
+	private Node head;
+
+	private Node last;
+
+	/**
+	 * 向 链表尾端插入元素
+	 *
+	 * @Method add
+	 * @param o
+	 * @see com.guodong.datastructure.List#add(java.lang.Object)
+	 */
+	public void add(Object o) {
+		linkLast(o);
+	}
+
+	/**
+	 * 向链表指定位置插入元素
+	 *
+	 * @Method add
+	 * @param index
+	 * @param o
+	 * @see com.guodong.datastructure.List#add(int, java.lang.Object)
+	 */
+	public void add(int index, Object o) {
+		checkIndexForAdd(index);
+
+		if (index == size) {
+			linkLast(o);
+		} else {
+			Node prevNode = getNodeByIndex(index - 1); // 取到当前下标的前一个节点
+			Node currentNode = getNodeByIndex(index); // 取到当前下标节点
+			Node newNode = new Node(o, currentNode); // 创建新节点，新节点的下一个节点为当前下标节点
+
+			if (prevNode == null) { // 如果前一个节点为空，说明从头部插入
+				head = newNode;
+			} else {
+				prevNode.next = newNode;
+			}
+			size++;
+		}
+	}
+
+	/**
+	 * 根据下标获取链表中元素
+	 *
+	 * @Method get
+	 * @param index
+	 * @return
+	 * @see com.guodong.datastructure.List#get(int)
+	 */
+	public Object get(int index) {
+		checkIndexForGet(index);
+		return getNodeByIndex(index).data;
+	}
+
+	public Object getLast() {
+		return last.data;
+	}
+
+	/**
+	 * 根据下标移除链表元素
+	 *
+	 * @Method remove
+	 * @param index
+	 * @return
+	 * @see com.guodong.datastructure.List#remove(int)
+	 */
+	public Object remove(int index) {
+		checkIndexForGet(index);
+
+		Node prevNode = getNodeByIndex(index - 1); // 获取当前index前一个元素
+		Node currentNode = null;
+		if (prevNode == null) {
+			currentNode = getNodeByIndex(index); // 如果前一个为空，则把下一个元素赋值给链表头
+			head = currentNode.next;
+		} else {
+			currentNode = prevNode.next; // 如果不为空，则把前一个节点跟后一个节点链接
+			prevNode.next = currentNode.next;
+		}
+		Node nextNode = currentNode.next;
+
+		if (nextNode == null) { // 如果后一个节点为空，则把链尾赋值为前一个节点
+			last = prevNode;
+		} else {
+			currentNode.next = null; // 如果后一个节点不为空，不做任何处理，只打断当前节点的链接
+		}
+		Object data = currentNode.data;
+		currentNode.data = null; // 清空当前节点的值，等待垃圾回收
+
+		size--;
+
+		return data;
+	}
+
+	/**
+	 * 返回List长度
+	 */
+	public int size() {
+		return size;
+	}
+
+	/**
+	 * 向列表头部添加元素
+	 * 
+	 * @param o
+	 */
+	public void addFirst(Object o) {
+		Node n = head;
+		Node newNode = new Node(o, n);
+
+		head = newNode;
+		if (n == null) {
+			last = newNode;
+		}
+		size++;
+	}
+
+	/**
+	 * 向列表尾部添加元素
+	 * 
+	 * @param o
+	 */
+	public void addLast(Object o) {
+		linkLast(o);
+	}
+
+	/**
+	 * 移除链表第一个元素
+	 * 
+	 * @return
+	 */
+	public Object removeFirst() {
+		Node n = head;
+		if (n == null) {
+			throw new NoSuchElementException();
+		}
+		Object data = n.data;
+		Node nextNode = n.next;
+
+		n.data = null;
+		n.next = null;
+
+		head = nextNode;
+		if (nextNode == null) {
+			last = null;
+		}
+
+		size--;
+		return data;
+	}
+
+	public Object removeLast() {
+		Node n = last;
+		if (n == null) {
+			throw new NoSuchElementException();
+		}
+		Object data = n.data;
+		Node prevNode = getNodeByIndex(size - 2);
+		n.data = null;
+		if (prevNode == null) {
+			head = null;
+		} else {
+			prevNode.next = null;
+		}
+		last = prevNode;
+
+		size--;
+		return data;
+	}
+
+	/**
+	 * 根据下标获取对应的节点
+	 *
+	 * @MethodName getNodeByIndex
+	 * @author zhaogd
+	 * @date 2017年2月23日 下午3:32:48
+	 * @param index
+	 * @return
+	 */
+	private Node getNodeByIndex(int index) {
+		if (index < 0) {
+			return null;
+		}
+		Node n = head;
+		for (int i = 0; i < index; i++) {
+			n = n.next;
+		}
+		return n;
+	}
+
+	/**
+	 * 在链表尾端插入节点
+	 *
+	 * @MethodName linkLast
+	 * @author zhaogd
+	 * @date 2017年2月23日 下午3:14:28
+	 * @param o
+	 */
+	private void linkLast(Object o) {
+		Node n = last; // 取出原尾端数据
+		Node newNode = new Node(o, null); // 创建新节点
+		last = newNode; // 把新节点放入链表尾端
+		// 如果原尾端为空，说明链表为空，把新节点也放入链表头部
+		// 如果不为空，把原尾端节点指向新节点
+		if (n == null) {
+			head = newNode;
+		} else {
+			n.next = newNode;
+		}
+
+		size++;
+	}
+
+	/**
+	 * 检查下标是否合法
+	 *
+	 * @MethodName checkIndexForAdd
+	 * @author zhaogd
+	 * @date 2017年2月23日 下午3:05:07
+	 * @param index
+	 */
+	private void checkIndexForAdd(int index) {
+		if (index < 0 || index > size) {
+			throw new IndexOutOfBoundsException("Index:" + index + ",Size:" + size);
+		}
+	}
+
+	/**
+	 * 检查下标是否合法
+	 *
+	 * @MethodName checkIndexForGet
+	 * @author zhaogd
+	 * @date 2017年2月23日 下午4:21:35
+	 * @param index
+	 */
+	private void checkIndexForGet(int index) {
+		if (index < 0 || index >= size) {
+			throw new IndexOutOfBoundsException("Index:" + index + ",Size:" + size);
+		}
+	}
+
+	private static class Node {
+		Object data;
+		Node next;
+
+		Node(Object data, Node next) {
+			this.data = data;
+			this.next = next;
+		}
+	}
+
+	public Iterator iterator() {
+		return new LinkedListIterator();
+	}
+
+	private class LinkedListIterator implements Iterator {
+		private Node current;
+
+		private int index;
+
+		@Override
+		public boolean hasNext() {
+			return index < size;
+		}
+
+		@Override
+		public Object next() {
+			if (current == null) {
+				current = getNodeByIndex(index);
+			}
+			Object data = current.data;
+			current = current.next;
+			index++;
+			return data;
+		}
+	}
+}
diff --git a/group12/377401843/learning_1/src/com/guodong/datastructure/List.java b/group12/377401843/learning_1/src/com/guodong/datastructure/List.java
new file mode 100644
index 0000000000..2471c15d21
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/List.java
@@ -0,0 +1,14 @@
+package com.guodong.datastructure;
+
+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/group12/377401843/learning_1/src/com/guodong/datastructure/Queue.java b/group12/377401843/learning_1/src/com/guodong/datastructure/Queue.java
new file mode 100644
index 0000000000..b14751aab7
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/Queue.java
@@ -0,0 +1,21 @@
+package com.guodong.datastructure;
+
+public class Queue {
+	private LinkedList element = new LinkedList();
+
+	public void enQueue(Object o) {
+		element.addLast(o);
+	}
+
+	public Object deQueue() {
+		return element.removeFirst();
+	}
+
+	public boolean isEmpty() {
+		return element.size() == 0;
+	}
+
+	public int size() {
+		return element.size();
+	}
+}
diff --git a/group12/377401843/learning_1/src/com/guodong/datastructure/Stack.java b/group12/377401843/learning_1/src/com/guodong/datastructure/Stack.java
new file mode 100644
index 0000000000..f743d0dd3b
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/Stack.java
@@ -0,0 +1,25 @@
+package com.guodong.datastructure;
+
+public class Stack {
+	private LinkedList elementData = new LinkedList();
+
+	public void push(Object o) {
+		elementData.addLast(o);
+	}
+
+	public Object pop() {
+		return elementData.removeLast();
+	}
+
+	public Object peek() {
+		return elementData.getLast();
+	}
+
+	public boolean isEmpty() {
+		return elementData.size() == 0;
+	}
+
+	public int size() {
+		return elementData.size();
+	}
+}
diff --git a/group12/377401843/learning_1/src/com/guodong/datastructure/test/ArrayListTest.java b/group12/377401843/learning_1/src/com/guodong/datastructure/test/ArrayListTest.java
new file mode 100644
index 0000000000..ec3a7600a4
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/test/ArrayListTest.java
@@ -0,0 +1,135 @@
+package com.guodong.datastructure.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.guodong.datastructure.ArrayList;
+import com.guodong.datastructure.Iterator;
+
+public class ArrayListTest {
+
+	ArrayList arrayList;
+
+	@Before
+	public void setUp() throws Exception {
+		arrayList = new ArrayList();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	@Test
+	public void testAddObject() {
+		// 测试新增
+		arrayList.add(0);
+		assertEquals(0, arrayList.get(0));
+		assertEquals(1, arrayList.size());
+
+		// 测试扩充
+		for (int i = 1; i < 101; i++) {
+			arrayList.add(i);
+		}
+		assertEquals(101, arrayList.size());
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForAdd1() {
+		// 测试新增下标异常时，是否可以正确抛出异常
+		arrayList.add(-1, 2);
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForAdd2() {
+		// 测试新增下标异常时，是否可以正确抛出异常
+		arrayList.add(1, 3);
+	}
+
+	@Test
+	public void testAddIntObject() {
+		// 测试下标新增
+		arrayList.add(0, 1);
+		arrayList.add(1, 2);
+		arrayList.add(2, 3);
+		arrayList.add(3, 4);
+		assertEquals(4, arrayList.size());
+
+		// 测试中间插入
+		arrayList.add(2, 5);
+		assertEquals(5, arrayList.size()); // 测试插入之后长度
+		assertEquals(5, arrayList.get(2));
+		assertEquals(4, arrayList.get(4)); // 测试插入之后原来数据是否后移
+		assertEquals(3, arrayList.get(3)); // 测试插入之后原来数据是否后移
+
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForGet1() {
+		// 测试Get时，下标异常，是否可以正确抛出异常
+		arrayList.get(-1);
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForGet2() {
+		// 测试Get时，下标异常，是否可以正确抛出异常
+		arrayList.get(0);
+	}
+
+	@Test
+	public void testGet() {
+		arrayList.add(1);
+		arrayList.add(2);
+		arrayList.add(3);
+		assertEquals(1, arrayList.get(0));
+		assertEquals(2, arrayList.get(1));
+		assertEquals(3, arrayList.get(2));
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForRemove1() {
+		arrayList.remove(-1);
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForRemove2() {
+		arrayList.remove(0);
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForRemove3() {
+		arrayList.remove(1);
+	}
+
+	@Test
+	public void testRemove() {
+		arrayList.add(1);
+		arrayList.remove(0);
+		assertEquals(0, arrayList.size());
+
+		arrayList.add(1);
+		arrayList.add(2);
+		arrayList.remove(0);
+		assertEquals(1, arrayList.size());
+		assertEquals(2, arrayList.get(0));
+	}
+
+	@Test
+	public void testSize() {
+		arrayList.add(1);
+		assertEquals(1, arrayList.size());
+	}
+
+	@Test
+	public void testIterator() {
+		Iterator iterator = arrayList.iterator();
+		assertFalse(iterator.hasNext());
+		
+		arrayList.add(1);
+		assertTrue(iterator.hasNext());
+		assertEquals(1, iterator.next());
+		assertFalse(iterator.hasNext());
+	}
+}
diff --git a/group12/377401843/learning_1/src/com/guodong/datastructure/test/BinaryTreeNodeTest.java b/group12/377401843/learning_1/src/com/guodong/datastructure/test/BinaryTreeNodeTest.java
new file mode 100644
index 0000000000..83972b7776
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/test/BinaryTreeNodeTest.java
@@ -0,0 +1,37 @@
+package com.guodong.datastructure.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.guodong.datastructure.BinaryTreeNode;
+
+public class BinaryTreeNodeTest {
+	
+	private BinaryTreeNode binaryTreeNode;
+
+	@Before
+	public void setUp() throws Exception {
+		binaryTreeNode = new BinaryTreeNode(50);
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	@Test
+	public void testInsert() {
+		binaryTreeNode.insert(20);
+		binaryTreeNode.insert(30);
+		binaryTreeNode.insert(60);
+		binaryTreeNode.insert(80);
+		
+		assertEquals(20, binaryTreeNode.getLeft().getData());
+		assertEquals(30, binaryTreeNode.getLeft().getRight().getData());
+		assertEquals(60, binaryTreeNode.getRight().getData());
+		assertEquals(80, binaryTreeNode.getRight().getRight().getData());
+	}
+
+}
diff --git a/group12/377401843/learning_1/src/com/guodong/datastructure/test/LinkedListTest.java b/group12/377401843/learning_1/src/com/guodong/datastructure/test/LinkedListTest.java
new file mode 100644
index 0000000000..054e8f81b4
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/test/LinkedListTest.java
@@ -0,0 +1,143 @@
+package com.guodong.datastructure.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.guodong.datastructure.Iterator;
+import com.guodong.datastructure.LinkedList;
+
+public class LinkedListTest {
+
+	private LinkedList linkedList;
+
+	@Before
+	public void setUp() throws Exception {
+		linkedList = new LinkedList();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	@Test
+	public void testAddObject() {
+		linkedList.add(1);
+		assertEquals(1, linkedList.size());
+		assertEquals(1, linkedList.get(0));
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForAdd1() {
+		linkedList.add(-1, 1);
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForAdd2() {
+		linkedList.add(1, 1);
+	}
+
+	@Test
+	public void testAddIntObject() {
+		linkedList.add(0, 1);
+		linkedList.add(1, 2);
+		assertEquals(1, linkedList.get(0));
+		
+		linkedList.add(1,3);
+		assertEquals(2, linkedList.get(2));
+		assertEquals(3, linkedList.get(1));
+		assertEquals(3, linkedList.size());
+	}
+
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForGet1() {
+		linkedList.get(-1);
+	}
+	
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForGet2() {
+		linkedList.get(0);
+	}
+	
+	@Test(expected = IndexOutOfBoundsException.class)
+	public void testExceptionForGet3() {
+		linkedList.get(1);
+	}
+	
+	@Test
+	public void testGet() {
+		linkedList.add(0, 1);
+		linkedList.add(1, 2);
+		assertEquals(2, linkedList.get(1));
+	}
+
+	@Test
+	public void testGetLast() {
+		linkedList.add(1);
+		assertEquals(1, linkedList.getLast());
+		
+		linkedList.add(2);
+		assertEquals(2, linkedList.getLast());
+	}
+
+	@Test
+	public void testRemove() {
+		linkedList.add(1);
+		assertEquals(1, linkedList.remove(0));
+		assertEquals(0, linkedList.size());
+	}
+
+	@Test
+	public void testSize() {
+		linkedList.add(1);
+		linkedList.add(1);
+		linkedList.add(1);
+		assertEquals(3, linkedList.size());
+	}
+
+	@Test
+	public void testAddFirst() {
+		linkedList.addFirst(1);
+		assertEquals(1, linkedList.get(0));
+		
+		linkedList.addFirst(2);
+		linkedList.addFirst(3);
+		assertEquals(3, linkedList.get(0));
+		assertEquals(1, linkedList.getLast());
+	}
+
+	@Test
+	public void testAddLast() {
+		linkedList.addLast(1);
+		assertEquals(1, linkedList.getLast());
+		assertEquals(1, linkedList.get(0));
+	}
+
+	@Test
+	public void testRemoveFirst() {
+		linkedList.addFirst(1);
+		assertEquals(1, linkedList.removeFirst());
+		assertEquals(0, linkedList.size());
+	}
+
+	@Test
+	public void testRemoveLast() {
+		linkedList.addLast(2);
+		assertEquals(2, linkedList.removeLast());
+		assertEquals(0, linkedList.size());
+	}
+
+	@Test
+	public void testIterator() {
+		Iterator iterator = linkedList.iterator();
+		assertFalse(iterator.hasNext());
+		
+		linkedList.add(1);
+		assertTrue(iterator.hasNext());
+		assertEquals(1, iterator.next());
+		assertFalse(iterator.hasNext());
+	}
+
+}
diff --git a/group12/377401843/learning_1/src/com/guodong/datastructure/test/QueueTest.java b/group12/377401843/learning_1/src/com/guodong/datastructure/test/QueueTest.java
new file mode 100644
index 0000000000..86a4ebdd68
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/test/QueueTest.java
@@ -0,0 +1,62 @@
+package com.guodong.datastructure.test;
+
+import static org.junit.Assert.*;
+
+import java.util.NoSuchElementException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.guodong.datastructure.Queue;
+
+public class QueueTest {
+
+	private Queue queue;
+	
+	@Before
+	public void setUp() throws Exception {
+		queue = new Queue();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	@Test
+	public void testEnQueue() {
+		queue.enQueue(1);
+		assertFalse(queue.isEmpty());
+	}
+	
+	@Test(expected = NoSuchElementException.class)
+	public void testDeQueueExecption() {
+		queue.deQueue();
+	}
+
+	@Test
+	public void testDeQueue() {
+		queue.enQueue(1);
+		assertEquals(1, queue.deQueue());
+		assertTrue(queue.isEmpty());
+	}
+
+	@Test
+	public void testIsEmpty() {
+		queue.enQueue(1);
+		assertFalse(queue.isEmpty());
+		
+		queue.deQueue();
+		assertTrue(queue.isEmpty());
+	}
+
+	@Test
+	public void testSize() {
+		queue.enQueue(1);
+		queue.enQueue(1);
+		queue.enQueue(1);
+		
+		assertEquals(3, queue.size());
+	}
+
+}
diff --git a/group12/377401843/learning_1/src/com/guodong/datastructure/test/StackTest.java b/group12/377401843/learning_1/src/com/guodong/datastructure/test/StackTest.java
new file mode 100644
index 0000000000..36781c863f
--- /dev/null
+++ b/group12/377401843/learning_1/src/com/guodong/datastructure/test/StackTest.java
@@ -0,0 +1,46 @@
+package com.guodong.datastructure.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.guodong.datastructure.Stack;
+
+public class StackTest {
+	
+	private Stack stack;
+
+	@Before
+	public void setUp() throws Exception {
+		stack = new Stack();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	@Test
+	public void testPush() {
+		stack.push(11);
+		assertEquals(11, stack.pop());
+		assertTrue(stack.isEmpty());
+	}
+
+	@Test
+	public void testPop() {
+		stack.push(11);
+		assertEquals(11, stack.pop());
+		assertTrue(stack.isEmpty());
+	}
+
+	@Test
+	public void testPeek() {
+		stack.push(11);
+		assertEquals(11, stack.peek());
+		assertFalse(stack.isEmpty());
+		assertEquals(1, stack.size());
+	}
+
+}
diff --git a/group12/382266293/.classpath b/group12/382266293/.classpath
new file mode 100644
index 0000000000..3e0fb272a8
--- /dev/null
+++ b/group12/382266293/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group12/382266293/.gitignore b/group12/382266293/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group12/382266293/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group12/382266293/.project b/group12/382266293/.project
new file mode 100644
index 0000000000..1282023911
--- /dev/null
+++ b/group12/382266293/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>382266293Learning</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group12/382266293/src/Collection/AbstractList.java b/group12/382266293/src/Collection/AbstractList.java
new file mode 100644
index 0000000000..a81e76b587
--- /dev/null
+++ b/group12/382266293/src/Collection/AbstractList.java
@@ -0,0 +1,43 @@
+package Collection;
+
+public abstract class AbstractList<E> implements List<E> {
+
+	protected static final String PREFIX = "[";
+	protected static final String SUFFIX = "]";
+	protected static final String SEPERATOR = ", ";
+	protected static final int MAX_SIZE = Integer.MAX_VALUE/3;
+	
+	protected void checkIndex(int i) {
+		if( i < 0 || i > Math.min(size(), MAX_SIZE))
+			throw new IndexOutOfBoundsException("Size :" + size()+", Index: " + i);
+	}
+	
+	public boolean isEmpty() {
+		return size() == 0;
+	}
+	
+
+	public int indexOf(E e) {
+		for (int i = 0; i < size()-1; i++) {
+			if (get(i).equals(e))
+				return i;
+		}
+		return -1;
+	}
+
+	protected abstract Iterator<E> iterator();
+	
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		sb.append(PREFIX);
+		for (int i = 0; i < size(); i++) {
+			sb.append(get(i));
+			if (i < size()-1)
+				sb.append(SEPERATOR);
+		}
+		sb.append(SUFFIX);
+		return sb.toString();
+	}
+	
+}
diff --git a/group12/382266293/src/Collection/Concrete/ArrayList.java b/group12/382266293/src/Collection/Concrete/ArrayList.java
new file mode 100644
index 0000000000..3db5ab47e6
--- /dev/null
+++ b/group12/382266293/src/Collection/Concrete/ArrayList.java
@@ -0,0 +1,148 @@
+package Collection.Concrete;
+
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+import Collection.AbstractList;
+import Collection.Iterator;
+
+public class ArrayList<E> extends AbstractList<E> {
+
+	private E[] elements;
+	private int size;
+	private static final int INITIAL_SIZE = 16;
+
+
+	public ArrayList() {
+		elements = (E[]) new Object[INITIAL_SIZE];
+		size = 0;
+	}
+	
+	@Override
+	public void add(E e) {
+		checkCapacity();
+		elements[size++] = e;
+	}
+
+	private void checkCapacity() {
+		if (size >= MAX_SIZE)
+			throw new IndexOutOfBoundsException("Reached max size");
+		
+		if (elements.length - size < INITIAL_SIZE)
+			grow();
+	}
+
+	synchronized private void grow() {
+		
+		int newCapacity = size * 2;
+		newCapacity = (newCapacity < 0 || newCapacity - MAX_SIZE > 0) ? MAX_SIZE : newCapacity;
+		E[] target = (E[]) new Object[newCapacity];
+		System.arraycopy(elements, 0, target, 0, size);
+		elements = target;
+		
+	}
+	
+	public void add(int index, E e) {
+		checkCapacity();
+		if (index == size) {
+			add(e);
+			return;
+		}
+		checkIndex(index);
+		synchronized (this) {
+			System.arraycopy(elements, index, elements, index+1, size-index+1);
+			elements[index] = e;
+			size++;
+		}
+	}
+	
+	@Override
+	public E get(int index) {
+		checkIndex(index);
+			return elements[index];
+	}
+
+	
+	public E getLast() {
+		return get(size-1);
+	}
+	
+	public void addLast(E e) {
+		add(e);	
+	}
+	
+	public E removeLast() {
+		return elements[--size];
+	}
+	
+	public E remove(int index) {
+		checkIndex(index);
+		E result = elements[index];
+		synchronized (this) {
+			System.arraycopy(elements, index+1, elements, index, size-index-1);
+			elements[--size] = null;
+		}
+		return result;
+	}
+	
+	@Override
+	public int size() {
+		return size;
+	}
+	
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + Arrays.hashCode(elements);
+		result = prime * result + size;
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		ArrayList other = (ArrayList) obj;
+		if (!Arrays.equals(elements, other.elements))
+			return false;
+		if (size != other.size)
+			return false;
+		return true;
+	}
+
+	public Iterator<E> iterator(){
+		return new ArrayListIterator<E>(this);
+	}
+	
+	private class ArrayListIterator<E> implements Iterator<E> {
+
+		private ArrayList<E> myArrayList;
+		private int pos;
+		
+		public ArrayListIterator(ArrayList<E> arrayList) {
+			myArrayList = arrayList;
+			pos = 0;
+		}
+
+		@Override
+		public boolean hasNext() {
+			return pos < size;
+		}
+
+		@Override
+		public E next() {
+			if (hasNext())
+				return (E) elements[pos++];
+			throw new NoSuchElementException();
+		}
+	}
+
+
+
+}
diff --git a/group12/382266293/src/Collection/Concrete/BinaryTreeNode.java b/group12/382266293/src/Collection/Concrete/BinaryTreeNode.java
new file mode 100644
index 0000000000..34a9d4253e
--- /dev/null
+++ b/group12/382266293/src/Collection/Concrete/BinaryTreeNode.java
@@ -0,0 +1,126 @@
+package Collection.Concrete;
+
+public class BinaryTreeNode<E extends Comparable<E>> {
+	
+	private E data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+	private int size;
+	private ArrayList<E> myList;
+
+	
+	
+	public BinaryTreeNode() {
+		this.data = null;
+		this.left = null;
+		this.right = null;
+	}
+	
+	public BinaryTreeNode(E data) {
+		this.data = data;
+		this.left = null;
+		this.right = null;
+	}
+	
+    public boolean isEmpty() {
+        return data == null;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public BinaryTreeNode<E> insert(E o) {
+        BinaryTreeNode<E> res;
+        if (isEmpty()) {
+            data = o;
+            size++;
+            return this;
+        } else {
+            BinaryTreeNode<E> p = this;
+            res = new BinaryTreeNode<E>(o);
+            while (true) {
+                if (res.getData().compareTo(p.getData()) < 0) {
+                    if (p.left == null) {
+                        p.setLeft(res);
+                        break;
+                    }
+                    p = p.left;
+                } else if (res.getData().compareTo(p.getData()) > 0) {
+                    if (p.right == null) {
+                        p.setRight(res);
+                        break;
+                    }
+                    p = p.right;
+                } else {
+                	return null;
+                }
+            }
+            size++;
+        }
+        return res;
+    }
+    
+    
+
+    public ArrayList<E> preOrderTraversal(BinaryTreeNode<E> node) {
+    	
+        if (node != null) {
+        	preOrderTraversal(node.left);
+        	myList.add(node.data);
+            preOrderTraversal(node.right);
+        }
+        return myList;
+    }
+
+	@Override
+	public String toString() {
+		myList = new ArrayList<E>();
+		return preOrderTraversal(this).toString();
+	}
+
+	public E getData() {
+		return data;
+	}
+	public void setData(E 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;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((data == null) ? 0 : data.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;
+		BinaryTreeNode other = (BinaryTreeNode) obj;
+		if (data == null) {
+			if (other.data != null)
+				return false;
+		} else if (!data.equals(other.data))
+			return false;
+		return true;
+	}
+
+}
\ No newline at end of file
diff --git a/group12/382266293/src/Collection/Concrete/LinkedList.java b/group12/382266293/src/Collection/Concrete/LinkedList.java
new file mode 100644
index 0000000000..66dbd9d8d0
--- /dev/null
+++ b/group12/382266293/src/Collection/Concrete/LinkedList.java
@@ -0,0 +1,196 @@
+package Collection.Concrete;
+
+import java.util.NoSuchElementException;
+import Collection.AbstractList;
+import Collection.Iterator;
+
+
+public class LinkedList<E> extends AbstractList<E> {
+
+	private Node head;
+	private int size;
+	
+	public LinkedList() {
+		this.head = new Node<E>(null);
+		this.size = 0;
+	}
+	
+	@Override
+	public void add(E e) {
+		addLast(e);
+	}
+	
+	
+	@Override
+	public E get(int index) {
+		checkIndex(index);
+		return getNode(index).data;
+	}
+	
+	public E getFirst() {
+		return get(0);
+	}
+	
+	public E getLast() {
+		return get(size-1);
+	}
+	
+	
+	public void add(int index, E e) {		
+		if (index == size) {
+			addLast(e);
+			return;
+		} 
+		
+		if (index == 0) {
+			addFirst(e);
+			return;
+		}
+		
+		checkIndex(index);
+		Node<E> pNode = new Node<E>(e);
+		Node<E> p = getNode(index);
+		synchronized (this) {
+			getNode(index-1).next = pNode;
+			pNode.next = p;
+			size++;
+		}
+	}
+
+	public void addFirst(E e){
+		checkCapacity();
+		Node<E> pNode = new Node<E>(e);
+		Node oldHead = head;
+		head = pNode;
+		pNode.next = oldHead;
+		size++;
+		return;
+	}
+	
+	public void addLast(E e){
+		if (size == 0) {
+			addFirst(e);
+			return;
+		}
+		
+		checkCapacity();
+		Node res = new Node<E>(e);
+		setLastNode(res);
+		size++;
+		return;
+	}
+	
+	public E removeFirst(){
+		return remove(0);
+	}
+	public E removeLast(){
+		return remove(size-1);
+	}
+
+	public E remove(int index) {
+		checkIndex(index);
+		Node<E> pNode = getNode(index);
+		if (index == 0) {
+			head =  head.next;
+		} else if (index == size-1 ) {
+			getNode(index-1).next = null;
+		} else {
+			getNode(index-1).next = getNode(index+1);
+		}
+		size--;
+		return pNode.data;
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+	
+	public Iterator<E> iterator(){
+		return new LinkedListIterator<E>(this);
+	}
+
+	private void checkCapacity() {
+		if (size > MAX_SIZE)
+			throw new IndexOutOfBoundsException("Reached max capacity: "+ MAX_SIZE);
+	}	
+
+	private Node<E> getNode(int index) {
+		if (size == 0)
+			return head;
+	
+		Node pNode = head;
+		for ( int i = 0; i < index ; i++) {
+			pNode = pNode.next;
+		}
+		return pNode;
+	}
+	
+	private void setLastNode(Node res) {
+		getNode(size-1).next = res;
+	}
+
+	private static class Node<E> {
+		E data;
+		Node next;
+		
+		public Node(E data) {
+			this.data = data;
+			this.next = null;
+		}
+
+		@Override
+		public String toString() {
+			return data.toString();
+		}
+
+		@Override
+		public int hashCode() {
+			final int prime = 31;
+			int result = 1;
+			result = prime * result + ((data == null) ? 0 : data.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;
+			Node other = (Node) obj;
+			if (data == null) {
+				if (other.data != null)
+					return false;
+			} else if (!data.equals(other.data))
+				return false;
+			return true;
+		}
+	}
+	
+	@SuppressWarnings("hiding")
+	private class LinkedListIterator<E> implements Iterator<E> {
+
+		private LinkedList<E> myLinkedList;
+		private int pos;
+		
+		public LinkedListIterator(LinkedList<E> linkedList) {
+			myLinkedList = linkedList;
+			pos = 0;
+		}
+
+		@Override
+		public boolean hasNext() {
+			return pos < size;
+		}
+
+		@Override
+		public E next() {
+			if (hasNext())
+				return (E) get(pos++);
+			throw new NoSuchElementException();
+		}
+	}
+}
diff --git a/group12/382266293/src/Collection/Concrete/Queue.java b/group12/382266293/src/Collection/Concrete/Queue.java
new file mode 100644
index 0000000000..300fb633af
--- /dev/null
+++ b/group12/382266293/src/Collection/Concrete/Queue.java
@@ -0,0 +1,84 @@
+package Collection.Concrete;
+import java.util.NoSuchElementException;
+
+import Collection.AbstractList;
+import Collection.Iterator;
+
+public class Queue<E> extends AbstractList<E> {
+	
+	private LinkedList<E> myList;
+
+	public Queue() {
+		this.myList = new LinkedList<E>();
+	}
+	
+	public void enQueue(E e){
+		myList.addLast(e);
+	}
+	
+	public E deQueue(){
+		if (0 == size())
+			return null;
+		return myList.removeFirst();
+	}
+
+	@Override
+	public void add(E e) {
+		enQueue(e);
+	}
+	
+	@Override
+	public E get(int index) {
+		if (0 == size())
+			return null;
+		return myList.get(index);
+	}
+	
+	public E element() {
+		if (0 == size())
+			return null;
+		return myList.getFirst();
+	}
+
+
+	@Override
+	public int size() {
+		return myList.size();
+	}
+	
+	@Override
+	protected Iterator<E> iterator() {
+		return myList.iterator();
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((myList == null) ? 0 : myList.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;
+		Queue other = (Queue) obj;
+		if (myList == null) {
+			if (other.myList != null)
+				return false;
+		} else if (!myList.equals(other.myList))
+			return false;
+		return true;
+	}
+
+
+
+
+	
+
+}
diff --git a/group12/382266293/src/Collection/Concrete/Stack.java b/group12/382266293/src/Collection/Concrete/Stack.java
new file mode 100644
index 0000000000..17ec4364fa
--- /dev/null
+++ b/group12/382266293/src/Collection/Concrete/Stack.java
@@ -0,0 +1,106 @@
+package Collection.Concrete;
+
+import java.util.EmptyStackException;
+import java.util.NoSuchElementException;
+
+import Collection.AbstractList;
+import Collection.Iterator;
+
+public class Stack<E> extends AbstractList<E> {
+	
+	private ArrayList<E> myList;
+
+	public Stack() {
+		this.myList = new ArrayList<E>();
+	}
+
+	public void push(E e){
+		myList.addLast(e);
+	}
+	
+	public E pop(){
+		checkEmpty();
+		return myList.removeLast();
+	}
+	
+	private void checkEmpty() {
+		if (0 == size())
+			throw new EmptyStackException();
+	}
+
+	public E peek(){
+		checkEmpty();
+		return myList.getLast();
+	}
+
+	public int size(){
+		return myList.size();
+	}
+
+	@Override
+	public void add(E e) {
+		push(e);
+	}
+
+	@Override
+	public E get(int index) {
+		checkEmpty();
+		return myList.get(size() - index - 1);
+	}
+	
+	@Override
+	protected Iterator<E> iterator() {
+		return new StackIterator(myList);
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((myList == null) ? 0 : myList.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;
+		Stack other = (Stack) obj;
+		if (myList == null) {
+			if (other.myList != null)
+				return false;
+		} else if (!myList.equals(other.myList))
+			return false;
+		return true;
+	}
+	
+	private class StackIterator<E> implements Iterator<E> {
+
+		private ArrayList<E> myArrayList;
+		private int pos;
+		
+		public StackIterator(ArrayList<E> myList) {
+			myArrayList = myList;
+			pos = 0;
+		}
+
+		@Override
+		public boolean hasNext() {
+			return pos < size();
+		}
+
+		@Override
+		public E next() {
+			if (hasNext())
+				return (E) get(pos);
+			throw new NoSuchElementException();
+		}
+	}
+
+	
+	
+}
diff --git a/group12/382266293/src/Collection/Iterator.java b/group12/382266293/src/Collection/Iterator.java
new file mode 100644
index 0000000000..d51656a3a8
--- /dev/null
+++ b/group12/382266293/src/Collection/Iterator.java
@@ -0,0 +1,7 @@
+package Collection;
+
+public interface Iterator<E> {
+
+	public boolean hasNext();
+	public E next();
+}
diff --git a/group12/382266293/src/Collection/List.java b/group12/382266293/src/Collection/List.java
new file mode 100644
index 0000000000..7ddb685cac
--- /dev/null
+++ b/group12/382266293/src/Collection/List.java
@@ -0,0 +1,16 @@
+package Collection;
+
+public interface List<E> {
+	
+	public void add(E e);
+		
+	public int size();
+	
+	public E get(int index);
+	
+	public boolean isEmpty();
+	
+	public int indexOf(E e);
+
+	
+}
diff --git a/group12/382266293/src/TestCollection/AllTests.java b/group12/382266293/src/TestCollection/AllTests.java
new file mode 100644
index 0000000000..cd4eeadb58
--- /dev/null
+++ b/group12/382266293/src/TestCollection/AllTests.java
@@ -0,0 +1,11 @@
+package TestCollection;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({ ArrayListTest.class, BinaryTreeNodeTest.class, LinkedListTest.class, QueueTest.class, StackTest.class })
+public class AllTests {
+
+}
diff --git a/group12/382266293/src/TestCollection/ArrayListTest.java b/group12/382266293/src/TestCollection/ArrayListTest.java
new file mode 100644
index 0000000000..f29580616f
--- /dev/null
+++ b/group12/382266293/src/TestCollection/ArrayListTest.java
@@ -0,0 +1,173 @@
+package TestCollection;
+
+import static util.Print.*;
+import static util.TestUtil.*;
+import java.util.Date;
+import java.util.NoSuchElementException;
+import java.util.Random;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+
+import Collection.Iterator;
+import Collection.List;
+import Collection.Concrete.ArrayList;
+import junit.framework.TestCase;
+
+public class ArrayListTest extends TestCase {
+
+
+	private ArrayList<Integer> myAL;
+	private static Random rnd = new Random();
+	
+	@Before
+	public void setUp() throws Exception {
+		
+		myAL = new ArrayList<Integer>();
+		assertEquals(true,myAL.isEmpty());
+		
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		myAL = null;
+	}
+
+	@Test
+	public void testRawTypeArrayList() {
+		
+		List rawList = new ArrayList();
+		assertEquals(rawList.size(), 0);
+		rawList.add(new Date());
+		assertEquals(1, rawList.size());
+	}
+
+	@Test
+	public void testEmpty() {
+		
+		assertEquals(true,myAL.isEmpty());
+		
+		myAL.add(5);
+		assertEquals(false,myAL.isEmpty());
+		
+		int num = getRandomNumber();
+		addIntWithNatureOrder(myAL, num);
+		assertEquals(false,myAL.isEmpty());
+		
+	}
+
+	@Test
+	public void testAddIntAutoBoxing() {
+		
+		myAL.add(5);
+		myAL.add(5);
+		myAL.add(5);
+		myAL.add(1,10);
+		int c = myAL.get(1);
+		assertEquals(10,c);
+		
+		assertEquals(4,myAL.size());
+		myAL.add(4,15);
+		int a = myAL.get(0);
+		Integer b = myAL.get(1);
+		c =  myAL.get(2);
+		int d = myAL.get(3);
+		int e = myAL.get(4);
+		assertEquals(5,a);
+		assertEquals(new Integer(10),b);
+		assertEquals(5,c);
+		assertEquals(5,d);
+		assertEquals(15,e);
+	}
+	
+	@Test
+	public void testGet() {
+		
+		int[] result = addRandomInt(myAL, getRandomNumber());
+		
+		int actual,expected;
+		
+		for (int i = 0; i < result.length; i++) {
+			actual = myAL.get(i);
+			expected = result[i];
+			assertEquals(expected, actual);
+		}
+
+	}
+
+	@Test
+	public void testRemove() {
+
+		addIntWithNatureOrder(myAL, 100);
+		
+		testRemoveAndGetFromTail(myAL);
+		try {
+			myAL.remove(10);
+			fail("no exception thrown");
+		} catch (Exception e) {
+			assertEquals(IndexOutOfBoundsException.class, e.getClass());
+		}
+
+	}
+
+	@Test
+	public void testSize() {
+		
+		assertEquals(0,myAL.size());
+		int num = getRandomNumber();
+		addIntWithNatureOrder(myAL, num);
+		assertEquals(num,myAL.size());
+	}
+
+
+	
+	@Test
+	public void testGrow() {
+		
+		int actualSize = 12345;
+		
+		addIntWithNatureOrder(myAL, actualSize);
+		
+		assertEquals(actualSize,myAL.size());
+	}
+	
+
+	@Test
+	public void testIterator() {
+		
+		addIntWithNatureOrder(myAL,100);
+		
+		Iterator<Integer> it = myAL.iterator();
+
+		for(int i = 0; it.hasNext(); i++){
+			int actual = it.next();
+			assertEquals(i,actual);
+		}
+		
+	    try {
+			it.next();
+	    } catch (NoSuchElementException ex) {
+	        assertEquals(ex.getClass(),NoSuchElementException.class);
+	    }
+	}
+	
+	@Test
+	public void testIndexOf() {
+		
+		int num = 200;
+		addIntWithNatureOrder(myAL,num);
+
+		int expected,actual;
+		for (int i = 0; i < num-1; i++) {
+			expected = i;
+			actual = myAL.indexOf(i);
+			assertEquals(expected, actual);
+		}
+		
+		assertEquals(-1, myAL.indexOf(-1*getRandomNumber()));
+
+	}
+
+}
diff --git a/group12/382266293/src/TestCollection/BinaryTreeNodeTest.java b/group12/382266293/src/TestCollection/BinaryTreeNodeTest.java
new file mode 100644
index 0000000000..275ef59484
--- /dev/null
+++ b/group12/382266293/src/TestCollection/BinaryTreeNodeTest.java
@@ -0,0 +1,54 @@
+package TestCollection;
+
+import static util.Print.*;
+import java.util.Random;
+import java.util.Set;
+import java.util.TreeSet;
+import static util.TestUtil.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import Collection.Concrete.BinaryTreeNode;
+import junit.framework.TestCase;
+
+public class BinaryTreeNodeTest extends TestCase {
+
+	private BinaryTreeNode<Integer> myTree;
+	
+	@Before
+	public void setUp() throws Exception {
+		myTree = new BinaryTreeNode<Integer>();
+		assertEquals(0, myTree.size());
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		myTree = null;
+	}
+
+	@Test
+	public void testInsert() {
+		Set<Integer> expected =  new TreeSet<Integer>();
+		int size = getRandomNumber();
+		int j = 0 ;
+		while (expected.size() != size) {
+			j = getRandomNumber();
+			expected.add(j);
+			myTree.insert(j);
+		}
+		
+		assertEquals(size,myTree.size());
+		assertEquals(expected.toString(),myTree.toString());
+	}
+	
+	public void testSize() {
+		
+		for (int i = 0; i < getRandomNumber(); i++) {
+			myTree.insert(18);
+			myTree.insert(-19);
+			myTree.insert(1);
+			assertEquals(3,myTree.size());
+		}	
+	}
+}
\ No newline at end of file
diff --git a/group12/382266293/src/TestCollection/LinkedListTest.java b/group12/382266293/src/TestCollection/LinkedListTest.java
new file mode 100644
index 0000000000..8b9fad15eb
--- /dev/null
+++ b/group12/382266293/src/TestCollection/LinkedListTest.java
@@ -0,0 +1,212 @@
+package TestCollection;
+
+import static util.Print.*;
+import static util.TestUtil.*; 
+import java.util.Date;
+import java.util.NoSuchElementException;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import Collection.Iterator;
+import Collection.List;
+import Collection.Concrete.LinkedList;
+import junit.framework.TestCase;
+
+
+public class LinkedListTest extends TestCase {
+
+	LinkedList<String> myLL;
+	
+	@Before
+	public void setUp() throws Exception {
+		myLL = new LinkedList<String>();
+		assertEquals(0,myLL.size());
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		myLL = null;
+	}
+
+	@Test
+	public void testLinkedList() {
+		List rawList = new LinkedList();
+		assertEquals(rawList.size(), 0);
+		rawList.add(new Date());
+		assertEquals(1, rawList.size());
+		
+	}
+
+	@Test
+	public void testAddE() {
+		myLL.add("s");
+		assertEquals(1,myLL.size());
+		assertEquals(false,myLL.isEmpty());
+	}
+
+	@Test
+	public void testAddStringE() {
+		String a;
+		
+		addString(myLL,30);
+		println(myLL.get(0));
+
+//		for (int i = 0 ; i < 29; i++) {
+//			a = "" + i;
+//			assertEquals(myLL.get(i),a);
+//		}
+	}
+	
+	@Test
+	public void testAddIndex() {
+		String a;
+		for (int i = 0 ; i < 30; i++) {
+			a = "" + i;
+			myLL.add(a);
+		}
+		
+		String ss = "ss";
+		myLL.add(3,ss);
+		assertEquals(myLL.get(3), ss);
+		assertEquals(myLL.get(2), "2");
+		assertEquals(myLL.get(4), "3");
+		
+	}
+	
+	public void testAddFirst() {
+		String a;
+		for (int i = 0 ; i < 20; i++) {
+			a = "" + i;
+			myLL.add(a);
+		}
+		
+		String ss = "bba";
+		myLL.addFirst(ss);
+		assertEquals(ss,myLL.get(0));
+		assertEquals(21, myLL.size());
+		
+		;
+		for (int i = 1 ; i < myLL.size(); i++) {
+			a = (i-1) + "";
+			assertEquals(a, myLL.get(i));
+		}		
+	}
+	
+	public void testAddLast() {
+		String a;
+		for (int i = 0 ; i < 25; i++) {
+			a = "" + i;
+			myLL.add(a);
+		}
+		
+		String ss = "25";
+		myLL.addLast(ss);
+		int size = myLL.size();
+		assertEquals(26, size);
+
+		for (int i = 0 ; i < size; i++) {
+			a = i + "";
+			assertEquals(a, myLL.get(i));
+		}		
+	}
+	
+	@Test
+	public void testRemoveFirst() {
+		
+		String a = "";
+		String result = "";
+		for(int i = 0; i < 10; i++) {
+			myLL.add(i+"");
+		}
+		
+		myLL.removeFirst();
+		assertEquals(9, myLL.size());
+
+		for(int i = 0; i < myLL.size(); i++) {
+			a = i+1 + "";
+			assertEquals(a, myLL.get(i));
+		}
+		
+		int size = myLL.size();
+		for(int i = 0; i < size; i++) {
+			a = i+1 +"";
+			result = myLL.removeFirst();
+			assertEquals(a, result);
+		}
+		
+		assertEquals(0, myLL.size());
+	}
+	
+	@Test
+	public void testRemoveLast() {
+		
+		String a = "";
+		String result = "";
+		for(int i = 0; i < 10; i++) {
+			myLL.add(i+"");
+		}
+		
+		myLL.removeLast();
+		assertEquals(9, myLL.size());
+
+		for(int i = 0; i < myLL.size(); i++) {
+			a = i + "";
+			assertEquals(a, myLL.get(i));
+		}
+		
+		int size = myLL.size();
+		for(int i = 0; i < size; i++) {
+			a = myLL.size()-1 +"";
+			result = myLL.removeLast();
+			assertEquals(a, result);
+		}
+		
+		assertEquals(0, myLL.size());
+		
+	}
+	
+
+	@Test
+	public void testRemove() {
+		
+		String res = "";
+		String a = "";
+		for(int i = 0; i < 10; i++) {
+			myLL.add(i+"");
+		}
+
+		for(int i = myLL.size()-1; i >= 0; i--) {
+			a = myLL.get(i);
+			res = myLL.remove(i);
+			assertEquals(i, myLL.size());
+			assertEquals(a,res);
+		}
+	}
+
+	@Test
+	public void testSize() {
+		assertEquals(0,myLL.size());
+	}
+
+	@Test
+	public void testIterator() {
+		for(int i = 0; i<10; i++) {
+			myLL.add(i+"");
+		}
+		Iterator<String> it = myLL.iterator();
+		
+		for(int i = 0; it.hasNext(); i++){
+			String res = it.next();
+			assertEquals(i+"",res);
+		}
+		
+	    try {
+			it.next();
+	    } catch (NoSuchElementException ex) {
+	        assertEquals(ex.getClass(),NoSuchElementException.class);
+	    }
+	}
+	
+
+}
diff --git a/group12/382266293/src/TestCollection/QueueTest.java b/group12/382266293/src/TestCollection/QueueTest.java
new file mode 100644
index 0000000000..01a9aa31f2
--- /dev/null
+++ b/group12/382266293/src/TestCollection/QueueTest.java
@@ -0,0 +1,98 @@
+package TestCollection;
+
+import static util.Print.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static util.TestUtil.*;
+import Collection.Concrete.Queue;
+import junit.framework.TestCase;
+
+public class QueueTest extends TestCase {
+
+	private Queue<Integer> myQueue;
+	
+	@Before
+	public void setUp() throws Exception {
+		myQueue= new Queue<Integer>();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		myQueue = null;
+	}
+
+	@Test
+	public void testIsEmpty() {
+		assertEquals(true, myQueue.isEmpty());
+		myQueue.enQueue(getRandomNumber());
+		assertEquals(false, myQueue.isEmpty());
+	}
+
+	@Test
+	public void testEnQueue() {
+
+		enQueueIntWithNatureOrder(myQueue, getRandomNumber());
+		
+	}
+
+	@Test
+	public void testDeQueue() {
+		enQueueIntWithNatureOrder(myQueue, getRandomNumber());
+		int size = myQueue.size();
+		for (int i = 0; i < size ; i++) {
+			assertEquals(size-i, myQueue.size());
+			int expect = i;
+			int actual = myQueue.deQueue();
+			assertEquals(expect, actual);
+		}
+		
+		assertEquals(null, myQueue.deQueue());
+		assertEquals(null, myQueue.element());
+		assertEquals(null, myQueue.get(0));
+
+	}
+
+	@Test
+	public void testelement() {
+		
+		int expected = 0;
+		int element1 = 0;
+		int repeated = 0;
+		
+		for (int i = 0; i < 10; i++) {
+			myQueue.enQueue(i);
+			expected = i;
+			
+			element1 = myQueue.element();
+			assertEquals(expected, element1);
+			
+			for (int j = 0; j < i; j++) {
+				repeated = myQueue.element();
+				assertEquals(expected, repeated);
+			}
+			myQueue.deQueue();
+		}
+		
+	}
+
+	@Test
+	public void testSize() {
+		for (int i = 0; i < 10000; i++) {
+			assertEquals(i, myQueue.size());
+			myQueue.enQueue(i);
+		}
+	}
+
+	@Test
+	public void testAdd() {
+		for (int i = 0; i < 10; i++) {
+			myQueue.add(i);
+			Integer actual = new Integer(myQueue.get(i));
+			Integer expected = new Integer(i);
+			assertEquals(expected, actual);
+		}
+	}
+
+
+}
diff --git a/group12/382266293/src/TestCollection/StackTest.java b/group12/382266293/src/TestCollection/StackTest.java
new file mode 100644
index 0000000000..3784a9b972
--- /dev/null
+++ b/group12/382266293/src/TestCollection/StackTest.java
@@ -0,0 +1,129 @@
+package TestCollection;
+
+import static util.Print.*;
+
+import java.util.EmptyStackException;
+import static util.TestUtil.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import Collection.Concrete.Stack;
+import junit.framework.TestCase;
+
+public class StackTest extends TestCase {
+
+	Stack<Integer> myStack;
+	
+	@Before
+	public void setUp() throws Exception {
+		myStack= new Stack<Integer>();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		myStack = null;
+	}
+
+	@Test
+	public void testIsEmpty() {
+		assertEquals(true, myStack.isEmpty());
+		myStack.push(getRandomNumber());
+		assertEquals(false, myStack.isEmpty());
+	}
+
+	@Test
+	public void testPush() {
+		for (int i = 0; i < 10; i++) {
+			assertEquals(i, myStack.size());
+			myStack.push(i);
+		}
+	}
+
+	@Test
+	public void testPop() {
+		testPush();
+		int size = myStack.size();
+		for (int i = size; i > 0; i--) {
+			assertEquals(i, myStack.size());
+			int expect = i-1;
+			assertEquals(i, myStack.size());
+			int actual = myStack.pop();
+			assertEquals(expect, actual);
+		}
+		
+		try {
+			myStack.pop();
+			fail("no exception throw");
+		} catch (Exception e) {
+			assertEquals(EmptyStackException.class, e.getClass());
+		}
+	}
+
+	@Test
+	public void testPeek() {
+		
+		int expected = 0;
+		int peek1 = 0;
+		int repeated = 0;
+		
+		for (int i = 0; i < 10; i++) {
+			myStack.push(i);
+			expected = i;
+			
+			peek1 = myStack.peek();
+			assertEquals(expected, peek1);
+			
+			for (int j = 0; j < i; j++) {
+				repeated = myStack.peek();
+				assertEquals(expected, repeated);
+			}
+		}
+		
+	}
+	
+	
+	public void testGet() {
+		
+		try {
+			myStack.get(getRandomNumber());
+			fail("no exception throw");
+		} catch (Exception e) {
+			assertEquals(EmptyStackException.class, e.getClass());
+		}
+		
+	}
+
+	@Test
+	public void testSize() {
+		for (int i = 0; i < 10000; i++) {
+			assertEquals(i, myStack.size());
+			myStack.push(i);
+		}
+	}
+
+	@Test
+	public void testAdd() {
+		myStack.push(5);
+		myStack.push(10);
+		myStack.push(15);
+		println(myStack.get(0));
+		println(myStack.get(1));
+		println(myStack.get(2));
+		
+	}
+
+	@Test
+	public void testPopPushAndPeek() {
+		for (int i = 0; i < 10; i++) {
+			int expected = i;
+			myStack.push(i);
+			int a = 0;
+			myStack.push(a);
+			myStack.pop();
+			int actual = myStack.peek();
+			assertEquals(expected, actual);
+		}
+	}
+
+}
diff --git a/group12/382266293/src/test.java b/group12/382266293/src/test.java
new file mode 100644
index 0000000000..e4e7fead2d
--- /dev/null
+++ b/group12/382266293/src/test.java
@@ -0,0 +1,15 @@
+import java.util.ArrayList;
+import java.util.Queue;
+import java.util.Stack;
+import java.util.concurrent.PriorityBlockingQueue;
+import static util.Print.*;
+
+public class test {
+
+	public static void main(String[] args) {
+		Queue queue =  new PriorityBlockingQueue();
+		println(queue.poll());
+
+	}
+
+}
diff --git a/group12/382266293/src/util/Print.java b/group12/382266293/src/util/Print.java
new file mode 100644
index 0000000000..b2ae48552b
--- /dev/null
+++ b/group12/382266293/src/util/Print.java
@@ -0,0 +1,14 @@
+package util;
+
+
+public class Print {
+	
+	public static void print(Object o){
+		System.out.print(o);
+	}
+	
+	public static void println(Object o){
+		System.out.println(o);
+	}
+
+}
diff --git a/group12/382266293/src/util/TestUtil.java b/group12/382266293/src/util/TestUtil.java
new file mode 100644
index 0000000000..2dfeeade7f
--- /dev/null
+++ b/group12/382266293/src/util/TestUtil.java
@@ -0,0 +1,78 @@
+package util;
+
+import java.util.Random;
+
+import Collection.List;
+import Collection.Concrete.ArrayList;
+import Collection.Concrete.LinkedList;
+import Collection.Concrete.Queue;
+import junit.framework.TestCase;
+
+
+public class TestUtil<E> extends TestCase {
+	
+	private static Random random = new Random();
+	private static final int RANDOM_BOUND = 2<<15;
+	private static final int RANDOM_SIZE = 500;
+	
+	
+	public static int getRandomNumber() {
+		return random.nextInt(RANDOM_SIZE);
+	}
+	
+	public static void addIntWithNatureOrder(List<Integer> myList, int numbers) {
+		
+		for (int acutal = 0; acutal < numbers ; acutal++) {
+			myList.add(acutal);
+		}
+	}
+	
+	public static int[] addRandomInt(List<Integer> myList, int numbers) {
+		
+		int actual = 0;
+		int[] result = new int[numbers];
+		for (int i = 0; i < numbers ; i++) {
+			actual = random.nextInt(RANDOM_BOUND);
+			result[i] = actual;
+			myList.add(actual);
+		}
+		return result;
+	}
+
+	public static void addString(List<String> myList, int num) {
+		
+		String actual;
+		for (int index = 0; index < num ; index++) {
+			actual = index + "";
+			myList.add(actual);
+		}
+	}
+	
+	public static <E> void testRemoveAndGetFromTail(ArrayList<E> myList) {
+		E get;
+		E remove;
+		for(int i = myList.size()-1; i >= 0; i--) {
+			get = myList.get(i);
+			remove = myList.remove(i);
+			assertEquals(get,remove);
+		}
+	}
+	
+	public static <E> void testRemoveAndGetFromTail(LinkedList<E> myList) {
+		E get;
+		E remove;
+		for(int i = myList.size()-1; i >= 0; i--) {
+			get = myList.get(i);
+			remove = myList.remove(i);
+			assertEquals(get,remove);
+		}
+	}
+
+	public static void enQueueIntWithNatureOrder(Queue<Integer> myQueue, int numbers) {
+		
+		for (int acutal = 0; acutal < numbers ; acutal++) {
+			myQueue.enQueue(acutal);
+		}
+	}
+	
+}
diff --git a/group12/441908378/ArrayList.java b/group12/441908378/ArrayList.java
new file mode 100755
index 0000000000..45e495867c
--- /dev/null
+++ b/group12/441908378/ArrayList.java
@@ -0,0 +1,50 @@
+import java.util.Arrays;
+
+public class ArrayList  {
+
+private int size = 0;
+
+private Object[] elementData = new Object[100];
+
+public void enlargeCapacity(int minCapacity){
+	int oldCapacity=elementData.length;
+	if(oldCapacity<minCapacity){
+		oldCapacity=(oldCapacity*3)/2+1;
+	}
+}
+
+public void add(Object o){
+ 	enlargeCapacity(elementData.length+1);
+ 	elementData[elementData.length+1]=o;
+}
+public void add(int index, Object o){
+	enlargeCapacity(elementData.length+1);
+	Object data[]= Arrays.copyOfRange(elementData, index, elementData.length);
+	elementData[index] = o;
+	System.arraycopy(data, 0, elementData, index+1, elementData.length);
+	
+}
+
+public Object get(int index){
+	Object o;
+	o=elementData[index];
+	return o;
+}
+
+public Object remove(int index){
+	Object o;
+	o=elementData[index];
+	Object data[]= Arrays.copyOfRange(elementData, index+1, elementData.length);
+	System.arraycopy(data, 0, elementData, index, elementData.length);
+	return o;
+}
+
+public int size(){
+ return size;
+}
+
+//public Iterator iterator(){
+//return null;
+//}
+
+}
diff --git a/group12/441908378/BinaryTreeNode.java b/group12/441908378/BinaryTreeNode.java
new file mode 100755
index 0000000000..972af1eec6
--- /dev/null
+++ b/group12/441908378/BinaryTreeNode.java
@@ -0,0 +1,47 @@
+
+public class BinaryTreeNode {
+
+	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){
+		BinaryTreeNode node;
+		do{
+			node=compare(o);
+		}while(node==null);
+		node.data=o;
+		return  node;
+	}
+	
+	public BinaryTreeNode compare(Object o){
+		int a=(Integer)data;
+		int b=(Integer)o;
+		if(a>b){
+			return left;
+		}else{
+			return right;
+		}
+	}
+	
+
+}
diff --git a/group12/441908378/LinkedList.java b/group12/441908378/LinkedList.java
new file mode 100755
index 0000000000..0d0339bc01
--- /dev/null
+++ b/group12/441908378/LinkedList.java
@@ -0,0 +1,121 @@
+public class LinkedList  {
+
+private Node head;
+
+private static  class Node{
+	Object data;
+	Node next;
+}
+
+public boolean hasNext(Node a){
+	if(a.next!=null){
+		return true;
+	}
+	return false;
+}
+
+public Node getIndex(int index){
+	Node a=head.next;
+	for(int i=0;i<index;i++){
+		a=a.next;
+	}
+	return a;
+}
+
+public void add(Object o){
+	Node a;
+	if(!hasNext(head)){
+		a=head.next;
+		a.data=o;
+		}else{
+			a=head.next;
+			while(a.next!=null){
+				a=a.next;
+			}
+			a=a.next;
+			a.data=o;
+		}
+}
+
+
+public void add(int index , Object o){
+	Node a=getIndex(index);
+	Node b=null;
+	b.data=o;
+	b.next=a.next;
+	a.next=b;	
+}
+public Object get(int index){
+	Object o;
+	Node a=getIndex(index);
+	o=a.data;
+	return o;
+}
+public Object remove(int index){
+	Node a=getIndex(index-1);
+	Node b=a.next;
+	Object c=b.data;
+	a.next=b.next;
+	b.next=null;
+	return c;
+}
+
+public int size(){
+	Node a=head.next;
+	int i=0;
+	while(a.next==null){
+		a=a.next;
+		i++;
+	}
+	return i;
+}
+
+public void addFirst(Object o){
+	Node a=null;
+	a.data=o;
+	Node b=head.next;
+	a.next=b;
+	head.next=a;
+}
+public void addLast(Object o){
+	Node a;
+	if(!hasNext(head)){
+		a=head.next;
+		a.data=o;
+		}else{
+			a=head.next;
+			while(a.next!=null){
+				a=a.next;
+			}
+			a=a.next;
+			a.data=o;
+		}
+}
+public Object removeFirst(){
+	Node a=head.next;
+	Node b=a.next;
+	Object c=a.data;
+	head.next=b;
+	a.next=null;
+	return c;
+}
+public Object removeLast(){
+	Node a=head.next;
+	while(a.next.next!=null){
+		a=a.next;
+	};
+	Object b=a.next.data;
+	a.next=null;
+	return b;
+	
+}
+
+
+//public Iterator iterator(){
+//return null;
+//}
+
+
+
+
+}
diff --git a/group12/441908378/Queue.java b/group12/441908378/Queue.java
new file mode 100755
index 0000000000..1485b891a6
--- /dev/null
+++ b/group12/441908378/Queue.java
@@ -0,0 +1,39 @@
+import java.util.Arrays;
+
+
+public class Queue {
+
+	
+	private int size = 0;
+
+	private Object[] elementData = new Object[100];
+	
+	public void enlargeCapacity(int minCapacity){
+		int oldCapacity=elementData.length;
+		if(oldCapacity<minCapacity){
+			oldCapacity=(oldCapacity*3)/2+1;
+		}
+	}
+	
+	public void enQueue(Object o){		
+		enlargeCapacity(elementData.length+1);
+	 	elementData[elementData.length+1]=o;
+	}
+	
+	public Object deQueue(){
+		Object a = elementData[0];
+		elementData=Arrays.copyOfRange(elementData, 1, elementData.length);
+		return null;
+	}
+	
+	public boolean isEmpty(){
+		if(elementData.length==0){
+		return true;
+		}
+		return false;
+	}
+	
+	public int size(){
+		return elementData.length;
+	}
+}
diff --git a/group12/441908378/Stack.java b/group12/441908378/Stack.java
new file mode 100755
index 0000000000..acfec33cd1
--- /dev/null
+++ b/group12/441908378/Stack.java
@@ -0,0 +1,30 @@
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+
+	private int size = 0;
+
+	public void push(Object o){		
+	elementData.add(o);
+	}
+	
+	public Object pop(){
+		Object o=elementData.get(elementData.size());
+		elementData.remove(elementData.size());
+		return o;
+	}
+	
+	public Object peek(){
+		Object o=elementData.get(elementData.size());
+		return o;
+	}
+	public boolean isEmpty(){
+		if(elementData.size()==0){
+			return true;
+		}
+		return false;
+	}
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group12/446031103/src/com/coding/basic/ArrayList.java b/group12/446031103/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..c627a7d2fa
--- /dev/null
+++ b/group12/446031103/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,121 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+/**
+ * 
+ * arrayList集合-数组
+ * 
+ * @ClassName ArrayList
+ * @author msh
+ * @date 2017年2月21日 下午3:49:24
+ */
+public class ArrayList implements List {
+	// 记录ArrayList集合大小
+	private int size = 0;
+	// 初始化存储数组
+	private Object[] elementData = new Object[100];
+	/**
+	 * 
+	 * 向最后插入元素 
+	 *
+	 * @Method add 添加
+	 * @param o 元素
+	 * @see com.coding.basic.List#add(java.lang.Object)
+	 */
+	public void add(Object o){
+		// 数组不够时增长
+		growOrNot(size + 1);
+		elementData[size] = o;
+		++size;
+	}
+	/**
+	 * 
+	 * 向指定位置插入元素 
+	 *
+	 * @Method add 添加
+	 * @param index 下标
+	 * @param o 元素
+	 * @see com.coding.basic.List#add(int, java.lang.Object)
+	 */
+	public void add(int index, Object o){
+		validate(index);
+		growOrNot(size + 1);
+		System.arraycopy(elementData, index, elementData, index + 1, size - index);
+		elementData[index] = o;
+		++size;
+	}
+	/**
+	 * 
+	 * 取得元素 
+	 *
+	 * @Method get 取得
+	 * @param index 下标
+	 * @return
+	 * @see com.coding.basic.List#get(int)
+	 */
+	public Object get(int index){
+		validate(index);
+		return elementData[index];
+	}
+	/**
+	 * 
+	 * 删除元素 
+	 *
+	 * @Method remove 删除
+	 * @param index 下标
+	 * @return 删除的元素
+	 * @see com.coding.basic.List#remove(int)
+	 */
+	public Object remove(int index){
+		Object oldValue = elementData[index];
+		validate(index);
+		System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
+		elementData[size] = null;
+		--size;
+		return oldValue;
+	}
+	/**
+	 * 
+	 * 取得集合大小 
+	 *
+	 * @Method size 集合大小
+	 * @return 集合大小
+	 * @see com.coding.basic.List#size()
+	 */
+	public int size(){
+		return size;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+	/**
+	 * 
+	 * 判断是否需要增长数组 
+	 *
+	 * @MethodName growOrNot
+	 * @author msh
+	 * @date 2017年2月21日 下午3:53:29
+	 * @param minCapacity
+	 */
+	private void growOrNot(int minCapacity) {
+		// 当增加长度大于数组长度时，增长
+		if (minCapacity > elementData.length) {
+			elementData = Arrays.copyOf(elementData, elementData.length * 2);
+		}
+	}
+	/**
+	 * 
+	 * 验证 
+	 *
+	 * @MethodName validate 下标
+	 * @author msh
+	 * @date 2017年2月21日 下午3:54:21
+	 * @param index
+	 */
+	private void validate(int index) {
+		if (index < 0 || index >= size)
+			throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+	}
+}
diff --git a/group12/446031103/src/com/coding/basic/BinaryTreeNode.java b/group12/446031103/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..ed26d946bb
--- /dev/null
+++ b/group12/446031103/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,44 @@
+package com.coding.basic;
+
+
+public class BinaryTreeNode {
+	private Object data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+	private BinaryTreeNode( Object data,BinaryTreeNode left,BinaryTreeNode right){
+		this.data = data;
+		this.left = left;
+		this.right = 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(BinaryTreeNode tree,Object o){
+		if(null== tree){
+			tree = new BinaryTreeNode(o, null, null);
+		}
+		if(Integer.valueOf(o.toString())>Integer.valueOf(tree.data.toString())){
+			tree.right =insert(tree.right,o);
+		}else{
+			tree.left = insert(tree.left,o);
+		}
+		return  tree;
+	}
+	
+}
diff --git a/group12/446031103/src/com/coding/basic/Iterator.java b/group12/446031103/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..06ef6311b2
--- /dev/null
+++ b/group12/446031103/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/group12/446031103/src/com/coding/basic/LinkedList.java b/group12/446031103/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..de508694a0
--- /dev/null
+++ b/group12/446031103/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,225 @@
+package com.coding.basic;
+
+/**
+ * 
+ * LinkedList集合-链
+ * 
+ * @ClassName LinkedList
+ * @author msh
+ * @date 2017年2月21日 下午4:08:01
+ */
+public class LinkedList implements List {
+	//链头
+	private Node head;
+	//集合大小
+	private int size=0;
+	/**
+	 * 
+	 * 向链中添加元素
+	 *
+	 * @Method add 添加
+	 * @param o 元素
+	 * @see com.coding.basic.List#add(java.lang.Object)
+	 */
+	public void add(Object o){
+		Node newNode = new Node(o, null);
+		if (null == head) {
+			head = newNode;
+		} else {
+			Node lastNode = null;
+			for (int i = 0; i < size; i++) {
+				lastNode = (Node) get(i);
+			}
+			lastNode.next = newNode;
+		}
+		size++;
+	}
+	/**
+	 * 
+	 * 向链中添加元素 
+	 *
+	 * @Method add 增加
+	 * @param index 下标
+	 * @param o 元素
+	 * @see com.coding.basic.List#add(int, java.lang.Object)
+	 */
+	public void add(int index , Object o){
+		validate(index);
+		Node newNode = null;
+		Node perNode = null;
+		Node nextNode = null;
+		// 当为最后插入时
+		if (index == size - 1) {
+			newNode = new Node(o, null);
+			for (int i = 0; i < index; i++) {
+				Node tempNode = (Node) get(i);
+				perNode = tempNode.next;
+			}
+			perNode.next = newNode;
+		} else if (0 == index) {
+			nextNode = head.next;
+			newNode = new Node(o, nextNode);
+			head = newNode;
+		} else {
+			for (int i = 0; i < index; i++) {
+				Node tempNode = (Node) get(i);
+				perNode = tempNode.next;
+			}
+			nextNode = perNode.next.next;
+			newNode = new Node(o, nextNode);
+			perNode.next = newNode;
+		}
+		size++;
+	}
+	/**
+	 * 
+	 * 取得元素 
+	 *
+	 * @Method get 取得
+	 * @param index 下标
+	 * @return
+	 * @see com.coding.basic.List#get(int)
+	 */
+	public Object get(int index){
+		validate(index);
+		Node tempNode = head;	
+		for (int i = 0; i <= index; i++) {
+			tempNode = tempNode.next;
+		}
+		return tempNode;
+	}
+	/**
+	 * 
+	 * 删除元素
+	 *
+	 * @Method remove 删除
+	 * @param index 下标
+	 * @return
+	 * @see com.coding.basic.List#remove(int)
+	 */
+	public Object remove(int index){
+		Node removeNode = (Node) get(index);
+		validate(index);
+		if (index == size - 1) {
+			Node tempNode = head;
+			for (int i = 0; i < index; i++) {
+				tempNode = tempNode.next;
+			}
+			tempNode.next = null;
+		} else if (index == 0) {
+			Node tempNode = head.next;
+			head.next = null;
+			head = tempNode;
+		} else {
+		}
+		size--;
+		return removeNode;
+	}
+	/**
+	 * 
+	 * 取得集合大小 
+	 *
+	 * @Method size 集合大小
+	 * @return 集合大小
+	 * @see com.coding.basic.List#size()
+	 */
+	public int size(){
+		return size;
+	}
+	/**
+	 * 
+	 * 想链头中插入元素
+	 *
+	 * @MethodName addFirst
+	 * @author msh
+	 * @date 2017年2月21日 下午4:10:56
+	 * @param o
+	 */
+	public void addFirst(Object o){
+		Node newNode = new Node(o, head);
+		head = newNode;
+	}
+	/**
+	 * 
+	 * 向链后加入元素 
+	 *
+	 * @MethodName addLast
+	 * @author msh
+	 * @date 2017年2月21日 下午4:11:43
+	 * @param o
+	 */
+	public void addLast(Object o){
+		add(o);
+	}
+	/**
+	 * 
+	 * 删除链头 
+	 *
+	 * @MethodName removeFirst
+	 * @author msh
+	 * @date 2017年2月21日 下午4:12:14
+	 * @return
+	 */
+	public Object removeFirst(){
+		if(null==head)
+			throw new IndexOutOfBoundsException("Size: " + size);
+		Node orgHead = head;
+		Node tempNode = head.next;
+		head.next = null;
+		head = tempNode;
+		return orgHead;
+	}
+	/**
+	 * 
+	 * 删除链尾
+	 *
+	 * @MethodName removeLast
+	 * @author zhaogd
+	 * @date 2017年2月21日 下午4:12:44
+	 * @return
+	 */
+	public Object removeLast(){
+		if(null==head)
+			throw new IndexOutOfBoundsException("Size: " + size);
+		Node lastNode = (Node) get(size);
+		Node tempNode = head;
+		for (int i = 0; i < (size - 1); i++) {
+			tempNode = tempNode.next;
+		}
+		tempNode.next = null;
+		return lastNode;
+	}
+	public Iterator iterator(){
+		return null;
+	}
+	
+	/**
+	 * 
+	 * 验证 
+	 *
+	 * @MethodName validate 下标
+	 * @author msh
+	 * @date 2017年2月21日 下午3:54:21
+	 * @param index
+	 */
+	private void validate(int index) {
+		if (index < 0 || index >= size)
+			throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+	}
+	/**
+	 * 
+	 * 链中元素
+	 * 
+	 * @ClassName Node
+	 * @author zhaogd
+	 * @date 2017年2月21日 下午4:13:10
+	 */
+	private static  class Node{
+		Object data;
+		Node next;
+		public Node(Object data, Node next) {
+			this.data = data;
+			this.next = next;
+		}
+	}
+}
diff --git a/group12/446031103/src/com/coding/basic/List.java b/group12/446031103/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ b/group12/446031103/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/group12/446031103/src/com/coding/basic/Queue.java b/group12/446031103/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..3844d9dd24
--- /dev/null
+++ b/group12/446031103/src/com/coding/basic/Queue.java
@@ -0,0 +1,68 @@
+package com.coding.basic;
+
+/**
+ * 
+ * 队列-先进先出
+ * 
+ * @ClassName Queue
+ * @author msh
+ * @date 2017年2月21日 下午9:29:03
+ */
+public class Queue {
+	private LinkedList elementData = new LinkedList();
+	/**
+	 * 
+	 * 入队列
+	 *
+	 * @MethodName enQueue
+	 * @author msh
+	 * @date 2017年2月21日 下午9:45:15
+	 * @param o
+	 */
+	public void enQueue(Object o){		
+		elementData.add(o);
+	}
+	/**
+	 * 
+	 * 离开队列
+	 *
+	 * @MethodName deQueue
+	 * @author msh
+	 * @date 2017年2月21日 下午9:56:06
+	 * @return
+	 */
+	public Object deQueue(){
+		if(isEmpty())
+			throw new IndexOutOfBoundsException("size："+size());
+		Object o=elementData.get(0);
+		elementData.removeFirst();
+		return o;
+	}
+	/**
+	 * 
+	 * 是否为空
+	 *
+	 * @MethodName isEmpty
+	 * @author msh
+	 * @date 2017年2月21日 下午9:57:14
+	 * @return
+	 */
+	public boolean isEmpty(){
+		boolean temp = false;
+		if(0==elementData.size())
+			temp= true;
+		return temp;
+	}
+	/**
+	 * 
+	 * 队列中元素
+	 *
+	 * @MethodName size
+	 * @author msh
+	 * @date 2017年2月21日 下午9:57:28
+	 * @return
+	 */
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group12/446031103/src/com/coding/basic/Stack.java b/group12/446031103/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..4d1c58b671
--- /dev/null
+++ b/group12/446031103/src/com/coding/basic/Stack.java
@@ -0,0 +1,81 @@
+package com.coding.basic;
+
+/**
+ * 
+ * 栈-先进后出
+ * 
+ * @ClassName Stack
+ * @author msh
+ * @date 2017年2月21日 下午9:05:39
+ */
+public class Stack {
+	
+	private ArrayList elementData = new ArrayList();
+	/**
+	 * 
+	 * 向栈中加入元素
+	 *
+	 * @MethodName push
+	 * @author msh
+	 * @date 2017年2月21日 下午9:12:03
+	 * @param o
+	 */
+	public void push(Object o){		
+		elementData.add(o);
+	}
+	/**
+	 * 
+	 * 从栈中取出元素
+	 *
+	 * @MethodName pop
+	 * @author msh
+	 * @date 2017年2月21日 下午9:12:51
+	 * @return
+	 */
+	public Object pop(){	
+		Object o= peek();
+		elementData.remove(size()-1);
+		return o;
+	}
+	/**
+	 * 
+	 * 取出栈顶元素
+	 *
+	 * @MethodName peek
+	 * @author msh
+	 * @date 2017年2月21日 下午9:13:08
+	 * @return
+	 */
+	public Object peek(){
+		Object o=elementData.get(size()-1);		
+		return o;
+	}
+	/**
+	 * 
+	 * 判断栈中是否有元素
+	 *
+	 * @MethodName isEmpty
+	 * @author msh
+	 * @date 2017年2月21日 下午9:14:26
+	 * @return
+	 */
+	public boolean isEmpty(){
+		boolean temp = false;
+		if(0==size())
+			temp = true;
+		return temp;
+	}
+	/**
+	 * 
+	 * 栈中有多少元素
+	 *
+	 * @MethodName size
+	 * @author msh
+	 * @date 2017年2月21日 下午9:16:42
+	 * @return
+	 */
+	public int size(){
+		return elementData.size();
+	}
+	
+}
diff --git a/group12/495473393/Coding/.gitignore b/group12/495473393/Coding/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group12/495473393/Coding/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group12/495473393/Coding/src/Base/ArrayList.java b/group12/495473393/Coding/src/Base/ArrayList.java
new file mode 100644
index 0000000000..0b99f87873
--- /dev/null
+++ b/group12/495473393/Coding/src/Base/ArrayList.java
@@ -0,0 +1,32 @@
+package Base;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[100];
+	
+	public void add(Object o){
+		
+	}
+	public void add(int index, Object o){
+		
+	}
+	
+	public Object get(int index){
+		return null;
+	}
+	
+	public Object remove(int index){
+		return null;
+	}
+	
+	public int size(){
+		return -1;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+	
+}
diff --git a/group12/495473393/Coding/src/Base/BinaryTreeNode.java b/group12/495473393/Coding/src/Base/BinaryTreeNode.java
new file mode 100644
index 0000000000..875abe8c80
--- /dev/null
+++ b/group12/495473393/Coding/src/Base/BinaryTreeNode.java
@@ -0,0 +1,32 @@
+package Base;
+
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git a/group12/495473393/Coding/src/Base/Iterator.java b/group12/495473393/Coding/src/Base/Iterator.java
new file mode 100644
index 0000000000..19b65c3637
--- /dev/null
+++ b/group12/495473393/Coding/src/Base/Iterator.java
@@ -0,0 +1,7 @@
+package Base;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group12/495473393/Coding/src/Base/LinkedList.java b/group12/495473393/Coding/src/Base/LinkedList.java
new file mode 100644
index 0000000000..0d4ce20167
--- /dev/null
+++ b/group12/495473393/Coding/src/Base/LinkedList.java
@@ -0,0 +1,46 @@
+package Base;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	
+	public void add(Object o){
+		
+	}
+	public void add(int index , Object o){
+		
+	}
+	public Object get(int index){
+		return null;
+	}
+	public Object remove(int index){
+		return null;
+	}
+	
+	public int size(){
+		return -1;
+	}
+	
+	public void addFirst(Object o){
+		
+	}
+	public void addLast(Object o){
+		
+	}
+	public Object removeFirst(){
+		return null;
+	}
+	public Object removeLast(){
+		return null;
+	}
+	public Iterator iterator(){
+		return null;
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		
+	}
+}
diff --git a/group12/495473393/Coding/src/Base/List.java b/group12/495473393/Coding/src/Base/List.java
new file mode 100644
index 0000000000..6c910af600
--- /dev/null
+++ b/group12/495473393/Coding/src/Base/List.java
@@ -0,0 +1,9 @@
+package Base;
+
+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/group12/495473393/Coding/src/Base/Queue.java b/group12/495473393/Coding/src/Base/Queue.java
new file mode 100644
index 0000000000..9c2948d7e3
--- /dev/null
+++ b/group12/495473393/Coding/src/Base/Queue.java
@@ -0,0 +1,19 @@
+package Base;
+
+public class Queue {
+	
+	public void enQueue(Object o){		
+	}
+	
+	public Object deQueue(){
+		return null;
+	}
+	
+	public boolean isEmpty(){
+		return false;
+	}
+	
+	public int size(){
+		return -1;
+	}
+}
diff --git a/group12/495473393/Coding/src/Base/Stack.java b/group12/495473393/Coding/src/Base/Stack.java
new file mode 100644
index 0000000000..8f59343d4b
--- /dev/null
+++ b/group12/495473393/Coding/src/Base/Stack.java
@@ -0,0 +1,22 @@
+package Base;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){		
+	}
+	
+	public Object pop(){
+		return null;
+	}
+	
+	public Object peek(){
+		return null;
+	}
+	public boolean isEmpty(){
+		return false;
+	}
+	public int size(){
+		return -1;
+	}
+}
diff --git a/group12/563253496/datastructure/.classpath b/group12/563253496/datastructure/.classpath
new file mode 100644
index 0000000000..fb5011632c
--- /dev/null
+++ b/group12/563253496/datastructure/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group12/563253496/datastructure/.gitignore b/group12/563253496/datastructure/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group12/563253496/datastructure/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group12/563253496/datastructure/.project b/group12/563253496/datastructure/.project
new file mode 100644
index 0000000000..4ae7fd9359
--- /dev/null
+++ b/group12/563253496/datastructure/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>datastructure</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group12/563253496/datastructure/src/Collection/ArrayList.java b/group12/563253496/datastructure/src/Collection/ArrayList.java
new file mode 100644
index 0000000000..597a9b1a3a
--- /dev/null
+++ b/group12/563253496/datastructure/src/Collection/ArrayList.java
@@ -0,0 +1,173 @@
+package Collection;
+
+import com.coding.basic.List;
+
+import java.util.NoSuchElementException;
+
+import com.coding.basic.Iterator;
+
+public class ArrayList implements List {
+
+    private int size;
+    private Object[] elementData;
+
+    public ArrayList() {
+        size = 0;
+        elementData = new Object[10];
+    }
+
+    public ArrayList(Object o) {
+        size = 0;
+        elementData = new Object[10];
+        this.add(o);
+    }
+
+    public ArrayList(int initialCapacity) {
+        size = 0;
+        elementData = new Object[initialCapacity];
+    }
+
+    @Override
+    public void add(Object o) {
+        if (size <= elementData.length - 1) {
+            elementData[size] = o;
+            size++;
+        } else {
+            this.extendCapacity();
+            elementData[size] = o;
+            size++;
+
+        }
+    }
+
+    @Override
+    public void add(int index, Object o) {
+        if (index < 0) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (index > elementData.length - 1) {
+            while (index > elementData.length - 1) {
+                this.extendCapacity();
+            }
+            elementData[index] = o;
+            size = index + 1;
+            return;
+        }
+
+        if (index >= size) {
+            size = index + 1;
+            elementData[index] = o;
+            return;
+        }
+        if (index >= 0 && index < size) {
+            this.moveRearward(index);
+            elementData[index] = o;
+            size++;
+            return;
+        }
+    }
+
+    @Override
+    public Object get(int index) {
+        checkCapacity(index);
+        if (index < size) {
+            return elementData[index];
+        }
+        return null;
+    }
+
+    @Override
+    public Object remove(int index) {
+        checkCapacity(index);
+
+        if (index == size - 1) {
+            size--;
+            return elementData[size - 1];
+        }
+        if (index < size - 1) {
+            Object tmp = elementData[index];
+            for (int i = index; i < size - 1; i++) {
+                elementData[i] = elementData[i + 1];
+            }
+            size--;
+            return tmp;
+        }
+        return null;
+    }
+
+    private void checkCapacity(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+    }
+
+    private void extendCapacity() {
+        Object[] elements = new Object[elementData.length + 10];
+        for (int i = 0; i < size; i++) {
+            elements[i] = elementData[i];
+        }
+        elementData = elements;
+
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[");
+        for (int i = 0; i < size; i++) {
+            sb.append(elementData[i]);
+            sb.append(",");
+        }
+        sb.deleteCharAt(sb.length() - 1);
+        sb.append("]");
+        return sb.toString();
+    }
+
+    private void moveRearward(int index) {
+        size++;
+
+        if (size >= elementData.length - 1)
+            this.extendCapacity();
+
+        for (int i = size - 1; i > index; i--) {
+            elementData[i] = elementData[i - 1];
+        }
+    }
+
+    public Iterator iterator() {
+        return new ArrayListIterator();
+    }
+
+    private class ArrayListIterator implements Iterator {
+
+        private int pos;
+
+        public ArrayListIterator() {
+
+            pos = 0;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (pos < size) {
+                return true;
+            }
+            return false;
+        }
+
+        @Override
+        public Object next() {
+            if (hasNext()) {
+                return elementData[pos++];
+            } else
+                throw new NoSuchElementException();
+
+        }
+
+    }
+
+}
diff --git a/group12/563253496/datastructure/src/Collection/LinkedList.java b/group12/563253496/datastructure/src/Collection/LinkedList.java
new file mode 100644
index 0000000000..94aefb188e
--- /dev/null
+++ b/group12/563253496/datastructure/src/Collection/LinkedList.java
@@ -0,0 +1,227 @@
+package Collection;
+
+import com.coding.basic.List;
+import com.coding.basic.Iterator;
+
+public class LinkedList implements List {
+
+	public  Node head;
+	public  int size;
+
+	public LinkedList() {
+		head = new Node();
+		size = 0;
+	}
+
+	public LinkedList(Object o) {
+		head = new Node(o);
+		size = 1;
+	}
+
+	public void add(Object o) {
+		if (size == 0) {
+			addfirst(o);
+			return;
+		}
+		addlast(o);
+	}
+
+	public void add(int index, Object o) {
+		this.checkCapacity(index);
+		if (index == 0) {
+			addfirst(o);
+			return;
+		}
+		if (index == size) {
+			addlast(o);
+			return;
+		}
+		addmid(index, o);
+	}
+
+	public void checkCapacity(int index) {
+		if (index > size || index < 0) {
+			throw new IndexOutOfBoundsException();
+		}
+	}
+
+	public void addfirst(Object o) {
+		Node tmp = new Node(head);
+		head.data = o;
+		head.next = tmp;
+		size++;
+	}
+
+	public void addlast(Object o) {
+		Node tmp = new Node(head);
+		//Node last = new Node(o);
+		//last.data=o;
+		for (int i = 0; i < size-1; i++) {
+			tmp = tmp.next;
+		}
+
+		tmp.next = new Node(o);
+		size++;
+
+	}
+
+	public void addmid(int index, Object o) {
+		Node tmp = new Node(head);
+		Node add = new Node(o);
+		for (int i = 0; i < index - 1; i++) {
+			tmp = tmp.next;
+		}
+		add.next = tmp.next;
+		tmp.next = add;
+		size++;
+	}
+
+	public Object get(int index) {
+		checkCapacity(index);
+		Node tmp = new Node(head);
+		if (index == 0) {
+			return head;
+		}
+		for (int i = 0; i < index - 1; i++) {
+			tmp = tmp.next;
+		}
+		return tmp.next;
+	}
+
+	public Object remove(int index) {
+		checkCapacity(index);
+		Node tmp = new Node(head);
+		if (index == 0) {
+			return removeFirst();
+		}
+		for (int i = 0; i < index - 1; i++) {
+			tmp = tmp.next;
+		}
+		Node result = new Node(tmp.next);
+		tmp.next = result.next;
+		return result;
+	}
+
+	public int size() {
+		return this.size;
+	}
+
+	public Object removeFirst() {
+		Node tmp = new Node(head);
+		head = head.next;
+		return tmp;
+	}
+
+	public Object removeLast() {
+		if (size == 0) {
+			return null;
+		}
+		if (size == 1) {
+			Node tmp = new Node(head);
+			head = null;
+			return tmp;
+		}
+		Node tmp = new Node(head);
+		for (int i = 0; i < size - 2; i++) {
+			tmp = tmp.next;
+		}
+		Node result = new Node(tmp.next);
+		tmp.next = result.next;
+		return result;
+	}
+
+	public String toString(){
+		StringBuilder sb= new StringBuilder();
+		sb.append("[");
+		Node tmp=new Node(head);
+		for(int i=0;i<size;i++){
+			Object o =tmp.data;
+			sb.append(o.toString());
+			sb.append(",");
+			tmp=tmp.next;
+		}
+		sb.deleteCharAt(sb.length()-1);
+		sb.append("]");
+		return sb.toString();
+	}
+	
+	public Iterator iterator() {
+		LinkedListIterator lli = new LinkedListIterator(this);
+		return lli;
+	}
+
+	private class LinkedListIterator implements Iterator {
+
+		private Node pos = new Node();
+
+		public LinkedListIterator(LinkedList ll) {
+			pos = ll.head;
+		}
+
+		@Override
+		public boolean hasNext() {
+			if (pos.next != null) {
+				return true;
+			}
+			return false;
+		}
+
+		@Override
+		public Object next() {
+			if (hasNext()) {
+				pos = pos.next;
+				return pos;
+			}
+			return null;
+		}
+
+	}
+
+	private static class Node {
+		 Object data;
+		 Node next;
+
+		public Node() {
+			this.data = null;
+			this.next = null;
+		}
+
+		public Node(Node n) {
+			this.data = n.data;
+			this.next = n.next;
+		}
+
+		public Node(Object o) {
+			this.data = o;
+			this.next = null;
+		}
+
+		public int hashCode() {
+			int result = 17;
+			int c = this.data == null ? 0 : this.data.hashCode();
+			return result = result * 37 + c;
+		}
+
+		public boolean equals(Object obj) {
+
+			if (obj == null) {
+				return false;
+			}
+			if (!(obj instanceof Node)) {
+				return false;
+			} else {
+				Node node = (Node) obj;
+				if (node.data.equals(data)) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+		public String toString(){
+			return "data:"+data+"   next:"+next;
+		}
+
+	}
+
+}
diff --git a/group12/563253496/datastructure/src/Collection/Queue.java b/group12/563253496/datastructure/src/Collection/Queue.java
new file mode 100644
index 0000000000..030d3970b5
--- /dev/null
+++ b/group12/563253496/datastructure/src/Collection/Queue.java
@@ -0,0 +1,44 @@
+package Collection;
+
+public class Queue {
+	private LinkedList linkedList;
+	private int size;
+
+	public Queue(Object o) {
+		linkedList = new LinkedList(o);
+		size = 1;
+	}
+
+	public Queue() {
+		linkedList = new LinkedList();
+		size = 0;
+	}
+
+	public void enQueue(Object o) {
+		linkedList.add(o);
+		size++;
+	}
+
+	private void checkCapacity(){
+		if(size<=0){
+			throw new IndexOutOfBoundsException();
+		}
+	}
+	public Object deQueue() {
+		checkCapacity();
+		Object o = linkedList.removeFirst();
+		size--;
+		return o;
+	}
+
+	public boolean isEmpty() {
+		if(size==0){
+			return true;
+		}
+		return false;
+	}
+
+	public int size() {
+		return size;
+	}
+}
diff --git a/group12/563253496/datastructure/src/Collection/Stack.java b/group12/563253496/datastructure/src/Collection/Stack.java
new file mode 100644
index 0000000000..545159206f
--- /dev/null
+++ b/group12/563253496/datastructure/src/Collection/Stack.java
@@ -0,0 +1,55 @@
+package Collection;
+
+
+public class Stack {
+	private ArrayList elementData;
+	private int size;
+
+	public Stack(Object o) {
+		elementData = new ArrayList(o);
+		size = 1;
+	}
+
+	public Stack() {
+		elementData = new ArrayList();
+		size = 0;
+	}
+
+	public void push(Object o) {
+		elementData.add(o);
+		size++;
+	}
+
+	private void checkCapacity(){
+		if(size<=0||size>elementData.size()){
+			throw new IndexOutOfBoundsException();
+		}
+	}
+	public Object pop(){
+		checkCapacity();
+		Object o = elementData.remove(size-1);
+		size--;
+		return o;
+	}
+
+	public Object peek() {
+		checkCapacity();
+		Object o = elementData.get(size-1);
+		return o;
+	}
+
+	public boolean isEmpty() {
+		if(size!=0){
+			return true;
+		}
+		return false;
+	}
+
+	public String toString(){
+		return super.toString();
+	}
+
+	public int size() {
+		return size;
+	}
+}
diff --git a/group12/563253496/datastructure/src/Collection/TestArrayList.java b/group12/563253496/datastructure/src/Collection/TestArrayList.java
new file mode 100644
index 0000000000..eef55fae6b
--- /dev/null
+++ b/group12/563253496/datastructure/src/Collection/TestArrayList.java
@@ -0,0 +1,33 @@
+package Collection;
+
+import java.lang.reflect.Array;
+
+/**
+ * Created by bdl19 on 2017/2/23.
+ */
+public class TestArrayList {
+    /*public  static void main(String[] args){
+        /*
+        ArrayList al= new ArrayList("test1");
+        System.out.println(al);
+        al.add("test2");
+        System.out.println(al);
+        al.add(1,2);
+        System.out.println(al);
+        System.out.println(al.get(2));
+        System.out.println(al.get(1));
+        System.out.println(al.get(0));
+       // System.out.println(al.get(3));
+        System.out.println(al.size());
+        System.out.println(al.remove(2));
+        System.out.println(al);
+
+        ArrayList al =new ArrayList();
+        al.add(3,2);
+        al.add(0,0);
+        System.out.println(al.size());
+        System.out.println(al);
+
+    }
+    **/
+}
diff --git a/group12/563253496/datastructure/src/Collection/TestStack.java b/group12/563253496/datastructure/src/Collection/TestStack.java
new file mode 100644
index 0000000000..4702e49079
--- /dev/null
+++ b/group12/563253496/datastructure/src/Collection/TestStack.java
@@ -0,0 +1,15 @@
+package Collection;
+
+/**
+ * Created by bdl19 on 2017/2/25.
+ */
+public class TestStack {
+    public static void main(String[] args) {
+        Stack s=new Stack();
+        s.push("a");
+        s.push("b");
+        System.out.println(s.pop());
+        System.out.println(s.pop());
+        
+    }
+}
diff --git a/group12/563253496/datastructure/src/com/coding/basic/ArrayList.java b/group12/563253496/datastructure/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..1f185736f9
--- /dev/null
+++ b/group12/563253496/datastructure/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,32 @@
+package com.coding.basic;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[100];
+	
+	public void add(Object o){
+		
+	}
+	public void add(int index, Object o){
+		
+	}
+	
+	public Object get(int index){
+		return null;
+	}
+	
+	public Object remove(int index){
+		return null;
+	}
+	
+	public int size(){
+		return -1;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+	
+}
diff --git a/group12/563253496/datastructure/src/com/coding/basic/BinaryTreeNode.java b/group12/563253496/datastructure/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..d7ac820192
--- /dev/null
+++ b/group12/563253496/datastructure/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,32 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git a/group12/563253496/datastructure/src/com/coding/basic/Iterator.java b/group12/563253496/datastructure/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..06ef6311b2
--- /dev/null
+++ b/group12/563253496/datastructure/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/group12/563253496/datastructure/src/com/coding/basic/LinkedList.java b/group12/563253496/datastructure/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..e2c4e5e795
--- /dev/null
+++ b/group12/563253496/datastructure/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,46 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	
+	public void add(Object o){
+		
+	}
+	public void add(int index , Object o){
+		
+	}
+	public Object get(int index){
+		return null;
+	}
+	public Object remove(int index){
+		return null;
+	}
+	
+	public int size(){
+		return -1;
+	}
+	
+	public void addFirst(Object o){
+		
+	}
+	public void addLast(Object o){
+		
+	}
+	public Object removeFirst(){
+		return null;
+	}
+	public Object removeLast(){
+		return null;
+	}
+	public Iterator iterator(){
+		return null;
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		
+	}
+}
diff --git a/group12/563253496/datastructure/src/com/coding/basic/List.java b/group12/563253496/datastructure/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ b/group12/563253496/datastructure/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/group12/563253496/datastructure/src/com/coding/basic/Queue.java b/group12/563253496/datastructure/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..36e516e266
--- /dev/null
+++ b/group12/563253496/datastructure/src/com/coding/basic/Queue.java
@@ -0,0 +1,19 @@
+package com.coding.basic;
+
+public class Queue {
+	
+	public void enQueue(Object o){		
+	}
+	
+	public Object deQueue(){
+		return null;
+	}
+	
+	public boolean isEmpty(){
+		return false;
+	}
+	
+	public int size(){
+		return -1;
+	}
+}
diff --git a/group12/563253496/datastructure/src/com/coding/basic/Stack.java b/group12/563253496/datastructure/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..a5a04de76d
--- /dev/null
+++ b/group12/563253496/datastructure/src/com/coding/basic/Stack.java
@@ -0,0 +1,22 @@
+package com.coding.basic;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){		
+	}
+	
+	public Object pop(){
+		return null;
+	}
+	
+	public Object peek(){
+		return null;
+	}
+	public boolean isEmpty(){
+		return false;
+	}
+	public int size(){
+		return -1;
+	}
+}
diff --git a/group16/1012075117/DataStructure219/.classpath b/group16/1012075117/DataStructure219/.classpath
new file mode 100644
index 0000000000..fceb4801b5
--- /dev/null
+++ b/group16/1012075117/DataStructure219/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group16/1012075117/DataStructure219/.project b/group16/1012075117/DataStructure219/.project
new file mode 100644
index 0000000000..567baae65f
--- /dev/null
+++ b/group16/1012075117/DataStructure219/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>DataStructure219</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group16/1012075117/DataStructure219/.settings/org.eclipse.jdt.core.prefs b/group16/1012075117/DataStructure219/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..3a21537071
--- /dev/null
+++ b/group16/1012075117/DataStructure219/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/ArrayList.java b/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/ArrayList.java
new file mode 100644
index 0000000000..a1d46a21d8
--- /dev/null
+++ b/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/ArrayList.java
@@ -0,0 +1,94 @@
+package com.stackwei.DataStructure;
+
+/**
+ * 
+ * @author stackwei -2017.2.25
+ *
+ */
+public class ArrayList implements List {
+
+	private int flag = -1;
+	private static final int DEFAULT_CAPACITY = 1;
+	private Object[] elementData = new Object[DEFAULT_CAPACITY];
+	
+	@Override
+	public void add(Object element) {
+		// 当要添加数据的位置已经超过数组长度时，增长数组长度
+		if (size() + 1 == elementData.length) {
+			grow();
+		}
+		elementData[flag + 1] = element;
+		flag++;
+	}
+
+	@Override
+	public void add(int index, Object element) {
+		if (index < 0 || index > getFlag() + 1) {
+			System.out.println("在--" + index + "--添加的--" + element + "--无效，因为越界了！");
+			return;
+		}
+		// 数组长度永远比已存数据大一个。
+		if (size() + 1 == elementData.length) {
+			grow();
+		}
+		elementData[index] = element;
+		if (index > getFlag()) {
+			flag++;
+		}
+	}
+
+	@Override
+	public Object get(int index) {
+		if (index < 0 || index > getFlag()) {
+			System.out.print("在--" + index + "--的get无效,因为越界了！");
+			return null;
+		}
+		return elementData[index];
+	}
+
+	@Override
+	public Object remove(int index) {
+		if (index < 0 || index > getFlag()) {
+			System.out.println("在--" + index + "--的remove无效,因为越界了！");
+			return null;
+		}
+		Object oldValue = elementData[index];
+		elementData[index] = null;
+		// 将删除处后面的数据往前移一格。
+		Object[] data2 = new Object[elementData.length - 1];
+		System.arraycopy(elementData, 0, data2, 0, getFlag());
+		elementData = data2;
+		flag--;
+		return oldValue;
+	}
+
+	@Override
+	public int size() {
+		return getFlag() + 1;
+	}
+
+	public int getFlag() {
+		return flag;
+	}
+
+	private void grow() {
+		Object[] data2 = new Object[elementData.length + 1];
+		System.arraycopy(elementData, 0, data2, 0, getFlag() + 2);// 最后一个参数是需要复制的数据的数量。
+		elementData = data2;
+	}
+
+	/**
+	 * 测试用例
+	 * 
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		ArrayList al = new ArrayList();
+		al.add(0, 99);
+		al.add(1, 100);
+		System.out.println(al.get(1));
+		al.remove(1);
+		System.out.println(al.get(1));
+		System.out.println(al.size());
+	}
+}
\ No newline at end of file
diff --git a/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/LinkedList.java b/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/LinkedList.java
new file mode 100644
index 0000000000..a1c728f0a1
--- /dev/null
+++ b/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/LinkedList.java
@@ -0,0 +1,194 @@
+package com.stackwei.DataStructure;
+
+/**
+ * 
+ * @author stackwei -2017.2.25
+ *
+ */
+public class LinkedList implements List {
+
+	private Node head = null;
+	private Node last = null;
+	private int size = 0;
+
+	private static class Node {
+		Object item;
+		Node prev;
+		Node next;
+
+		public Node(Node prev, Object item, Node next) {
+			this.prev = prev;
+			this.item = item;
+			this.next = next;
+		}
+	}
+
+	@Override
+	public void add(Object element) {
+		addLast(element);
+	}
+
+	@Override
+	public void add(int index, Object element) {
+		if (index < 0 || index > size) {
+			System.out.println("操作无效,越界了");
+			return;
+		}
+		if (index == 0) {
+			addFirst(element);
+			return;
+		}
+		if (index == size) {
+			addLast(element);
+			return;
+		}
+		Node indexNode = node(index);
+		Node newNode = new Node(indexNode.prev, element, indexNode);
+		indexNode.prev.next = newNode;
+		indexNode.prev = newNode;
+		size++;
+	}
+
+	@Override
+	public Object get(int index) {
+		if (index < 0 || index >= size) {
+			System.out.println("查询无效,越界了");
+			return null;
+		}
+		if (index == 0) {
+			return head.item;
+		}
+		return node(index).item;
+	}
+
+	@Override
+	public Object remove(int index) {
+		if (index < 0 || index > size) {
+			System.out.println("是空的，无法删除");
+			return null;
+		}
+		if (index == 0) {
+			return removeFirst();
+		}
+		if (index == size - 1) {
+			return removeLast();
+		}
+		Node x = node(index);
+		final Object element = x.item;
+		final Node next = x.next;
+		final Node prev = x.prev;
+
+		if (prev == null) {
+			head = next;
+		} else {
+			prev.next = next;
+			x.prev = null;
+		}
+
+		if (next == null) {
+			last = prev;
+		} else {
+			next.prev = prev;
+			x.next = null;
+		}
+
+		x.item = null;
+		size--;
+		return element;
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+
+	private void addFirst(Object element) {
+		final Node f = head;
+		Node newNode = new Node(null, element, f);
+		head = newNode;
+		if (f == null)
+			last = newNode;
+		else
+			f.prev = newNode;
+		size++;
+	}
+
+	public void addLast(Object element) {
+		if (head == null) {
+			addFirst(element);
+		} else {
+			Node newNode = new Node(last, element, null);
+			last.next = newNode;
+			last = newNode;
+			size++;
+		}
+	}
+
+	public Object removeFirst() {
+		if (head == null) {
+			System.out.println("是空的，无法删除");
+			return null;
+		} else {
+			Node x = head;
+			Node next = head.next;
+			Object element = x.item;
+			x.item = null;
+			x.next = null;
+			head = next;
+			if (next == null)
+				last = null;
+			else
+				x.prev = null;
+			size--;
+			return element;
+		}
+	}
+
+	public Object removeLast() {
+		if (last == null) {
+			System.out.println("是空的，无法删除");
+			return null;
+		} else {
+			final Node l = last;
+			final Object element = l.item;
+			final Node p = l.prev;
+			l.item = null;
+			l.prev = null;
+			last = p;
+			if (p == null)
+				head = null;
+			else
+				p.next = null;
+			size--;
+			return element;
+		}
+	}
+
+	Node node(int index) {
+		if (index < (size >> 1)) {
+			Node x = head;
+			for (int i = 0; i < index; i++)
+				x = x.next;
+			return x;
+		} else {
+			Node x = last;
+			for (int i = size - 1; i > index; i--)
+				x = x.prev;
+			return x;
+		}
+	}
+
+	/**
+	 * 测试用例
+	 * 
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		LinkedList ll = new LinkedList();
+		ll.add(0, "xxx");
+		ll.add(1, 111);
+		System.out.println(ll.size());
+		System.out.println(ll.get(2));
+
+	}
+}
\ No newline at end of file
diff --git a/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/List.java b/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/List.java
new file mode 100644
index 0000000000..5226796141
--- /dev/null
+++ b/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/List.java
@@ -0,0 +1,13 @@
+package com.stackwei.DataStructure;
+
+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/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/Queue.java b/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/Queue.java
new file mode 100644
index 0000000000..4a227495e9
--- /dev/null
+++ b/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/Queue.java
@@ -0,0 +1,52 @@
+package com.stackwei.DataStructure;
+
+/**
+ * 
+ * @author stackwei -2017.2.25
+ *
+ */
+public class Queue {
+
+	private LinkedList ll = new LinkedList();
+	
+	/**
+	 * 在队尾添加数据
+	 * @param element
+	 */
+	public void enQueue(Object element) {
+		ll.addLast(element);
+	}
+	
+	/**
+	 * 删除队头数据
+	 * @return
+	 */
+	public Object deQueue() {
+		return ll.removeFirst();
+	}
+	
+	/**
+	 * 队列是否为空
+	 * @return
+	 */
+	public boolean isEmpty() {
+		if (ll.size() > 0) {
+			return false;
+		}
+		return true;
+	}
+	
+	/**
+	 * 测试用例
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		Queue q = new Queue();
+		q.enQueue(97);
+		q.enQueue(98);
+		q.enQueue(99);
+		System.out.println(q.isEmpty());
+		System.out.println(q.deQueue());
+	}
+
+}
diff --git a/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/Stack.java b/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/Stack.java
new file mode 100644
index 0000000000..1b047ffafd
--- /dev/null
+++ b/group16/1012075117/DataStructure219/src/com/stackwei/DataStructure/Stack.java
@@ -0,0 +1,59 @@
+package com.stackwei.DataStructure;
+
+/**
+ * 
+ * @author stackwei -2017.2.25
+ *
+ */
+public class Stack {
+
+	private ArrayList al = new ArrayList();
+	
+	/**
+	 * 进栈
+	 * @param item
+	 */
+	public void push(Object item) {
+		al.add(item);
+	}
+	
+	/**
+	 * 出栈
+	 * @return
+	 */
+	public Object pop() {
+		return al.remove(al.getFlag());
+	}
+	
+	/**
+	 * 获取栈顶元素
+	 * @return
+	 */
+	public Object peek() {
+		return al.get(al.getFlag());
+	}
+	
+	/**
+	 * 栈是否为空
+	 * @return
+	 */
+	public boolean isEmpty() {
+		if (al.getFlag() >= 0) {
+			return false;
+		}
+		return true;
+	}
+	
+	/**
+	 * 测试用例
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		Stack s = new Stack();
+		s.push(98);
+		s.push(99);
+		s.pop();
+		System.out.println(s.peek());
+	}
+
+}
diff --git a/group16/1154151360/.classpath b/group16/1154151360/.classpath
new file mode 100644
index 0000000000..fb5011632c
--- /dev/null
+++ b/group16/1154151360/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group16/1154151360/.gitignore b/group16/1154151360/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group16/1154151360/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group16/1154151360/.project b/group16/1154151360/.project
new file mode 100644
index 0000000000..f88388f6d7
--- /dev/null
+++ b/group16/1154151360/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>DataStructure2</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group16/1154151360/.settings/org.eclipse.core.resources.prefs b/group16/1154151360/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000000..99f26c0203
--- /dev/null
+++ b/group16/1154151360/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/group16/1154151360/src/com/list/ArrayList.java b/group16/1154151360/src/com/list/ArrayList.java
new file mode 100644
index 0000000000..733dc0f341
--- /dev/null
+++ b/group16/1154151360/src/com/list/ArrayList.java
@@ -0,0 +1,93 @@
+package com.list;
+
+
+//ArrayList
+public class ArrayList {
+
+	private int size;
+	
+	private Object [] elementData = new Object[10];
+	
+	public boolean add(Object data){
+		
+		getRow(size+1);
+		elementData[size++] = data; 
+		return true;
+	}
+	
+	public boolean add(int index, Object data){
+		if (index < 0 || index > elementData.length){
+			throw new IndexOutOfBoundsException("�±�Խ��");
+		}
+		getRow(size + 1);
+		Object object = elementData [index];
+		System.arraycopy(elementData, index,elementData , index + 1,size - index );
+		elementData[index] = data;
+		size++;
+		return true;
+	}
+	
+	public Object get(int index){
+		if (index < 0 || index > elementData.length){
+			throw new IndexOutOfBoundsException("下标越界");
+		}
+		return elementData[index];
+	}
+	
+	public Object remove(int index){
+		if (index < 0 || index > elementData.length){
+			throw new IndexOutOfBoundsException("下标越界");
+		}
+		Object object = elementData [index];
+		System.arraycopy(elementData, index + 1 , elementData, index, size - 1 - index);
+		elementData[size--]= null;
+		return object;
+	}
+	
+	
+	private void getRow(int num){
+		if (num > elementData.length ){
+			int oldLength = elementData.length;
+			int newLength = ((num + elementData.length) * 3) >> 2;
+			Object [] oldelements = elementData;
+			elementData = new Object[newLength];
+			System.arraycopy(oldelements, 0, elementData, 0, size);
+		}
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public int length(){
+		return elementData.length;
+	}
+	public static void main(String[] args) {
+			ArrayList list  = new ArrayList();
+			
+			list.add("A");
+			list.add("B");
+			list.add("C");
+			list.add("D");
+			list.add("E");
+			list.add("F");
+			list.add("G");
+			list.add("H");
+			list.add("I");
+			list.add("J");
+			list.add("K");
+			list.add("L");
+			list.add(2, 1);
+			System.out.println("elementsData.Length: "+list.length());
+			System.out.println("elementsData.size: "+list.size());
+			for (int i = 0; i < list.size; i++){
+				System.out.print(list.get(i)+ " ");
+			}
+			System.out.println(" ");
+			list.remove(2);
+			
+			for (int i = 0; i < list.size; i++){
+				System.out.print(list.get(i)+ " ");
+			}
+	}
+}
diff --git a/group16/1154151360/src/com/list/LinkedList.java b/group16/1154151360/src/com/list/LinkedList.java
new file mode 100644
index 0000000000..46f61fb667
--- /dev/null
+++ b/group16/1154151360/src/com/list/LinkedList.java
@@ -0,0 +1,158 @@
+package com.list;
+
+public class LinkedList {
+
+	private int size;
+	
+	private Node head;//头节点
+	
+	Node current; //当前节点
+	
+	public LinkedList(){
+		this.head = current = new Node(null);
+		this.size = 0;
+	}
+	
+	
+	private boolean add(Object object){
+		addAfter(object);
+		size++;
+		return true;
+	}
+	
+	
+	private boolean add(int index,Object object) throws Exception{
+		index(index - 1);
+		current.nextNode = new Node(object,current.nextNode.nextNode);
+		size++;
+		return true;
+	}
+	
+	
+	private boolean addFirst(Object object){
+		Node node = new Node(object,null);
+		current = head.nextNode;
+		head.nextNode = node;
+		node.nextNode = current;
+		size++;
+		return true;
+	}
+	
+	
+	private boolean addLast(Object object){
+		add(object);
+		return true;
+	}
+	
+	
+	private Object get(int index) throws Exception{
+		index(index);
+		return current.object;
+	}
+	
+	
+	private  Object remove(int index) throws Exception{
+		
+		if (index == size - 1){
+			Object object = removeLast();
+			return object;
+		}
+		index(index - 1);
+		Object object = current.nextNode.object;
+		
+		current.nextNode = current.nextNode.nextNode;
+		size--;
+		return object;
+	}
+	
+	private Object removeFirst(){
+		Object object = null;
+		if (size > 0){
+			current = head.nextNode;
+			object = current.object;
+			head.nextNode = head.nextNode.nextNode;
+			size--;
+		}
+		return object;
+	}
+	
+	private Object removeLast() throws Exception{
+		Object object = null;
+		if (size > 0){
+			int j = 0;
+			current = head.nextNode;
+			
+			while (current != null){
+				current = current.nextNode;
+				j++;
+			}
+			index(j - 1);
+			object = current.nextNode.object;
+			current.nextNode = null;
+			size--;
+		}
+		return object;
+	}
+	private void index (int index) throws Exception{
+		
+		if (index < -1 || index > size){
+			
+			throw new Exception(" ");
+		}
+		
+		if (index == -1){
+			return;
+		}
+		current = head.nextNode;
+		int j = 0;
+		while (current != null && j < index){
+			current = current.nextNode;
+			j++;
+		}
+	}
+	
+	
+	private void addAfter(Object object){
+		
+		if (head.nextNode == null){
+			
+			Node newNode = new Node(object,null);
+		}else{
+			current = head.nextNode;
+			while (current.nextNode == null){
+				current = current.nextNode;
+			}
+			current.setNode(new Node(object,null));
+		}
+		
+		
+	}
+	
+	
+	
+	
+	private static class Node{
+		
+		Object object;
+		
+		Node nextNode;
+		
+		
+		Node (Node nextNode){
+			this.nextNode = nextNode;
+		}
+		
+		
+		Node (Object object, Node nextNode){
+			this.nextNode = nextNode;
+			this.object = object;
+		}
+		
+		private void setNode(Node node){
+			this.nextNode = node;
+		}
+		
+	}
+	
+	
+}
diff --git a/group16/1154151360/src/com/list/Queue.java b/group16/1154151360/src/com/list/Queue.java
new file mode 100644
index 0000000000..faa3e87381
--- /dev/null
+++ b/group16/1154151360/src/com/list/Queue.java
@@ -0,0 +1,51 @@
+package com.list;
+//队列
+public class Queue {
+
+	Object [] element;
+	
+	private static int DEFAULT_SIZE = 10;
+	
+	int front;//头指针
+	
+	int rear;//尾指针
+	
+	public Queue(){
+		this(DEFAULT_SIZE);
+	}
+	public Queue(int size){
+		element = new Object[size];
+		this.front = 0;
+		this.rear = 0;
+	}
+	
+	public boolean enQueue(Object object){
+		
+		if ((rear + 1) % element.length == front){
+			return false;
+		}else{
+			element[rear] = object;
+			rear = (rear + 1) % element.length;
+			return true;
+		}
+	}
+	
+	public Object deQueue(){
+		if (front == rear){
+			return null;
+		}else{
+			Object object = element[front];
+			front = (front + 1) % element.length;
+			return object;
+		}
+		
+	}
+	
+	public int size(){
+		return (rear -front) & (element.length - 1);
+	}
+	
+	public boolean isEmpty(){
+		return rear == front;
+	}
+}
diff --git a/group16/1154151360/src/com/list/Stack.java b/group16/1154151360/src/com/list/Stack.java
new file mode 100644
index 0000000000..f92a9e731c
--- /dev/null
+++ b/group16/1154151360/src/com/list/Stack.java
@@ -0,0 +1,35 @@
+package com.list;
+
+import java.util.ArrayList;
+import java.util.EmptyStackException;
+
+public class Stack {
+
+	ArrayList<Object> elelmentData = new ArrayList<Object>();
+	
+	//压入栈
+	public void push(Object object){
+		elelmentData.add(object);
+	}
+	
+	//弹出栈
+	public Object pop(){
+		if (isEmpty()){ throw new EmptyStackException();}
+		return elelmentData.remove(elelmentData.size() - 1);
+	}
+	
+	//取栈顶元素
+	public Object peek(){
+		if (isEmpty()){return null;}
+		return elelmentData.get(elelmentData.size() - 1);
+	}
+	
+	public boolean isEmpty(){
+		return elelmentData.isEmpty();
+	}
+	
+	public int size(){
+		if (isEmpty()){throw new EmptyStackException();}
+		return elelmentData.size();
+	}
+}
diff --git a/group16/1287642108/0226/src/com/coding/basic/ArrayList.java b/group16/1287642108/0226/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..e287419dc0
--- /dev/null
+++ b/group16/1287642108/0226/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,63 @@
+package com.coding.basic;
+
+public class ArrayList implements List {
+
+	private int size = 0;
+
+	private Object[] elementData = new Object[100];
+
+	public void add(Object o) {
+		IncrementsCapacity(size + 1);
+		elementData[size++] = o;
+
+	}
+
+	public void add(int index, Object o) {
+		checkIndex(index);
+		IncrementsCapacity(size + 1);
+		System.arraycopy(elementData, index, elementData, index + 1, size - index);
+		elementData[index] = o;
+		size++;
+	}
+
+	public Object get(int index) {
+		checkIndex(index);
+		return elementData[index];
+	}
+
+	public Object remove(int index) {
+		checkIndex(index);
+		Object o = elementData[index];
+		System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
+		elementData[--size] = null;
+		return o;
+	}
+
+	public int size() {
+		return size;
+	}
+	
+	public int length() {
+		return elementData.length;
+	}
+
+	// ����
+	private void IncrementsCapacity(int num) {
+		if (num > elementData.length) {
+			int oldCapacity = elementData.length; // ��ǰ���鳤��
+			int newCapacity = ((num + oldCapacity) * 3) >> 2; // ��ǰ���鳤�ȵ�1.5��
+			if (newCapacity - num < 0) {
+				newCapacity = num; // �����������ǲ���,ֱ����Ϊ����ֵ
+			}
+			Object[] oldelements = elementData;
+			elementData = new Object[newCapacity];
+			System.arraycopy(oldelements, 0, elementData, 0, size);
+		}
+	}
+
+	// �±�Խ���ж�
+	private void checkIndex(int index) {
+		if (index >= size || index < 0)
+			throw new IndexOutOfBoundsException("�����±�Խ��");
+	}
+}
diff --git a/group16/1287642108/0226/src/com/coding/basic/Iterator.java b/group16/1287642108/0226/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..e7cbd474ec
--- /dev/null
+++ b/group16/1287642108/0226/src/com/coding/basic/Iterator.java
@@ -0,0 +1,6 @@
+package com.coding.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+}
diff --git a/group16/1287642108/0226/src/com/coding/basic/LinkedList.java b/group16/1287642108/0226/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..99c92fb9f1
--- /dev/null
+++ b/group16/1287642108/0226/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,101 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	private Node tail;
+	private int size = 0 ;
+	
+	public void add(Object o){
+		addLast(o);
+	}
+
+	public void add(int index, Object o) {
+		if (index == 0) {
+			addFirst(o);
+		} else if (index >= size) {
+			addLast(o);
+		} else {
+			Node node = new Node();
+			node.data = o;
+			node.next = getNode(index);
+			getNode(index - 1).next = node;
+			size++;
+		}
+	}
+	
+	public Object get(int index) {
+		Node node = getNode(index);
+		return node.data;
+	}
+	
+	public Object remove(int index){
+		Node currentNode = getNode(index);
+		Node prevNode = getNode(index - 1);
+		Node lastNode = getNode(index + 1);
+		prevNode.next = lastNode;
+		size--;
+		return currentNode.data;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		  Node node=new Node();  
+		  node.data = o;
+		  node.next = head;  
+          head = node;  
+          size++;  
+	}
+	public void addLast(Object o){
+		 Node node=new Node();  
+		 node.data = o;
+		 node.next = null; 
+         Node lastNode = getNode(size-1);
+         lastNode.next = node;
+         size++;  
+	}
+	public Object removeFirst(){
+		Object obj = getNode(0).data;
+		Node node = getNode(1);
+		node.next = head;
+		size--;
+		return obj;
+	}
+	public Object removeLast(){
+		Object obj = getNode(size - 1).data;
+		Node node = getNode(size - 2);
+		node.next = null;
+		size--;
+		return obj;
+	}
+	
+	//��ȡ�ڵ�
+    public Node getNode(int index){
+    	checkIndex(index);
+    	if(index == 0 ){
+    		return head;
+    	}else if(index == size -1 ){
+    		return tail;
+    	}else{
+    		 Node node = head;
+    	        for(int i=0;i<index;i++){
+    	        	node = node.next;
+    	        }
+    	        return node;
+    	}
+    }
+    
+ // �±�Խ���ж�
+ 	private void checkIndex(int index) {
+ 		if (index >= size || index < 0)
+ 			throw new IndexOutOfBoundsException("�����±�Խ��");
+ 	}
+	
+	private static class Node {
+		Object data;
+		Node next;
+	}
+}
diff --git a/group16/1287642108/0226/src/com/coding/basic/List.java b/group16/1287642108/0226/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ b/group16/1287642108/0226/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/group16/1287642108/0226/src/com/coding/basic/Queue.java b/group16/1287642108/0226/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..95dee3d81b
--- /dev/null
+++ b/group16/1287642108/0226/src/com/coding/basic/Queue.java
@@ -0,0 +1,28 @@
+package com.coding.basic;
+
+public class Queue {
+	private LinkedList elementData = new LinkedList();
+
+	public void enQueue(Object o){		
+		elementData.addLast(o);
+	}
+	
+	public Object deQueue(){
+		if (isEmpty()) {
+			return null;
+		}else{
+			return elementData.removeFirst();
+		}
+	}
+	
+	public boolean isEmpty(){
+		if (elementData.size() == 0) {
+			return true;
+		}
+		return false;
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group16/1287642108/0226/src/com/coding/basic/Stack.java b/group16/1287642108/0226/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..c0b7da89f8
--- /dev/null
+++ b/group16/1287642108/0226/src/com/coding/basic/Stack.java
@@ -0,0 +1,38 @@
+package com.coding.basic;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+
+	public void push(Object o) {
+		if (isEmpty()) {
+			elementData.add(elementData.length() - 1, o);
+		}
+		elementData.add(elementData.length() - elementData.size() - 1, o);
+	}
+
+	public Object pop() {
+		if (isEmpty()) {
+			return null;
+		}
+		return elementData.remove(elementData.length() - elementData.size() - 1);
+	}
+
+	public Object peek() {
+		if (isEmpty()) {
+			return null;
+		}
+		return elementData.get(elementData.length() - elementData.size() - 1);
+	}
+
+	public boolean isEmpty() {
+		if (elementData.size() == 0) {
+			return true;
+		}
+		return false;
+	}
+
+	public int size() {
+		return elementData.size();
+	}
+
+}
diff --git a/group16/1325756593/.classpath b/group16/1325756593/.classpath
new file mode 100644
index 0000000000..3e0fb272a8
--- /dev/null
+++ b/group16/1325756593/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group16/1325756593/.gitignore b/group16/1325756593/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group16/1325756593/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group16/1325756593/.project b/group16/1325756593/.project
new file mode 100644
index 0000000000..e3d07b6899
--- /dev/null
+++ b/group16/1325756593/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>DongqiHomeWork</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group16/1325756593/dongqihust.readme b/group16/1325756593/dongqihust.readme
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/group16/1325756593/src/com/dong/week1/ArrayList.java b/group16/1325756593/src/com/dong/week1/ArrayList.java
new file mode 100644
index 0000000000..a700aecfb5
--- /dev/null
+++ b/group16/1325756593/src/com/dong/week1/ArrayList.java
@@ -0,0 +1,109 @@
+package com.dong.week1;
+
+import java.util.Arrays;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[100];
+	
+	public void add(Object o){
+		/**
+		 * ���ж������Ƿ��Ѿ����ˣ�����Ѿ����������ݴ���
+		 */
+		if(elementData.length==size){
+			elementData = Arrays.copyOf(elementData, elementData.length*2+1);			
+		}
+		elementData[size++]=o;
+			
+	}
+	public void add(int index, Object o){
+		if(index >size || index < 0 ){
+			throw new ArrayIndexOutOfBoundsException("����Խ��,��ǰ���鳤����"+size+",��������Ԫ�ص�������:"+index);
+		}
+		/**
+		 * �����Ѿ����ˣ�������
+		 */
+		if(size==elementData.length){
+			elementData = Arrays.copyOf(elementData, elementData.length*2+1);		
+		}	
+		Object[] elementDataClone = elementData.clone();
+		System.arraycopy(elementData, index, elementDataClone, index+1, size-index);
+		elementDataClone[index++]=o;
+		size++;
+		elementData = elementDataClone;
+	}
+	
+	
+	public Object get(int index){
+		if(index >=size || index < 0 ){
+			throw new ArrayIndexOutOfBoundsException("����Խ��,��ǰ���鳤����"+size+",��������Ԫ�ص�������:"+index);
+		}
+		return elementData[index];
+	}
+	
+	public Object remove(int index){
+		if(index >=size || index < 0 ){
+			throw new ArrayIndexOutOfBoundsException("����Խ��,��ǰ���鳤����"+size+",����ɾ��Ԫ�ص�������:"+index);
+		}
+		elementData[index]=null;
+		size--;
+		Object[] elementDataClone = elementData.clone();
+		System.arraycopy(elementData, index+1, elementDataClone, index, size-index-1);
+		elementData = elementDataClone;
+		return elementData[index];
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public Iterator iterator(){
+		return new IteratorArrayList(this);
+	}
+	@Override
+	public String toString() {
+		return "ArrayList [size=" + size + ", elementData=" + Arrays.toString(elementData) + "]";
+	}
+
+	
+	private class IteratorArrayList implements Iterator{
+		
+		private ArrayList arrayList;
+		private int index=0;
+		
+
+		public IteratorArrayList(ArrayList arrayList) {
+			super();
+			this.arrayList = arrayList;
+		}
+
+		@Override
+		public boolean hasNext() {
+			// TODO Auto-generated method stub
+			return this.arrayList.size() >index;
+		}
+
+		@Override
+		public Object next() {
+			// TODO Auto-generated method stub
+			if(hasNext()){
+				return  this.arrayList.get(index++);
+			}
+			return null;
+		}
+		
+	}
+	
+	public static void main(String[] args) {
+		ArrayList arrayList= new ArrayList();
+		
+		Iterator iterator=  arrayList.iterator();
+		while(iterator.hasNext()){
+			System.out.println(iterator.next());
+		}
+	}
+
+	
+}
diff --git a/group16/1325756593/src/com/dong/week1/ArrayListTest.java b/group16/1325756593/src/com/dong/week1/ArrayListTest.java
new file mode 100644
index 0000000000..128130cfb2
--- /dev/null
+++ b/group16/1325756593/src/com/dong/week1/ArrayListTest.java
@@ -0,0 +1,63 @@
+package com.dong.week1;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class ArrayListTest {
+
+	//@Test
+	public void testAddObject() {
+		ArrayList arrayList = new ArrayList();
+		for(int i=0;i<=200;i++){
+			arrayList.add(i);
+		}
+		System.out.println(arrayList);
+	}
+
+	//@Test
+	public void testAddIntObject() {
+		ArrayList arrayList = new ArrayList();
+		for(int i=0;i<=2;i++){
+			arrayList.add(i);
+		}
+		arrayList.add(1,100);
+		arrayList.add(1, 1000);
+		System.out.println(arrayList);
+	}
+
+//	@Test
+	public void testGet() {
+		ArrayList arrayList = new ArrayList();
+		for(int i=0;i<=200;i++){
+			arrayList.add(i);
+		}
+		//System.out.println(arrayList.get(-1));
+		//System.out.println(arrayList.get(50));
+		System.out.println(arrayList.get(200));
+		//System.out.println(arrayList.get(300));
+		
+		
+	}
+
+	@Test
+	public void testRemove() {
+		ArrayList arrayList = new ArrayList();
+		for(int i=0;i<=10;i++){
+			arrayList.add(i);
+		}
+		arrayList.remove(1);
+		arrayList.remove(1);
+		System.out.println(arrayList);
+	}
+
+//	@Test
+	public void testSize() {
+		ArrayList arrayList = new ArrayList();
+		for(int i=0;i<=10;i++){
+			arrayList.add(i);
+		}
+		System.out.println(arrayList.size());
+	}
+
+}
diff --git a/group16/1325756593/src/com/dong/week1/BinaryTreeNode.java b/group16/1325756593/src/com/dong/week1/BinaryTreeNode.java
new file mode 100644
index 0000000000..ef41ced8df
--- /dev/null
+++ b/group16/1325756593/src/com/dong/week1/BinaryTreeNode.java
@@ -0,0 +1,39 @@
+package com.dong.week1;
+
+public class BinaryTreeNode {
+	private TreeNode node;
+	
+	  private static class  TreeNode{  
+	        private int key=0;  
+	        private TreeNode leftChild=null;  
+	        private TreeNode rightChild=null;  
+	          
+	        public TreeNode(){}  
+	          
+	        /** 
+	         * @param key  ������� 
+	         * @param data ������ 
+	         */  
+	        public TreeNode(int key){  
+	            this.key=key;  
+	            this.leftChild=null;  
+	            this.rightChild=null;  
+	        }  
+	  
+	  
+	    }  
+	
+	
+	
+	public TreeNode insert(TreeNode  o){
+		if(node == null){
+			return o;
+		}		
+		if(node.key > o.key){
+			return insert(o.leftChild);
+		}else{
+			return insert(node.leftChild);
+		}
+	}
+	
+}
diff --git a/group16/1325756593/src/com/dong/week1/Iterator.java b/group16/1325756593/src/com/dong/week1/Iterator.java
new file mode 100644
index 0000000000..9147ab8264
--- /dev/null
+++ b/group16/1325756593/src/com/dong/week1/Iterator.java
@@ -0,0 +1,7 @@
+package com.dong.week1;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group16/1325756593/src/com/dong/week1/LinkedList.java b/group16/1325756593/src/com/dong/week1/LinkedList.java
new file mode 100644
index 0000000000..339b5862ee
--- /dev/null
+++ b/group16/1325756593/src/com/dong/week1/LinkedList.java
@@ -0,0 +1,208 @@
+package com.dong.week1;
+
+public class LinkedList implements List {
+	
+	private int size = 0;
+	private Node head;
+	private Node tail;
+	
+	
+	public void add(Object o){
+	//����һ��Ԫ�ص��߼��ǳ��򵥣�ֻ��Ҫ�ж�head�Ƿ�Ϊ�ա���Ϊ�գ�����ֱ�ӼӼ���
+		Node node = new Node(o,null);		
+		if(head ==null){
+			head =node;
+		}else{
+			tail.next=node;			
+		}
+		tail=node;
+		size++;
+		
+	}
+	public void add(int index , Object o){
+		if(index < 0){
+			throw new ArrayIndexOutOfBoundsException("index����Ϊ����");
+		}
+		if(index > size){
+			throw new ArrayIndexOutOfBoundsException("��ǰlist����Ϊ"+size+",��ȡ�����ǣ�"+index);
+		}
+		if(size==0){
+			head=new Node(o, null);		
+			tail=head;
+			return;
+		}
+		if(index==0){
+			Node curNode =head;
+			Node newNode =new Node(o, curNode);
+			head=newNode;
+			return;
+		}
+		Node curNode =head;
+		Object retVal = null;
+		for(int i=0;i<index-1;i++){
+			curNode=curNode.next;
+		}
+		if(curNode.next==null){
+			curNode.next = new Node(o, null);
+			tail = curNode.next;
+			return;
+		}	
+		
+		Node newNode = new Node(o, curNode.next);
+		curNode.next = newNode;
+		size ++;
+	}
+	public Object get(int index){
+		if(size ==0){
+			throw new ArrayIndexOutOfBoundsException("��ǰlistΪ�գ��޷��Ƴ�");
+		}
+		if(index >= size){
+			throw new ArrayIndexOutOfBoundsException("��ǰlist����Ϊ"+size+",�Ƴ������ǣ�"+index);
+		}
+		Node curNode = head;
+		for(int i=0;i<index;i++){
+			curNode = curNode.next;
+		}
+		return curNode.data;
+	}
+	public Object remove(int index){
+		if(size ==0){
+			throw new ArrayIndexOutOfBoundsException("��ǰlistΪ�գ��޷���ȡ");
+		}
+		if(index >= size){
+			throw new ArrayIndexOutOfBoundsException("��ǰlist����Ϊ"+size+",��ȡ�����ǣ�"+index);
+		}
+		Object retVal = null;
+		if(index==0){
+			retVal =head.data;
+			head=head.next;
+			return retVal;
+		}
+		Node curNode =head;
+		
+		for(int i=0;i<index-1;i++){
+			curNode=curNode.next;
+		}
+		retVal = curNode.next.data;
+		if(curNode.next==tail){
+			tail=curNode;
+		}		
+		curNode.next = curNode.next.next;
+		size --;
+		return retVal;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		Node node = new Node(o,head);		
+		head=node;
+		size++;
+		
+	}
+	public void addLast(Object o){
+		tail.next = new Node(o, null);
+		tail=tail.next;
+		size++;
+		
+	}
+	public Object removeFirst(){
+		if(size ==0){
+			throw new ArrayIndexOutOfBoundsException("��ǰlistΪ�գ��޷��Ƴ�");
+		}
+		Object retVal = head.data;
+		head.data=null;
+		head=head.next;		
+		size--;
+		return retVal;
+	}
+	public Object removeLast(){
+		Object retVal;
+		if(size ==0){
+			throw new ArrayIndexOutOfBoundsException("��ǰlistΪ�գ��޷��Ƴ�");
+		}else if(size==1){
+			retVal= head.data;
+			head=null;
+			tail=null;
+			size--;
+			return retVal;
+		}
+		Node curNode = head;
+		while(curNode.next.next!=null){
+			curNode= curNode.next;
+		}
+		tail =curNode;
+		retVal=curNode.next.data;
+		curNode.next=null;
+		size--;
+		return retVal;
+	}
+	public Iterator iterator(){
+		return new IteratorArrayLinkedList(this);
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		public Node(Object data, Node next) {
+			super();
+			this.data = data;
+			this.next = next;
+		}
+		@Override
+		public String toString() {
+			return "Node [data=" + data + ", next=" + next + "]";
+		}	
+		
+		
+	}
+	
+	
+	@Override
+	public String toString() {
+		return "LinkedList [size=" + size + ", head=" + head + ", tail=" + tail + "]";
+	}
+	
+	
+	private class IteratorArrayLinkedList implements Iterator{
+		private LinkedList list;
+		private int index = 0;
+		
+			
+
+
+		public IteratorArrayLinkedList(LinkedList list) {
+			super();
+			this.list = list;
+		}
+
+		@Override
+		public boolean hasNext() {
+			// TODO Auto-generated method stub
+			return this.list.size() >index;
+		}
+
+		@Override
+		public Object next() {
+			// TODO Auto-generated method stub
+			if(hasNext()){
+				return  this.list.get(index++);
+			}
+			return null;
+		}
+}
+	public static void main(String[] args) {
+		
+		LinkedList arrayList= new LinkedList();
+		
+		Iterator iterator=  arrayList.iterator();
+		while(iterator.hasNext()){
+			System.out.println(iterator.next());
+		}
+	
+}
+	
+}
diff --git a/group16/1325756593/src/com/dong/week1/List.java b/group16/1325756593/src/com/dong/week1/List.java
new file mode 100644
index 0000000000..adc694241a
--- /dev/null
+++ b/group16/1325756593/src/com/dong/week1/List.java
@@ -0,0 +1,9 @@
+package com.dong.week1;
+
+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/group16/1325756593/src/com/dong/week1/Queue.java b/group16/1325756593/src/com/dong/week1/Queue.java
new file mode 100644
index 0000000000..445390a168
--- /dev/null
+++ b/group16/1325756593/src/com/dong/week1/Queue.java
@@ -0,0 +1,24 @@
+package com.dong.week1;
+
+public class Queue {
+	private ArrayList elementData = new ArrayList();
+	
+	public void enQueue(Object o){		
+		elementData.add(elementData.size(), o);
+	}
+	
+	public Object deQueue(){
+		if(elementData.size()==0){
+			throw new IndexOutOfBoundsException("����Ϊ��");
+		}
+		return elementData.remove(0);
+	}
+	
+	public boolean isEmpty(){
+		return elementData.size()==0;
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group16/1325756593/src/com/dong/week1/Stack.java b/group16/1325756593/src/com/dong/week1/Stack.java
new file mode 100644
index 0000000000..1dea6cdfd9
--- /dev/null
+++ b/group16/1325756593/src/com/dong/week1/Stack.java
@@ -0,0 +1,31 @@
+package com.dong.week1;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){		
+		elementData.add(o);
+	}
+	
+	
+	public Object pop(){
+		if(elementData.size()==0){
+			throw new IndexOutOfBoundsException("ջΪ��");
+		}
+		return elementData.remove(elementData.size()-1);
+		
+	}
+	
+	public Object peek(){
+		if(elementData.size()==0){
+			throw new IndexOutOfBoundsException("ջΪ��");
+		}
+		return elementData.get(elementData.size()-1);
+	}
+	public boolean isEmpty(){
+		return elementData.size()==0;
+	}
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group16/1924332561/.classpath b/group16/1924332561/.classpath
new file mode 100644
index 0000000000..fb5011632c
--- /dev/null
+++ b/group16/1924332561/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group16/1924332561/.project b/group16/1924332561/.project
new file mode 100644
index 0000000000..5f960262bc
--- /dev/null
+++ b/group16/1924332561/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>1924332561Learning</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group16/1924332561/.settings/org.eclipse.core.resources.prefs b/group16/1924332561/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000000..99f26c0203
--- /dev/null
+++ b/group16/1924332561/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/group16/1924332561/src/com/coding/basic/ArrayList.java b/group16/1924332561/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..3fc0960e08
--- /dev/null
+++ b/group16/1924332561/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,41 @@
+package com.coding.basic;
+
+public class ArrayList implements List{
+	private int size = 0;
+	
+	private Object[] elementDate = new Object[100];
+	
+	
+	@Override
+	public void add(Object o) {
+		
+		this.elementDate[this.size]=o;
+		this.size++;
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		
+	}
+
+	@Override
+	public Object get(int dex) {
+		 
+		return null;
+	}
+
+	@Override
+	public Object remove(int index) {
+		return null;
+	}
+
+	@Override
+	public int size() {
+		return -1;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+	
+}
diff --git a/group16/1924332561/src/com/coding/basic/BinaryTreeNode.java b/group16/1924332561/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..e7d9e43e24
--- /dev/null
+++ b/group16/1924332561/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,29 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	private Object date;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+	public Object getDate() {
+		return date;
+	}
+	public void setDate(Object date) {
+		this.date = date;
+	}
+	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){
+			return null;
+	}
+}
diff --git a/group16/1924332561/src/com/coding/basic/Iterator.java b/group16/1924332561/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..e7cbd474ec
--- /dev/null
+++ b/group16/1924332561/src/com/coding/basic/Iterator.java
@@ -0,0 +1,6 @@
+package com.coding.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+}
diff --git a/group16/1924332561/src/com/coding/basic/LinkedList.java b/group16/1924332561/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..d39557be29
--- /dev/null
+++ b/group16/1924332561/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,62 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+	
+	private static class Node{
+		Object date;
+		Node next;
+	}
+	
+	private Node head;
+	
+	
+	@Override
+	public void add(Object o) {
+
+	}
+
+	@Override
+	public void add(int index, Object o) {
+
+	}
+
+	@Override
+	public Object get(int dex) {
+		return null;
+	}
+
+	@Override
+	public Object remove(int index) {
+		return null;
+	}
+
+	@Override
+	public int size() {
+		
+		return 0;
+	}
+	
+	public void addFirst(Object o){
+		
+	}
+	
+	public void addLast(Object o){
+		
+	}
+	
+	public Object removeFirst(){
+		
+		return null;
+	}
+	
+	public Object removeLast(){
+		
+		return null;
+	}
+	
+	public Iterator iterator(){
+		
+		return null;
+	}
+	
+}
diff --git a/group16/1924332561/src/com/coding/basic/List.java b/group16/1924332561/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..d48b1f4827
--- /dev/null
+++ b/group16/1924332561/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/group16/1924332561/src/com/coding/basic/Queue.java b/group16/1924332561/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..7dc7b4820a
--- /dev/null
+++ b/group16/1924332561/src/com/coding/basic/Queue.java
@@ -0,0 +1,23 @@
+package com.coding.basic;
+
+public class Queue {
+	
+	public void enQueue(){
+		
+		
+	}
+	public Object deQueue(){
+		
+		return null;
+	}
+	
+	public boolean isEmpty(){
+		
+		return false;
+	}
+	
+	public int size(){
+		
+		return -1;
+	}
+}
diff --git a/group16/1924332561/src/com/coding/basic/Stack.java b/group16/1924332561/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..7a49c48279
--- /dev/null
+++ b/group16/1924332561/src/com/coding/basic/Stack.java
@@ -0,0 +1,29 @@
+package com.coding.basic;
+
+public class Stack {
+	private ArrayList elementDate = new ArrayList();
+	
+	public void push(Object o){
+		
+	}
+	
+	public Object pop(){
+		
+		return null;
+	}
+	
+	public Object peek(){
+		
+		return null;
+	}
+	
+	public boolean isEmpty(){
+		
+		return false;
+	}
+	
+	public int size(){
+		
+		return -1;
+	}
+}
diff --git a/group16/214074094/readme.txt b/group16/214074094/readme.txt
new file mode 100644
index 0000000000..c1b06ddcc2
--- /dev/null
+++ b/group16/214074094/readme.txt
@@ -0,0 +1 @@
+I am 北京-Shane
diff --git a/group16/214074094/src/com/coding/basic/ArrayList.java b/group16/214074094/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..158c866d45
--- /dev/null
+++ b/group16/214074094/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,165 @@
+package coding.basic;
+
+
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+/**
+ * @Author shane
+ * @Time 2017/2/25 13:06
+ * @Email stevenchenguang@gmail.com
+ * @Desc OwnArrayList
+ */
+public class ArrayList implements List {
+
+    private int size = 0;
+
+    private final static Object[] EMPTY_ELEMENTDATA = {};
+
+    /**
+     * 默认容量
+     */
+    private static int DEFAULT_CAPACITY = 10;
+
+    private Object[] elementData;
+
+    public ArrayList() {
+        this.elementData = EMPTY_ELEMENTDATA;
+    }
+
+    @Override
+    public void add(Object o) {
+        if (elementData == EMPTY_ELEMENTDATA) {
+            elementData = Arrays.copyOf(elementData, DEFAULT_CAPACITY);
+            elementData[0] = o;
+        } else if (size < elementData.length) {
+            elementData[size] = o;
+        } else {
+            _grow();
+            elementData[size] = o;
+        }
+        size++;
+        _analyze();
+    }
+
+    @Override
+    public void add(int index, Object o) {
+        if (index < 0) {
+            throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
+        }
+        if (elementData == EMPTY_ELEMENTDATA) {
+            if (index != 0) {
+                throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
+            } else {
+                elementData = new Object[DEFAULT_CAPACITY];
+                elementData[0] = o;
+            }
+        } else if (index > size) {
+            throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
+        } else if (index == size) {
+            _grow();
+            elementData[size] = o;
+            size++;
+        } else {
+            if (elementData.length == size) {
+                _grow();
+            }
+            System.arraycopy(elementData, index, elementData, index + 1, size - index);
+            elementData[index] = o;
+            size++;
+        }
+        _analyze();
+    }
+
+    @Override
+    public Object get(int index) {
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
+        }
+        return elementData[index];
+    }
+
+    @Override
+    public Object remove(int index) {
+
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
+        }
+        Object oldValue = elementData[index];
+        //需要复制的长度
+        int needMoveLength = size - index - 1;
+        //如果该长度小于0,　说明只有一个元素,　直接置空即可
+        if (needMoveLength > 0) {
+            System.arraycopy(elementData, index + 1, elementData, index, needMoveLength);
+        }
+        elementData[--size] = null;
+        _analyze();
+        return oldValue;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    public Iterator iterator() {
+        return new ArrayListItrator();
+    }
+
+    /**
+     * @Author: shane
+     * @Time: 2017/2/25 20:18
+     * @Email: stevenchenguang@gmail.com
+     * @param:
+     * @Return:
+     * @Throw:
+     * @Desc: 返回真实长度的数组数据
+     */
+    private void _analyze() {
+        if (size < elementData.length) {
+            elementData = Arrays.copyOf(elementData, size);
+        }
+    }
+
+    /**
+     * @Author: shane
+     * @Time: 2017/2/25 20:19
+     * @Email: stevenchenguang@gmail.com
+     * @param:
+     * @Return:
+     * @Throw:
+     * @Desc: 将数组的长度扩容至2倍
+     */
+    private void _grow() {
+        elementData = Arrays.copyOf(elementData, elementData.length << 1);
+    }
+
+    @Override
+    public String toString() {
+        return Arrays.toString(elementData);
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    private class ArrayListItrator implements Iterator {
+
+        private int position = 0;
+
+        @Override
+        public boolean hasNext() {
+            return position != size;
+        }
+
+        @Override
+        public Object next() {
+            int i = position;
+            if (i >= size) {
+                throw new NoSuchElementException();
+            }
+            position = i + 1;
+            return elementData[i];
+        }
+    }
+}
diff --git a/group16/214074094/src/com/coding/basic/BinaryTreeNode.java b/group16/214074094/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..b40066ebe1
--- /dev/null
+++ b/group16/214074094/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,39 @@
+package coding.basic;
+
+public class BinaryTreeNode {
+
+    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) {
+        return null;
+    }
+
+}
diff --git a/group16/214074094/src/com/coding/basic/Iterator.java b/group16/214074094/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..1acc5349a4
--- /dev/null
+++ b/group16/214074094/src/com/coding/basic/Iterator.java
@@ -0,0 +1,9 @@
+package coding.basic;
+
+public interface Iterator {
+
+    boolean hasNext();
+
+    Object next();
+
+}
diff --git a/group16/214074094/src/com/coding/basic/LinkedList.java b/group16/214074094/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..9108c2b6fe
--- /dev/null
+++ b/group16/214074094/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,222 @@
+package coding.basic;
+
+/**
+ * @Author shane
+ * @Time 2017/2/25 21:01
+ * @Email stevenchenguang@gmail.com
+ * @Desc OwnLinkedList
+ */
+public class LinkedList implements List {
+
+    private int size = 0;
+
+    private Node first;
+
+    private Node last;
+
+    public void add(Object o) {
+        if (size == 0) {
+            first = new Node(null, o, null);
+            last = first;
+            size++;
+        } else {
+            addLast(o);
+        }
+    }
+
+    public void add(int index, Object o) {
+        _checkIndex(index);
+        if (index == size - 1) {
+            addLast(o);
+        } else {
+            Node prev = _node(index);
+            Node next = _node(index + 1);
+            Node newNode = new Node(prev, o, next);
+            prev.next = newNode;
+            next.prev = newNode;
+            size++;
+        }
+    }
+
+    public Object get(int index) {
+        _checkIndex(index);
+        return node(index);
+    }
+
+    public Object remove(int index) {
+        _checkIndex(index);
+        if (index == 0) {
+            return removeFirst();
+        } else if (index == size - 1) {
+            return removeLast();
+        }
+        Node curr = _node(index);
+        Object data = curr.data;
+        final Node prev = curr.prev;
+        final Node next = curr.next;
+
+        prev.next = next;
+        next.prev = prev;
+        curr = null;
+        size--;
+
+        return data;
+    }
+
+    private Object removeFirst() {
+        Node oldFirst = first;
+        Object data = first.data;
+        final Node oldSecond = oldFirst.next;
+        if (null == oldSecond) {
+            first = null;
+            last = null;
+        } else {
+            oldSecond.prev = null;
+            first = oldSecond;
+            oldFirst = null;
+        }
+        size--;
+        return data;
+    }
+
+    private Object removeLast() {
+        Node oldLast = last;
+        Object data = last.data;
+        final Node oldLastButOne = last.prev;
+        if (null == oldLastButOne) {
+            first = null;
+            last = null;
+        } else {
+            oldLastButOne.next = null;
+            last = oldLastButOne;
+            oldLast = null;
+        }
+        size--;
+        return data;
+    }
+
+    public void addFirst(Object o) {
+        final Node oldFirst = first;
+        final Node param = new Node(null, o, null);
+        if (null == oldFirst) {
+            first = param;
+        } else {
+            oldFirst.prev = param;
+            param.next = oldFirst;
+            first = param;
+        }
+        size++;
+    }
+
+    public void addLast(Object o) {
+        final Node n = last;
+        final Node newNode = new Node(n, o, null);
+        last = newNode;
+        n.next = newNode;
+        size++;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public Iterator iterator() {
+        return null;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    private static class Node {
+        Node prev;
+        Object data;
+        Node next;
+
+        public Node(Node prev, Object data, Node next) {
+            this.prev = prev;
+            this.data = data;
+            this.next = next;
+        }
+    }
+
+    /**
+     * @Author: shane
+     * @Time: 2017/2/25 22:44
+     * @Email: stevenchenguang@gmail.com
+     * @param: int index
+     * @Return: Node
+     * @Throw:
+     * @Desc: 根据下标获取节点元素上的数据
+     */
+    private Object node(int index) {
+        //如果下标在左一半, 从左往右取
+        if (index < size >> 1) {
+            Node tmp = first;
+            for (int i = 0; i < index; i++) {
+                tmp = tmp.next;
+            }
+            return tmp.data;
+        } else {
+            Node tmp = last;
+            for (int i = size - 1; i > index; i--) {
+                tmp = tmp.prev;
+            }
+            return tmp.data;
+        }
+    }
+
+    /**
+     * @Author: shane
+     * @Time: 2017/2/25 22:44
+     * @Email: stevenchenguang@gmail.com
+     * @param: int index
+     * @Return: Node
+     * @Throw:
+     * @Desc: 根据下标获取节点元素
+     */
+    private Node _node(int index) {
+        //如果下标在左一半, 从左往右取
+        if (index < size >> 1) {
+            Node tmp = first;
+            for (int i = 0; i < index; i++) {
+                tmp = tmp.next;
+            }
+            return tmp;
+        } else {
+            Node tmp = last;
+            for (int i = size - 1; i > index; i--) {
+                tmp = tmp.prev;
+            }
+            return tmp;
+        }
+    }
+
+    /**
+     * @Author: shane
+     * @Time: 2017/2/25 22:43
+     * @Email: stevenchenguang@gmail.com
+     * @param: int index
+     * @Return:
+     * @Throw: IndexOutOfBoundsException
+     * @Desc: 校验下标是否合法
+     */
+    private void _checkIndex(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
+        }
+    }
+
+    @Override
+    public String toString() {
+        if (0 == size) {
+            return "[]";
+        }
+        StringBuffer sb = new StringBuffer();
+        for (int i = 0; i < this.size; i++) {
+            sb.append(get(i)).append(", ");
+        }
+        String tmp = sb.substring(0, sb.length() - 2);
+        return "[" + tmp + "]";
+    }
+}
\ No newline at end of file
diff --git a/group16/214074094/src/com/coding/basic/List.java b/group16/214074094/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..5da9b0d4c6
--- /dev/null
+++ b/group16/214074094/src/com/coding/basic/List.java
@@ -0,0 +1,15 @@
+package coding.basic;
+
+public interface List {
+
+    void add(Object o);
+
+    void add(int index, Object o);
+
+    Object get(int index);
+
+    Object remove(int index);
+
+    int size();
+
+}
diff --git a/group16/214074094/src/com/coding/basic/Queue.java b/group16/214074094/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..869d0f7333
--- /dev/null
+++ b/group16/214074094/src/com/coding/basic/Queue.java
@@ -0,0 +1,36 @@
+package coding.basic;
+
+/**
+ * @Author shane
+ * @Time 2017/2/26 17:19
+ * @Email stevenchenguang@gmail.com
+ * @Desc Own Queue
+ */
+public class Queue {
+
+    private LinkedList elementData = new LinkedList();
+
+    public void enQueue(Object o) {
+        elementData.add(o);
+    }
+
+    public Object deQueue() {
+        if (isEmpty()) {
+            throw new RuntimeException("Queue is empty");
+        }
+        return elementData.remove(0);
+    }
+
+    public boolean isEmpty() {
+        return elementData.isEmpty();
+    }
+
+    public int size() {
+        return elementData.size();
+    }
+
+    @Override
+    public String toString() {
+        return elementData.toString();
+    }
+}
diff --git a/group16/214074094/src/com/coding/basic/Stack.java b/group16/214074094/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..7ef1c9ad06
--- /dev/null
+++ b/group16/214074094/src/com/coding/basic/Stack.java
@@ -0,0 +1,37 @@
+package coding.basic;
+
+/**
+ * @Author shane
+ * @Time 2017/2/26 16:55
+ * @Email stevenchenguang@gmail.com
+ * @Desc Own Stack
+ */
+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.isEmpty();
+    }
+
+    public int size() {
+        return elementData.size();
+    }
+
+    @Override
+    public String toString() {
+        return elementData.toString();
+    }
+}
diff --git a/group16/214074094/src/com/reading/blog_test.txt b/group16/214074094/src/com/reading/blog_test.txt
new file mode 100644
index 0000000000..b7e5cbfe14
--- /dev/null
+++ b/group16/214074094/src/com/reading/blog_test.txt
@@ -0,0 +1 @@
+just test new fork
\ No newline at end of file
diff --git a/group16/214074094/src/test/coding/basic/AbstractTest.java b/group16/214074094/src/test/coding/basic/AbstractTest.java
new file mode 100644
index 0000000000..80eaaa6fe5
--- /dev/null
+++ b/group16/214074094/src/test/coding/basic/AbstractTest.java
@@ -0,0 +1,19 @@
+package coding.basic;
+
+/**
+ * @Author shane
+ * @Time 2017/2/25 13:06
+ * @Email stevenchenguang@gmail.com
+ * @Desc 测试基类
+ */
+public class AbstractTest {
+
+    protected void printStar() {
+        System.out.println("********************************************");
+    }
+
+    protected void printHyphen() {
+        System.out.println("--------------------------------------------");
+    }
+
+}
diff --git a/group16/214074094/src/test/coding/basic/ArrayListTest.java b/group16/214074094/src/test/coding/basic/ArrayListTest.java
new file mode 100644
index 0000000000..2f03342d61
--- /dev/null
+++ b/group16/214074094/src/test/coding/basic/ArrayListTest.java
@@ -0,0 +1,81 @@
+package coding.basic;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @Author shane
+ * @Time 2017/2/25 13:02
+ * @Email stevenchenguang@gmail.com
+ * @Desc ...
+ */
+
+public class ArrayListTest extends AbstractTest {
+
+    private static ArrayList list;
+
+    @Before
+    public void before() {
+
+        list = new ArrayList();
+        list.add("a");
+        list.add("b");
+        list.add("c");
+        list.add("d");
+        list.add("e");
+
+        printStar();
+        System.out.println("Before Test data :" + list);
+        printHyphen();
+    }
+
+    @After
+    public void after() {
+        printHyphen();
+        System.out.println("After Test data : " + list);
+        printStar();
+    }
+
+    @Test
+    public void testAddI() {
+        int index = list.size();
+        list.add(index, "test add i");
+        Assert.assertEquals(list.get(index), "test add i");
+    }
+
+    @Test
+    public void test() {
+        java.util.ArrayList<String> list = new java.util.ArrayList<String>();
+        list.add("a");
+        list.add("b");
+        java.util.Iterator<String> it = list.iterator();
+        while (it.hasNext()) {
+
+        }
+        System.out.println(it.next());
+        System.out.println(it.next());
+        System.out.println(it.next());
+    }
+
+    @Test
+    public void testSize() {
+        Assert.assertEquals(5, list.size());
+    }
+
+    @Test
+    public void testRemove() {
+        list.remove(5);
+        Assert.assertEquals(list.get(3), "d");
+    }
+
+    @Test
+    public void testIterator() {
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            System.out.println(it.next());
+        }
+    }
+
+}
diff --git a/group16/214074094/src/test/coding/basic/LinkedListTest.java b/group16/214074094/src/test/coding/basic/LinkedListTest.java
new file mode 100644
index 0000000000..bc78728a25
--- /dev/null
+++ b/group16/214074094/src/test/coding/basic/LinkedListTest.java
@@ -0,0 +1,63 @@
+package coding.basic;
+
+import junit.framework.Assert;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @Author shane
+ * @Time 2017/2/25 23:32
+ * @Email stevenchenguang@gmail.com
+ * @Desc ...
+ */
+public class LinkedListTest extends AbstractTest {
+
+    private static LinkedList list;
+
+    @Before
+    public void before() {
+        list = new LinkedList();
+        list.add("a");
+        list.add("b");
+        list.add("c");
+        list.add("d");
+        list.add("e");
+
+        printStar();
+        System.out.println("Before Test data :" + list);
+        printHyphen();
+    }
+
+    @After
+    public void after() {
+        printHyphen();
+        System.out.println("After Test data : " + list);
+        printStar();
+    }
+
+    @Test
+    public void testAddIndex() {
+        list.add(0, "after a");
+        Assert.assertEquals("after a", list.get(1));
+
+        list.add(3, "after c");
+        Assert.assertEquals("after c", list.get(4));
+
+        list.add(6, "after e");
+        Assert.assertEquals("after e", list.get(7));
+    }
+
+    @Test
+    public void testRemove() {
+        list.remove(0);
+        Assert.assertEquals("b", list.get(0));
+
+        list.remove(list.size() - 1);
+        Assert.assertEquals("d", list.get(list.size() - 1));
+
+        Object obj = list.remove(1);
+        Assert.assertEquals("c", obj);
+        Assert.assertEquals(2, list.size());
+    }
+}
diff --git a/group16/214074094/src/test/coding/basic/QueueTest.java b/group16/214074094/src/test/coding/basic/QueueTest.java
new file mode 100644
index 0000000000..12302783b3
--- /dev/null
+++ b/group16/214074094/src/test/coding/basic/QueueTest.java
@@ -0,0 +1,62 @@
+package coding.basic;
+
+import junit.framework.Assert;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @Author shane
+ * @Time 2017/2/26 17:24
+ * @Email stevenchenguang@gmail.com
+ * @Desc ...
+ */
+public class QueueTest extends AbstractTest {
+
+    private static Queue queue;
+
+    @Before
+    public void before() {
+        queue = new Queue();
+
+        queue.enQueue("a");
+        queue.enQueue("b");
+        queue.enQueue("c");
+        queue.enQueue("d");
+        queue.enQueue("e");
+
+        printStar();
+        System.out.println("Before Test data :" + queue);
+        printHyphen();
+    }
+
+    @After
+    public void after() {
+        printHyphen();
+        System.out.println("After Test data : " + queue);
+        printStar();
+    }
+
+    @Test
+    public void testDeQueueAndIsEmpty() {
+        Assert.assertEquals("a", queue.deQueue());
+
+        queue.deQueue();
+        queue.deQueue();
+        queue.deQueue();
+        queue.deQueue();
+
+        Assert.assertEquals(true, queue.isEmpty());
+
+        try {
+            queue.deQueue();
+        } catch (RuntimeException e) {
+            Assert.assertEquals("Queue is empty", e.getMessage());
+        }
+    }
+
+    @Test
+    public void testSize() {
+        Assert.assertEquals(5, queue.size());
+    }
+}
diff --git a/group16/214074094/src/test/coding/basic/StackTest.java b/group16/214074094/src/test/coding/basic/StackTest.java
new file mode 100644
index 0000000000..f289744a67
--- /dev/null
+++ b/group16/214074094/src/test/coding/basic/StackTest.java
@@ -0,0 +1,68 @@
+package coding.basic;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @Author shane
+ * @Time 2017/2/26 16:58
+ * @Email stevenchenguang@gmail.com
+ * @Desc ...
+ */
+public class StackTest extends AbstractTest {
+
+    private static Stack stack;
+
+    @Before
+    public void before() {
+        stack = new Stack();
+
+        stack.push("a");
+        stack.push("b");
+        stack.push("c");
+        stack.push("d");
+        stack.push("e");
+
+        printStar();
+        System.out.println("Before Test data :" + stack);
+        printHyphen();
+    }
+
+    @After
+    public void after() {
+        printHyphen();
+        System.out.println("After Test data : " + stack);
+        printStar();
+    }
+
+    @Test
+    public void testPop() {
+        Assert.assertEquals("e", stack.pop());
+    }
+
+    @Test
+    public void testPeek() {
+        Assert.assertEquals("e", stack.peek());
+    }
+
+    @Test
+    public void testIsEmpty() {
+        Assert.assertEquals(false, stack.isEmpty());
+
+        stack.pop();
+        stack.pop();
+        stack.pop();
+        stack.pop();
+        stack.pop();
+
+        Assert.assertEquals(true, stack.isEmpty());
+    }
+
+    @Test
+    public void testSize() {
+        Assert.assertEquals(5, stack.size());
+    }
+
+}
diff --git a/group16/214074094/target/production/214074094/reading/blog_test.txt b/group16/214074094/target/production/214074094/reading/blog_test.txt
new file mode 100644
index 0000000000..b7e5cbfe14
--- /dev/null
+++ b/group16/214074094/target/production/214074094/reading/blog_test.txt
@@ -0,0 +1 @@
+just test new fork
\ No newline at end of file
diff --git a/group16/2562124714/.idea/dictionaries/zhangwj.xml b/group16/2562124714/.idea/dictionaries/zhangwj.xml
new file mode 100644
index 0000000000..d07fd80ae1
--- /dev/null
+++ b/group16/2562124714/.idea/dictionaries/zhangwj.xml
@@ -0,0 +1,3 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="zhangwj" />
+</component>
\ No newline at end of file
diff --git a/group16/2562124714/.idea/misc.xml b/group16/2562124714/.idea/misc.xml
new file mode 100644
index 0000000000..e97ef03f44
--- /dev/null
+++ b/group16/2562124714/.idea/misc.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_7" default="true" project-jdk-name="1.7" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+  <component name="masterDetails">
+    <states>
+      <state key="ProjectJDKs.UI">
+        <settings>
+          <last-edited>1.7</last-edited>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+    </states>
+  </component>
+</project>
\ No newline at end of file
diff --git a/group16/2562124714/.idea/modules.xml b/group16/2562124714/.idea/modules.xml
new file mode 100644
index 0000000000..c3fdba38f0
--- /dev/null
+++ b/group16/2562124714/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/2562124714.iml" filepath="$PROJECT_DIR$/2562124714.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/group16/2562124714/.idea/workspace.xml b/group16/2562124714/.idea/workspace.xml
new file mode 100644
index 0000000000..d357c0f9a1
--- /dev/null
+++ b/group16/2562124714/.idea/workspace.xml
@@ -0,0 +1,780 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="4037d4be-1274-4d54-a028-6cb3f091f598" name="Default" comment="" />
+    <ignored path="$PROJECT_DIR$/out/" />
+    <option name="EXCLUDED_CONVERTED_TO_IGNORED" value="true" />
+    <option name="TRACKING_ENABLED" value="true" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="CreatePatchCommitExecutor">
+    <option name="PATCH_PATH" value="" />
+  </component>
+  <component name="ExecutionTargetManager" SELECTED_TARGET="default_target" />
+  <component name="FileEditorManager">
+    <leaf SIDE_TABS_SIZE_LIMIT_KEY="300">
+      <file leaf-file-name="TreeData.java" pinned="false" current-in-tab="false">
+        <entry file="file://$PROJECT_DIR$/src/com/coding/basic/TreeData.java">
+          <provider selected="true" editor-type-id="text-editor">
+            <state relative-caret-position="266">
+              <caret line="19" column="5" lean-forward="true" selection-start-line="19" selection-start-column="5" selection-end-line="19" selection-end-column="5" />
+              <folding />
+            </state>
+          </provider>
+        </entry>
+      </file>
+      <file leaf-file-name="BinaryTreeNode.java" pinned="false" current-in-tab="false">
+        <entry file="file://$PROJECT_DIR$/src/com/coding/basic/BinaryTreeNode.java">
+          <provider selected="true" editor-type-id="text-editor">
+            <state relative-caret-position="323">
+              <caret line="27" column="26" lean-forward="false" selection-start-line="27" selection-start-column="21" selection-end-line="27" selection-end-column="26" />
+              <folding>
+                <element signature="e#414#415#0" expanded="true" />
+                <element signature="e#437#438#0" expanded="true" />
+                <element signature="e#473#474#0" expanded="true" />
+                <element signature="e#492#493#0" expanded="true" />
+              </folding>
+            </state>
+          </provider>
+        </entry>
+      </file>
+      <file leaf-file-name="BinaryTreeNodeTest.java" pinned="false" current-in-tab="true">
+        <entry file="file://$PROJECT_DIR$/src/Test/BinaryTreeNodeTest.java">
+          <provider selected="true" editor-type-id="text-editor">
+            <state relative-caret-position="152">
+              <caret line="14" column="61" lean-forward="true" selection-start-line="14" selection-start-column="61" selection-end-line="14" selection-end-column="61" />
+              <folding />
+            </state>
+          </provider>
+        </entry>
+      </file>
+      <file leaf-file-name="TestRunner.java" pinned="false" current-in-tab="false">
+        <entry file="file://$PROJECT_DIR$/src/Test/TestRunner.java">
+          <provider selected="true" editor-type-id="text-editor">
+            <state relative-caret-position="114">
+              <caret line="6" column="0" lean-forward="true" selection-start-line="6" selection-start-column="0" selection-end-line="6" selection-end-column="0" />
+              <folding>
+                <element signature="imports" expanded="true" />
+              </folding>
+            </state>
+          </provider>
+        </entry>
+      </file>
+      <file leaf-file-name="Stack.java" pinned="false" current-in-tab="false">
+        <entry file="file://$PROJECT_DIR$/src/com/coding/basic/Stack.java">
+          <provider selected="true" editor-type-id="text-editor">
+            <state relative-caret-position="437">
+              <caret line="25" column="9" lean-forward="true" selection-start-line="25" selection-start-column="9" selection-end-line="25" selection-end-column="9" />
+              <folding />
+            </state>
+          </provider>
+        </entry>
+      </file>
+      <file leaf-file-name="StackTest.java" pinned="false" current-in-tab="false">
+        <entry file="file://$PROJECT_DIR$/src/Test/StackTest.java">
+          <provider selected="true" editor-type-id="text-editor">
+            <state relative-caret-position="247">
+              <caret line="20" column="22" lean-forward="false" selection-start-line="20" selection-start-column="18" selection-end-line="20" selection-end-column="22" />
+              <folding />
+            </state>
+          </provider>
+        </entry>
+      </file>
+      <file leaf-file-name="Queue.java" pinned="false" current-in-tab="false">
+        <entry file="file://$PROJECT_DIR$/src/com/coding/basic/Queue.java">
+          <provider selected="true" editor-type-id="text-editor">
+            <state relative-caret-position="114">
+              <caret line="8" column="4" lean-forward="true" selection-start-line="8" selection-start-column="4" selection-end-line="8" selection-end-column="4" />
+              <folding />
+            </state>
+          </provider>
+        </entry>
+      </file>
+      <file leaf-file-name="QueueTest.java" pinned="false" current-in-tab="false">
+        <entry file="file://$PROJECT_DIR$/src/Test/QueueTest.java">
+          <provider selected="true" editor-type-id="text-editor">
+            <state relative-caret-position="152">
+              <caret line="16" column="12" lean-forward="false" selection-start-line="16" selection-start-column="12" selection-end-line="22" selection-end-column="9" />
+              <folding />
+            </state>
+          </provider>
+        </entry>
+      </file>
+    </leaf>
+  </component>
+  <component name="FileTemplateManagerImpl">
+    <option name="RECENT_TEMPLATES">
+      <list>
+        <option value="Class" />
+        <option value="JUnit4 Test Class" />
+      </list>
+    </option>
+  </component>
+  <component name="FindInProjectRecents">
+    <findStrings>
+      <find>binaryTree.PriOder</find>
+    </findStrings>
+  </component>
+  <component name="GradleLocalSettings">
+    <option name="externalProjectsViewState">
+      <projects_view />
+    </option>
+  </component>
+  <component name="IdeDocumentHistory">
+    <option name="CHANGED_PATHS">
+      <list>
+        <option value="$PROJECT_DIR$/src/com/coding/basic/List.java" />
+        <option value="$PROJECT_DIR$/src/com/coding/basic/Queue.java" />
+        <option value="$PROJECT_DIR$/src/com/coding/basic/TestJunit.java" />
+        <option value="$PROJECT_DIR$/src/com/coding/basic/TestRunner.java" />
+        <option value="$PROJECT_DIR$/src/com/coding/basic/ArrayList.java" />
+        <option value="$PROJECT_DIR$/src/Test/ArrayListTest.java" />
+        <option value="$PROJECT_DIR$/src/com/coding/basic/LinkedList.java" />
+        <option value="$PROJECT_DIR$/src/Test/LinkedListTest.java" />
+        <option value="$PROJECT_DIR$/src/Test/QueueTest.java" />
+        <option value="$PROJECT_DIR$/src/Test/StackTest.java" />
+        <option value="$PROJECT_DIR$/src/com/coding/basic/Stack.java" />
+        <option value="$PROJECT_DIR$/src/com/coding/basic/TreeData.java" />
+        <option value="$PROJECT_DIR$/src/Test/TestRunner.java" />
+        <option value="$PROJECT_DIR$/src/com/coding/basic/BinaryTreeNode.java" />
+        <option value="$PROJECT_DIR$/src/Test/BinaryTreeNodeTest.java" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectFrameBounds">
+    <option name="x" value="-8" />
+    <option name="y" value="-8" />
+    <option name="width" value="1924" />
+    <option name="height" value="1056" />
+  </component>
+  <component name="ProjectView">
+    <navigator currentView="ProjectPane" proportions="" version="1">
+      <flattenPackages />
+      <showMembers />
+      <showModules />
+      <showLibraryContents />
+      <hideEmptyPackages />
+      <abbreviatePackageNames />
+      <autoscrollToSource />
+      <autoscrollFromSource />
+      <sortByType />
+      <manualOrder />
+      <foldersAlwaysOnTop value="true" />
+    </navigator>
+    <panes>
+      <pane id="Scratches" />
+      <pane id="ProjectPane">
+        <subPane>
+          <PATH>
+            <PATH_ELEMENT>
+              <option name="myItemId" value="2562124714" />
+              <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.ProjectViewProjectNode" />
+            </PATH_ELEMENT>
+            <PATH_ELEMENT>
+              <option name="myItemId" value="2562124714" />
+              <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.PsiDirectoryNode" />
+            </PATH_ELEMENT>
+          </PATH>
+          <PATH>
+            <PATH_ELEMENT>
+              <option name="myItemId" value="2562124714" />
+              <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.ProjectViewProjectNode" />
+            </PATH_ELEMENT>
+            <PATH_ELEMENT>
+              <option name="myItemId" value="2562124714" />
+              <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.PsiDirectoryNode" />
+            </PATH_ELEMENT>
+            <PATH_ELEMENT>
+              <option name="myItemId" value="src" />
+              <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.PsiDirectoryNode" />
+            </PATH_ELEMENT>
+            <PATH_ELEMENT>
+              <option name="myItemId" value="Test" />
+              <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.PsiDirectoryNode" />
+            </PATH_ELEMENT>
+          </PATH>
+          <PATH>
+            <PATH_ELEMENT>
+              <option name="myItemId" value="2562124714" />
+              <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.ProjectViewProjectNode" />
+            </PATH_ELEMENT>
+            <PATH_ELEMENT>
+              <option name="myItemId" value="2562124714" />
+              <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.PsiDirectoryNode" />
+            </PATH_ELEMENT>
+            <PATH_ELEMENT>
+              <option name="myItemId" value="src" />
+              <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.PsiDirectoryNode" />
+            </PATH_ELEMENT>
+            <PATH_ELEMENT>
+              <option name="myItemId" value="basic" />
+              <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.PsiDirectoryNode" />
+            </PATH_ELEMENT>
+          </PATH>
+        </subPane>
+      </pane>
+      <pane id="PackagesPane" />
+      <pane id="Scope" />
+    </panes>
+  </component>
+  <component name="PropertiesComponent">
+    <property name="settings.editor.selected.configurable" value="reference.settings.ide.settings.spelling" />
+    <property name="com.intellij.testIntegration.createTest.CreateTestDialog.defaultLibrary" value="JUnit4" />
+  </component>
+  <component name="RecentsManager">
+    <key name="CreateTestDialog.RecentsKey">
+      <recent name="Test" />
+    </key>
+    <key name="CreateTestDialog.Recents.Supers">
+      <recent name="" />
+    </key>
+  </component>
+  <component name="RunManager" selected="Application.TestRunner (1)">
+    <configuration default="false" name="TestRunner" type="Application" factoryName="Application" temporary="true" nameIsGenerated="true">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
+        <pattern>
+          <option name="PATTERN" value="com.coding.basic.*" />
+          <option name="ENABLED" value="true" />
+        </pattern>
+      </extension>
+      <option name="MAIN_CLASS_NAME" value="com.coding.basic.TestRunner" />
+      <option name="VM_PARAMETERS" />
+      <option name="PROGRAM_PARAMETERS" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="ENABLE_SWING_INSPECTOR" value="false" />
+      <option name="ENV_VARIABLES" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <module name="2562124714" />
+      <envs />
+      <method />
+    </configuration>
+    <configuration default="false" name="TestJunit.testAdd" type="JUnit" factoryName="JUnit" temporary="true" nameIsGenerated="true">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
+        <pattern>
+          <option name="PATTERN" value="com.coding.basic.*" />
+          <option name="ENABLED" value="true" />
+        </pattern>
+      </extension>
+      <module name="2562124714" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="PACKAGE_NAME" value="com.coding.basic" />
+      <option name="MAIN_CLASS_NAME" value="com.coding.basic.TestJunit" />
+      <option name="METHOD_NAME" value="testAdd" />
+      <option name="TEST_OBJECT" value="method" />
+      <option name="VM_PARAMETERS" value="-ea" />
+      <option name="PARAMETERS" />
+      <option name="WORKING_DIRECTORY" value="$MODULE_DIR$" />
+      <option name="ENV_VARIABLES" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <option name="TEST_SEARCH_SCOPE">
+        <value defaultName="singleModule" />
+      </option>
+      <envs />
+      <patterns />
+      <method />
+    </configuration>
+    <configuration default="false" name="TestRunner (1)" type="Application" factoryName="Application" temporary="true" nameIsGenerated="true">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
+        <pattern>
+          <option name="PATTERN" value="Test.*" />
+          <option name="ENABLED" value="true" />
+        </pattern>
+      </extension>
+      <option name="MAIN_CLASS_NAME" value="Test.TestRunner" />
+      <option name="VM_PARAMETERS" />
+      <option name="PROGRAM_PARAMETERS" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="ENABLE_SWING_INSPECTOR" value="false" />
+      <option name="ENV_VARIABLES" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <module name="2562124714" />
+      <envs />
+      <method />
+    </configuration>
+    <configuration default="false" name="BinaryTreeNodeTest" type="JUnit" factoryName="JUnit" temporary="true" nameIsGenerated="true">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
+        <pattern>
+          <option name="PATTERN" value="Test.*" />
+          <option name="ENABLED" value="true" />
+        </pattern>
+      </extension>
+      <module name="2562124714" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="PACKAGE_NAME" value="Test" />
+      <option name="MAIN_CLASS_NAME" value="Test.BinaryTreeNodeTest" />
+      <option name="METHOD_NAME" />
+      <option name="TEST_OBJECT" value="class" />
+      <option name="VM_PARAMETERS" value="-ea" />
+      <option name="PARAMETERS" />
+      <option name="WORKING_DIRECTORY" value="$MODULE_DIR$" />
+      <option name="ENV_VARIABLES" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <option name="TEST_SEARCH_SCOPE">
+        <value defaultName="singleModule" />
+      </option>
+      <envs />
+      <patterns />
+      <method />
+    </configuration>
+    <configuration default="true" type="#org.jetbrains.idea.devkit.run.PluginConfigurationType" factoryName="Plugin">
+      <module name="" />
+      <option name="VM_PARAMETERS" value="-Xmx512m -Xms256m -XX:MaxPermSize=250m -ea" />
+      <option name="PROGRAM_PARAMETERS" />
+      <predefined_log_file id="idea.log" enabled="true" />
+      <method />
+    </configuration>
+    <configuration default="true" type="AndroidRunConfigurationType" factoryName="Android App">
+      <module name="" />
+      <option name="DEPLOY" value="true" />
+      <option name="ARTIFACT_NAME" value="" />
+      <option name="PM_INSTALL_OPTIONS" value="" />
+      <option name="ACTIVITY_EXTRA_FLAGS" value="" />
+      <option name="MODE" value="default_activity" />
+      <option name="TARGET_SELECTION_MODE" value="SHOW_DIALOG" />
+      <option name="PREFERRED_AVD" value="" />
+      <option name="CLEAR_LOGCAT" value="false" />
+      <option name="SHOW_LOGCAT_AUTOMATICALLY" value="false" />
+      <option name="SKIP_NOOP_APK_INSTALLATIONS" value="true" />
+      <option name="FORCE_STOP_RUNNING_APP" value="true" />
+      <option name="DEBUGGER_TYPE" value="Java" />
+      <option name="USE_LAST_SELECTED_DEVICE" value="false" />
+      <option name="PREFERRED_AVD" value="" />
+      <Java />
+      <Profilers>
+        <option name="ENABLE_ADVANCED_PROFILING" value="true" />
+        <option name="GAPID_ENABLED" value="false" />
+        <option name="GAPID_DISABLE_PCS" value="false" />
+        <option name="SUPPORT_LIB_ENABLED" value="true" />
+        <option name="INSTRUMENTATION_ENABLED" value="true" />
+      </Profilers>
+      <option name="DEEP_LINK" value="" />
+      <option name="ACTIVITY_CLASS" value="" />
+      <method />
+    </configuration>
+    <configuration default="true" type="AndroidTestRunConfigurationType" factoryName="Android Tests">
+      <module name="" />
+      <option name="TESTING_TYPE" value="0" />
+      <option name="INSTRUMENTATION_RUNNER_CLASS" value="" />
+      <option name="METHOD_NAME" value="" />
+      <option name="CLASS_NAME" value="" />
+      <option name="PACKAGE_NAME" value="" />
+      <option name="EXTRA_OPTIONS" value="" />
+      <option name="TARGET_SELECTION_MODE" value="SHOW_DIALOG" />
+      <option name="PREFERRED_AVD" value="" />
+      <option name="CLEAR_LOGCAT" value="false" />
+      <option name="SHOW_LOGCAT_AUTOMATICALLY" value="false" />
+      <option name="SKIP_NOOP_APK_INSTALLATIONS" value="true" />
+      <option name="FORCE_STOP_RUNNING_APP" value="true" />
+      <option name="DEBUGGER_TYPE" value="Java" />
+      <option name="USE_LAST_SELECTED_DEVICE" value="false" />
+      <option name="PREFERRED_AVD" value="" />
+      <Java />
+      <Profilers>
+        <option name="ENABLE_ADVANCED_PROFILING" value="true" />
+        <option name="GAPID_ENABLED" value="false" />
+        <option name="GAPID_DISABLE_PCS" value="false" />
+        <option name="SUPPORT_LIB_ENABLED" value="true" />
+        <option name="INSTRUMENTATION_ENABLED" value="true" />
+      </Profilers>
+      <method />
+    </configuration>
+    <configuration default="true" type="Applet" factoryName="Applet">
+      <option name="HTML_USED" value="false" />
+      <option name="WIDTH" value="400" />
+      <option name="HEIGHT" value="300" />
+      <option name="POLICY_FILE" value="$APPLICATION_HOME_DIR$/bin/appletviewer.policy" />
+      <module />
+      <method />
+    </configuration>
+    <configuration default="true" type="Application" factoryName="Application">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+      <option name="MAIN_CLASS_NAME" />
+      <option name="VM_PARAMETERS" />
+      <option name="PROGRAM_PARAMETERS" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="ENABLE_SWING_INSPECTOR" value="false" />
+      <option name="ENV_VARIABLES" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <module name="" />
+      <envs />
+      <method />
+    </configuration>
+    <configuration default="true" type="GradleRunConfiguration" factoryName="Gradle">
+      <ExternalSystemSettings>
+        <option name="executionName" />
+        <option name="externalProjectPath" />
+        <option name="externalSystemIdString" value="GRADLE" />
+        <option name="scriptParameters" />
+        <option name="taskDescriptions">
+          <list />
+        </option>
+        <option name="taskNames">
+          <list />
+        </option>
+        <option name="vmOptions" />
+      </ExternalSystemSettings>
+      <method />
+    </configuration>
+    <configuration default="true" type="JUnit" factoryName="JUnit">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+      <module name="" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="PACKAGE_NAME" />
+      <option name="MAIN_CLASS_NAME" />
+      <option name="METHOD_NAME" />
+      <option name="TEST_OBJECT" value="class" />
+      <option name="VM_PARAMETERS" value="-ea" />
+      <option name="PARAMETERS" />
+      <option name="WORKING_DIRECTORY" value="$MODULE_DIR$" />
+      <option name="ENV_VARIABLES" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <option name="TEST_SEARCH_SCOPE">
+        <value defaultName="singleModule" />
+      </option>
+      <envs />
+      <patterns />
+      <method />
+    </configuration>
+    <configuration default="true" type="JarApplication" factoryName="JAR Application">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+      <envs />
+      <method />
+    </configuration>
+    <configuration default="true" type="Java Scratch" factoryName="Java Scratch">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+      <option name="SCRATCH_FILE_ID" value="0" />
+      <option name="MAIN_CLASS_NAME" />
+      <option name="VM_PARAMETERS" />
+      <option name="PROGRAM_PARAMETERS" />
+      <option name="WORKING_DIRECTORY" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="ENABLE_SWING_INSPECTOR" value="false" />
+      <option name="ENV_VARIABLES" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <module name="" />
+      <envs />
+      <method />
+    </configuration>
+    <configuration default="true" type="JetRunConfigurationType" factoryName="Kotlin">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+      <option name="MAIN_CLASS_NAME" />
+      <option name="VM_PARAMETERS" />
+      <option name="PROGRAM_PARAMETERS" />
+      <option name="WORKING_DIRECTORY" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <module name="2562124714" />
+      <envs />
+      <method />
+    </configuration>
+    <configuration default="true" type="KotlinStandaloneScriptRunConfigurationType" factoryName="Kotlin script">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+      <option name="filePath" />
+      <option name="vmParameters" />
+      <option name="alternativeJrePath" />
+      <option name="programParameters" />
+      <option name="passParentEnvs" value="true" />
+      <option name="workingDirectory" />
+      <option name="isAlternativeJrePathEnabled" value="false" />
+      <envs />
+      <method />
+    </configuration>
+    <configuration default="true" type="Remote" factoryName="Remote">
+      <option name="USE_SOCKET_TRANSPORT" value="true" />
+      <option name="SERVER_MODE" value="false" />
+      <option name="SHMEM_ADDRESS" value="javadebug" />
+      <option name="HOST" value="localhost" />
+      <option name="PORT" value="5005" />
+      <method />
+    </configuration>
+    <configuration default="true" type="TestNG" factoryName="TestNG">
+      <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+      <module name="" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+      <option name="ALTERNATIVE_JRE_PATH" />
+      <option name="SUITE_NAME" />
+      <option name="PACKAGE_NAME" />
+      <option name="MAIN_CLASS_NAME" />
+      <option name="METHOD_NAME" />
+      <option name="GROUP_NAME" />
+      <option name="TEST_OBJECT" value="CLASS" />
+      <option name="VM_PARAMETERS" value="-ea" />
+      <option name="PARAMETERS" />
+      <option name="WORKING_DIRECTORY" value="$MODULE_DIR$" />
+      <option name="OUTPUT_DIRECTORY" />
+      <option name="ANNOTATION_TYPE" />
+      <option name="ENV_VARIABLES" />
+      <option name="PASS_PARENT_ENVS" value="true" />
+      <option name="TEST_SEARCH_SCOPE">
+        <value defaultName="singleModule" />
+      </option>
+      <option name="USE_DEFAULT_REPORTERS" value="false" />
+      <option name="PROPERTIES_FILE" />
+      <envs />
+      <properties />
+      <listeners />
+      <method />
+    </configuration>
+    <list size="4">
+      <item index="0" class="java.lang.String" itemvalue="Application.TestRunner" />
+      <item index="1" class="java.lang.String" itemvalue="JUnit.TestJunit.testAdd" />
+      <item index="2" class="java.lang.String" itemvalue="Application.TestRunner (1)" />
+      <item index="3" class="java.lang.String" itemvalue="JUnit.BinaryTreeNodeTest" />
+    </list>
+    <recent_temporary>
+      <list size="4">
+        <item index="0" class="java.lang.String" itemvalue="Application.TestRunner (1)" />
+        <item index="1" class="java.lang.String" itemvalue="JUnit.BinaryTreeNodeTest" />
+        <item index="2" class="java.lang.String" itemvalue="JUnit.TestJunit.testAdd" />
+        <item index="3" class="java.lang.String" itemvalue="Application.TestRunner" />
+      </list>
+    </recent_temporary>
+  </component>
+  <component name="ShelveChangesManager" show_recycled="false">
+    <option name="remove_strategy" value="false" />
+  </component>
+  <component name="SvnConfiguration">
+    <configuration />
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="4037d4be-1274-4d54-a028-6cb3f091f598" name="Default" comment="" />
+      <created>1487640652721</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1487640652721</updated>
+    </task>
+    <servers />
+  </component>
+  <component name="TestHistory">
+    <history-entry file="BinaryTreeNodeTest - 2017.02.23 at 17h 15m 08s.xml">
+      <configuration name="BinaryTreeNodeTest" configurationId="JUnit" />
+    </history-entry>
+    <history-entry file="TestJunit_testAdd - 2017.02.23 at 10h 27m 39s.xml">
+      <configuration name="TestJunit.testAdd" configurationId="JUnit" />
+    </history-entry>
+  </component>
+  <component name="ToolWindowManager">
+    <frame x="-8" y="-8" width="1924" height="1056" extended-state="0" />
+    <editor active="false" />
+    <layout>
+      <window_info id="Palette" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
+      <window_info id="TODO" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="6" side_tool="false" content_ui="tabs" />
+      <window_info id="Nl-Palette" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
+      <window_info id="Messages" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
+      <window_info id="Palette&#9;" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
+      <window_info id="Image Layers" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
+      <window_info id="Capture Analysis" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
+      <window_info id="Event Log" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="7" side_tool="true" content_ui="tabs" />
+      <window_info id="Maven Projects" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
+      <window_info id="Run" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.32980973" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
+      <window_info id="Version Control" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="false" weight="0.33" sideWeight="0.5" order="7" side_tool="false" content_ui="tabs" />
+      <window_info id="Properties" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
+      <window_info id="Terminal" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="7" side_tool="false" content_ui="tabs" />
+      <window_info id="Capture Tool" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
+      <window_info id="Designer" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
+      <window_info id="Project" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="true" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="0" side_tool="false" content_ui="combo" />
+      <window_info id="Find" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
+      <window_info id="Structure" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
+      <window_info id="Ant Build" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
+      <window_info id="UI Designer" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
+      <window_info id="Theme Preview" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
+      <window_info id="Debug" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
+      <window_info id="Favorites" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="true" content_ui="tabs" />
+      <window_info id="Cvs" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="4" side_tool="false" content_ui="tabs" />
+      <window_info id="Message" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
+      <window_info id="Commander" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
+      <window_info id="Hierarchy" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="2" side_tool="false" content_ui="combo" />
+      <window_info id="Inspection" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="5" side_tool="false" content_ui="tabs" />
+    </layout>
+  </component>
+  <component name="VcsContentAnnotationSettings">
+    <option name="myLimit" value="2678400000" />
+  </component>
+  <component name="XDebuggerManager">
+    <breakpoint-manager>
+      <option name="time" value="1" />
+    </breakpoint-manager>
+    <watches-manager />
+  </component>
+  <component name="antWorkspaceConfiguration">
+    <option name="IS_AUTOSCROLL_TO_SOURCE" value="false" />
+    <option name="FILTER_TARGETS" value="false" />
+  </component>
+  <component name="editorHistoryManager">
+    <entry file="file://$PROJECT_DIR$/src/com/coding/basic/BinaryTreeNode.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="247">
+          <caret line="23" column="5" lean-forward="true" selection-start-line="23" selection-start-column="5" selection-end-line="23" selection-end-column="5" />
+          <folding>
+            <element signature="e#230#231#0" expanded="false" />
+            <element signature="e#252#253#0" expanded="false" />
+            <element signature="e#290#291#0" expanded="false" />
+            <element signature="e#317#318#0" expanded="false" />
+            <element signature="e#414#415#0" expanded="true" />
+            <element signature="e#437#438#0" expanded="true" />
+            <element signature="e#473#474#0" expanded="true" />
+            <element signature="e#492#493#0" expanded="true" />
+            <element signature="e#538#539#0" expanded="false" />
+            <element signature="e#563#564#0" expanded="false" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/com/coding/basic/TreeData.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="0">
+          <caret line="0" column="0" lean-forward="false" selection-start-line="0" selection-start-column="0" selection-end-line="0" selection-end-column="0" />
+          <folding />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/com/coding/basic/List.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="133">
+          <caret line="7" column="22" lean-forward="true" selection-start-line="7" selection-start-column="22" selection-end-line="7" selection-end-column="22" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/com/coding/basic/ArrayList.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="-152">
+          <caret line="25" column="23" lean-forward="false" selection-start-line="25" selection-start-column="23" selection-end-line="25" selection-end-column="23" />
+          <folding>
+            <element signature="e#247#248#0" expanded="true" />
+            <element signature="e#268#269#0" expanded="true" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/com/coding/basic/TestJunit.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="133">
+          <caret line="7" column="24" lean-forward="false" selection-start-line="7" selection-start-column="24" selection-end-line="7" selection-end-column="24" />
+          <folding>
+            <element signature="imports" expanded="true" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/Test/ArrayListTest.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="1045">
+          <caret line="61" column="5" lean-forward="true" selection-start-line="61" selection-start-column="5" selection-end-line="61" selection-end-column="5" />
+          <folding />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/com/coding/basic/LinkedList.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="131">
+          <caret line="104" column="35" lean-forward="true" selection-start-line="104" selection-start-column="35" selection-end-line="104" selection-end-column="35" />
+          <folding />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/Test/LinkedListTest.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="323">
+          <caret line="72" column="52" lean-forward="true" selection-start-line="72" selection-start-column="52" selection-end-line="72" selection-end-column="52" />
+          <folding />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/com/coding/basic/TestRunner.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="285">
+          <caret line="15" column="71" lean-forward="false" selection-start-line="15" selection-start-column="62" selection-end-line="15" selection-end-column="71" />
+          <folding>
+            <element signature="imports" expanded="true" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/com/coding/basic/Queue.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="114">
+          <caret line="8" column="4" lean-forward="true" selection-start-line="8" selection-start-column="4" selection-end-line="8" selection-end-column="4" />
+          <folding />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/Test/QueueTest.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="152">
+          <caret line="16" column="12" lean-forward="false" selection-start-line="16" selection-start-column="12" selection-end-line="22" selection-end-column="9" />
+          <folding />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/Test/StackTest.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="247">
+          <caret line="20" column="22" lean-forward="false" selection-start-line="20" selection-start-column="18" selection-end-line="20" selection-end-column="22" />
+          <folding />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/com/coding/basic/Stack.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="437">
+          <caret line="25" column="9" lean-forward="true" selection-start-line="25" selection-start-column="9" selection-end-line="25" selection-end-column="9" />
+          <folding />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/com/coding/basic/TreeData.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="266">
+          <caret line="19" column="5" lean-forward="true" selection-start-line="19" selection-start-column="5" selection-end-line="19" selection-end-column="5" />
+          <folding />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/com/coding/basic/BinaryTreeNode.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="323">
+          <caret line="27" column="26" lean-forward="false" selection-start-line="27" selection-start-column="21" selection-end-line="27" selection-end-column="26" />
+          <folding>
+            <element signature="e#414#415#0" expanded="true" />
+            <element signature="e#437#438#0" expanded="true" />
+            <element signature="e#473#474#0" expanded="true" />
+            <element signature="e#492#493#0" expanded="true" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/Test/TestRunner.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="114">
+          <caret line="6" column="0" lean-forward="true" selection-start-line="6" selection-start-column="0" selection-end-line="6" selection-end-column="0" />
+          <folding>
+            <element signature="imports" expanded="true" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/src/Test/BinaryTreeNodeTest.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="152">
+          <caret line="14" column="61" lean-forward="true" selection-start-line="14" selection-start-column="61" selection-end-line="14" selection-end-column="61" />
+          <folding />
+        </state>
+      </provider>
+    </entry>
+  </component>
+</project>
\ No newline at end of file
diff --git a/group16/2562124714/2562124714.iml b/group16/2562124714/2562124714.iml
new file mode 100644
index 0000000000..3a8ffcf1f5
--- /dev/null
+++ b/group16/2562124714/2562124714.iml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library name="JUnit4">
+        <CLASSES>
+          <root url="jar://$APPLICATION_HOME_DIR$/lib/junit-4.12.jar!/" />
+          <root url="jar://$APPLICATION_HOME_DIR$/lib/hamcrest-core-1.3.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>
\ No newline at end of file
diff --git a/group16/2562124714/src/Test/ArrayListTest.java b/group16/2562124714/src/Test/ArrayListTest.java
new file mode 100644
index 0000000000..9bd8f2aeca
--- /dev/null
+++ b/group16/2562124714/src/Test/ArrayListTest.java
@@ -0,0 +1,70 @@
+package Test;
+
+import com.coding.basic.ArrayList;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by zhangwj on 2017/2/23.
+ */
+public class ArrayListTest {
+     private static ArrayList arraylist = new ArrayList();
+    @BeforeClass
+    public static void setUp() throws Exception {
+
+        System.out.println("初始化变量");
+        for (Integer i = 0; i < 5; i++)
+        {
+            arraylist.add(i);
+        }
+
+
+    }
+
+    @After
+    public void tearDown() throws Exception {
+
+    }
+
+    @Test
+    public void add() throws Exception {
+        Integer i = arraylist.size();
+        Integer AddElement = 999;
+        arraylist.add(AddElement);
+        assertEquals(i + 1, arraylist.size());
+        assertEquals(AddElement, arraylist.get(arraylist.size()));
+        arraylist.remove(arraylist.size());
+    }
+
+    @Test
+    public void add1() throws Exception {
+        Integer AddElement = 999;
+        arraylist.add(1, AddElement);
+        assertEquals(AddElement, arraylist.get(1));
+        arraylist.remove(1);
+    }
+
+    @Test
+    public void get() throws Exception {
+            assertEquals(null, arraylist.get(9999));
+    }
+
+    @Test
+    public void remove() throws Exception {
+        Integer i = (Integer)arraylist.get(1);
+        assertEquals(i, arraylist.remove(1));
+        arraylist.add(1, i);
+
+    }
+
+    @Test
+    public void size() throws Exception {
+            assertEquals(5, arraylist.size());
+
+    }
+
+}
\ No newline at end of file
diff --git a/group16/2562124714/src/Test/BinaryTreeNodeTest.java b/group16/2562124714/src/Test/BinaryTreeNodeTest.java
new file mode 100644
index 0000000000..7d8f4fdd01
--- /dev/null
+++ b/group16/2562124714/src/Test/BinaryTreeNodeTest.java
@@ -0,0 +1,100 @@
+package Test;
+
+import com.coding.basic.BinaryTreeNode;
+import com.coding.basic.TreeData;
+import com.sun.org.apache.bcel.internal.generic.NEW;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by zhangwj on 2017/2/23.
+ */
+public class BinaryTreeNodeTest {
+    private BinaryTreeNode binaryTree = new BinaryTreeNode();
+    @Before
+    public void setUp() throws Exception {
+        //System.out.println("初始化二叉树，5, 4, 7");
+        TreeData element = new TreeData();
+        element.setT((Integer)5);
+        binaryTree.insert(element);
+        TreeData element2 = new TreeData();
+        element2.setT((Integer)4);
+        binaryTree.insert(element2);
+        TreeData element3 = new TreeData();
+        element3.setT((Integer)7);
+        binaryTree.insert(element3);
+//        binaryTree.PriOder(this.binaryTree);
+    }
+
+    @Test
+    public void getData() throws Exception {
+        assertEquals(5, binaryTree.getData().getT());
+
+    }
+
+    @Test
+    public void setData() throws Exception {
+        TreeData element = new TreeData();
+        element.setT(6);
+        binaryTree.setData(element);
+        assertEquals(6, binaryTree.getData().getT());
+//        binaryTree.PriOder(this.binaryTree);
+
+    }
+
+    @Test
+    public void getLeft() throws Exception {
+        assertEquals(4, binaryTree.getLeft().getData().getT());
+
+    }
+
+    @Test
+    public void setLeft() throws Exception {
+        TreeData element = new TreeData();
+        element.setT(2);
+        BinaryTreeNode NewTreeNode = new BinaryTreeNode();
+        NewTreeNode.setData(element);
+        binaryTree.setLeft(NewTreeNode);
+        assertEquals(2, binaryTree.getLeft().getData().getT());
+//        binaryTree.PriOder(this.binaryTree);
+    }
+
+    @Test
+    public void getRight() throws Exception {
+        assertEquals(7, binaryTree.getRight().getData().getT());
+
+    }
+
+    @Test
+    public void setRight() throws Exception {
+        TreeData element = new TreeData();
+        element.setT(9);
+        BinaryTreeNode NewTreeNode = new BinaryTreeNode();
+        NewTreeNode.setData(element);
+        binaryTree.setRight(NewTreeNode);
+        assertEquals(9, binaryTree.getRight().getData().getT());
+    }
+
+    @Test
+    public void priOder() throws Exception {
+
+
+    }
+
+    @Test
+    public void insert() throws Exception {
+        TreeData element = new TreeData();
+        element.setT(2);
+        binaryTree.insert(element);
+        binaryTree.PriOder(this.binaryTree);
+        element.setT(9);
+        binaryTree.insert(element);
+        binaryTree.PriOder(this.binaryTree);
+        element.setT(8);
+//        binaryTree.PriOder(this.binaryTree);
+
+    }
+
+}
\ No newline at end of file
diff --git a/group16/2562124714/src/Test/LinkedListTest.java b/group16/2562124714/src/Test/LinkedListTest.java
new file mode 100644
index 0000000000..276b389f15
--- /dev/null
+++ b/group16/2562124714/src/Test/LinkedListTest.java
@@ -0,0 +1,81 @@
+package Test;
+
+import com.coding.basic.LinkedList;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by zhangwj on 2017/2/23.
+ */
+public class LinkedListTest {
+    private LinkedList linkedlist = new LinkedList();
+
+    @Before
+    public void Init()
+    {
+        System.out.println("初始化");
+        linkedlist.add(9.9);
+        linkedlist.add(9.99);
+    }
+
+
+    @Test
+    public void add() throws Exception {
+        linkedlist.add(8.8);
+        assertEquals(3, linkedlist.size());
+        System.out.println("after add size is " + linkedlist.size());
+        System.out.println("after add last element is " + linkedlist.get(linkedlist.size()));
+
+    }
+
+    @Test
+    public void add1() throws Exception {
+        linkedlist.add(2, 7.7);
+        assertEquals(3, linkedlist.size());
+        System.out.println("after add in 2th size is " + linkedlist.size());
+        System.out.println("after add 2th element is " + linkedlist.get(2));
+    }
+
+    @Test
+    public void get() throws Exception {
+        assertEquals(9.9, linkedlist.get(1));
+    }
+
+    @Test
+    public void remove() throws Exception {
+        assertEquals(9.9, linkedlist.remove(1));
+    }
+
+    @Test
+    public void size() throws Exception {
+        assertEquals(2, linkedlist.size());
+
+    }
+
+    @Test
+    public void addFirst() throws Exception {
+        linkedlist.addFirst(3.3);
+        assertEquals(3.3, linkedlist.get(1));
+//        System.out.println();
+    }
+
+    @Test
+    public void addLast() throws Exception {
+        linkedlist.addLast(3.3);
+        assertEquals(3.3, linkedlist.get(linkedlist.size()));
+
+    }
+
+    @Test
+    public void removeFirst() throws Exception {
+        assertEquals(9.9, linkedlist.removeFirst());
+    }
+
+    @Test
+    public void removeLast() throws Exception {
+        assertEquals(9.99, linkedlist.removeLast());
+    }
+
+}
\ No newline at end of file
diff --git a/group16/2562124714/src/Test/QueueTest.java b/group16/2562124714/src/Test/QueueTest.java
new file mode 100644
index 0000000000..3f0557f262
--- /dev/null
+++ b/group16/2562124714/src/Test/QueueTest.java
@@ -0,0 +1,58 @@
+package Test;
+
+import com.coding.basic.Queue;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by zhangwj on 2017/2/23.
+ */
+public class QueueTest {
+    private Queue queue = new Queue();
+    @Before
+    public void setUp() throws Exception {
+            System.out.println("初始化队列,元素为a,b,c,d");
+
+            String[] s = {"a", "b","c","d"};
+        for (String a:s
+             ) {
+            queue.enQueue(a);
+        }
+
+    }
+
+    @After
+    public void tearDown() throws Exception {
+
+    }
+
+    @Test
+    public void enQueue() throws Exception {
+            queue.enQueue("dasdas");
+            assertEquals(5, queue.size());
+//            assertEquals("dasdas", queue.);
+    }
+
+    @Test
+    public void deQueue() throws Exception {
+        assertEquals("a",queue.deQueue());
+        assertEquals(3, queue.size());
+
+    }
+
+    @Test
+    public void isEmpty() throws Exception {
+        assertEquals(false, queue.isEmpty());
+
+    }
+
+    @Test
+    public void size() throws Exception {
+        assertEquals(4, queue.size());
+
+    }
+
+}
\ No newline at end of file
diff --git a/group16/2562124714/src/Test/StackTest.java b/group16/2562124714/src/Test/StackTest.java
new file mode 100644
index 0000000000..0a36d4dc0f
--- /dev/null
+++ b/group16/2562124714/src/Test/StackTest.java
@@ -0,0 +1,57 @@
+package Test;
+
+import com.coding.basic.Stack;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by zhangwj on 2017/2/23.
+ */
+public class StackTest {
+    private Stack stack = new Stack();
+    @Before
+    public void setUp() throws Exception {
+        System.out.println("初始化栈,元素为a,b,c,d");
+
+        String[] s = {"a", "b","c","d"};
+        for (String a:s
+                ) {
+            stack.push(a);
+        }
+
+    }
+
+    @Test
+    public void push() throws Exception {
+        stack.push("aaa");
+        assertEquals(5, stack.size());
+        assertEquals("aaa", stack.peek());
+
+    }
+
+    @Test
+    public void pop() throws Exception {
+        assertEquals("d", stack.pop());
+        assertEquals(3, stack.size());
+
+    }
+
+    @Test
+    public void peek() throws Exception {
+        assertEquals("d", stack.peek());
+        assertEquals(4, stack.size());
+    }
+
+    @Test
+    public void isEmpty() throws Exception {
+        assertEquals(false, stack.isEmpty());
+    }
+
+    @Test
+    public void size() throws Exception {
+        assertEquals(4, stack.size());
+    }
+
+}
\ No newline at end of file
diff --git a/group16/2562124714/src/Test/TestRunner.java b/group16/2562124714/src/Test/TestRunner.java
new file mode 100644
index 0000000000..2bf465f832
--- /dev/null
+++ b/group16/2562124714/src/Test/TestRunner.java
@@ -0,0 +1,19 @@
+package Test;
+
+import org.junit.runner.JUnitCore;
+import org.junit.runner.notification.Failure;
+
+import javax.xml.transform.Result;
+
+/**
+ * Created by zhangwj on 2017/2/23. 调用测试类 可重复使用
+ */
+public class TestRunner {
+    public static  void  main(String[] args) {
+        org.junit.runner.Result result = JUnitCore.runClasses(BinaryTreeNodeTest.class);
+        for (Failure failure:result.getFailures()) {
+            System.out.println(failure.toString());
+        }
+        System.out.println(result.wasSuccessful());
+    }
+}
diff --git a/group16/2562124714/src/com/coding/basic/ArrayList.java b/group16/2562124714/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..f1d5a9fdd9
--- /dev/null
+++ b/group16/2562124714/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,100 @@
+package com.coding.basic;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+
+	private int Scale; //每次扩展大小
+	
+	private Object[] elementData = new Object[100];
+
+	public ArrayList()
+	{
+		this.Scale = 10;
+	}
+
+	public ArrayList(int i)
+	{
+		this.Scale = i;
+	}
+
+	public void add(Object o){
+		if (this.size == elementData.length)
+		{
+			DoEnlage();
+		}
+		elementData[size] = o;
+		this.size++;
+	}
+
+	private void DoEnlage()
+	{
+		if (this.Scale >= 1 && this.Scale <= 10000)
+		{
+			Object[] NewElementData = new Object[this.elementData.length + this.Scale];
+			System.arraycopy(this.elementData,0,NewElementData,0,this.elementData.length);
+
+			this.elementData = NewElementData;
+		}
+
+	}
+
+	//index从1开始 位置1，2，3，4，5，6
+	public void add(int index, Object o){
+		if (this.size == elementData.length)
+		{
+			DoEnlage();
+		}
+		int i = 0;
+		//遍历赋值
+		for(i = this.size; i >= index;i--)
+		{
+			this.elementData[i] = this.elementData[i - 1];
+		}
+
+		this.elementData[i] = o;
+		this.size++;
+
+	}
+	
+	public Object get(int index){
+		if (index >= 1 && index <= this.size)
+		{
+			return this.elementData[index - 1];
+		}
+		else {
+			return null;
+		}
+
+
+	}
+	
+	public Object remove(int index){
+		if (index >= 1 && index <= this.size)
+		{
+			int i = 0;
+			Object DelElement = this.elementData[index - 1];
+			for(i = index; i <= this.size; i++)
+			{
+				this.elementData[i - 1] = this.elementData[i];
+			}
+			this.elementData[i] = null;
+			this.size--;
+
+			return DelElement;
+
+		}
+		else {
+			return null;
+		}
+	}
+	
+	public int size(){
+		return this.size;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+	
+}
diff --git a/group16/2562124714/src/com/coding/basic/BinaryTreeNode.java b/group16/2562124714/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..a703ad3165
--- /dev/null
+++ b/group16/2562124714/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,94 @@
+package com.coding.basic;
+
+import java.util.Properties;
+
+public class BinaryTreeNode {
+
+	private TreeData treeData;
+	//private Object data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+	
+	public TreeData getData() {
+		return treeData;
+	}
+	public void setData(TreeData data) {
+		this.treeData = 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 void PriOder(BinaryTreeNode Node)
+	{
+		if (Node.treeData != null)
+		{
+				System.out.println(Node.treeData.getT());
+				if (Node.left != null)
+				{
+					PriOder(Node.left);
+				}
+				if (Node.right != null)
+				{
+					PriOder(Node.right);
+				}
+		}
+
+	}
+
+	
+	public BinaryTreeNode insert(TreeData o){
+		if (this.treeData == null && this.left == null && this.right == null)
+		{
+			this.treeData = o;
+			this.left = null;
+			this.right = null;
+			return null;
+		}
+
+		//遍历寻找元素应该插入的位置
+		if (o.compareTo(this.treeData) <= 0)
+		{
+			if (this.left != null)
+			{
+				this.left.insert(o);
+			}
+			else
+			{
+				BinaryTreeNode NewNode = new BinaryTreeNode();
+				NewNode.setData(o);
+				NewNode.setLeft(null);
+				NewNode.setRight(null);
+				this.left = NewNode;
+			}
+		}
+		else
+		{
+			if (this.right != null)
+			{
+				this.right.insert(o);
+			}
+			else
+			{
+				BinaryTreeNode NewNode = new BinaryTreeNode();
+				NewNode.setData(o);
+				NewNode.setLeft(null);
+				NewNode.setRight(null);
+				this.right = NewNode;
+			}
+		}
+
+
+		return  null;
+	}
+	
+}
diff --git a/group16/2562124714/src/com/coding/basic/Iterator.java b/group16/2562124714/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..06ef6311b2
--- /dev/null
+++ b/group16/2562124714/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/group16/2562124714/src/com/coding/basic/LinkedList.java b/group16/2562124714/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..f1de0a6839
--- /dev/null
+++ b/group16/2562124714/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,200 @@
+package com.coding.basic;
+
+import com.sun.org.apache.bcel.internal.generic.NEW;
+
+import java.awt.*;
+
+public class LinkedList implements List {
+	public LinkedList()
+	{
+		head = null;
+		this.Size = 0;
+	}
+	
+	private Node head;
+	private int Size;
+	
+	public void add(Object o){
+		Node NewNode = new Node(o);
+
+		if (this.head == null)
+		{
+			head = NewNode;
+		}
+		else
+		{
+			Node node;
+			for (node = head; node.next != null; node = node.next)
+			{
+			}
+			node.next = NewNode;
+		}
+		this.Size++;
+		
+	}
+	//index为位置1，2，3，4，5，6，7
+	public void add(int index , Object o){
+		Node NewNode = new Node(o);
+
+		if (1 == index)
+		{
+			NewNode.next = head;
+			head = NewNode;
+		}
+		else {
+			Node node;
+			int i = 0;
+			for (i = 1, node = head; i < index - 1; i++, node = node.next) {
+			}
+			NewNode.next = node.next;
+			node.next = NewNode;
+		}
+		this.Size++;
+		
+	}
+	public Object get(int index){
+		Node node;
+		int i = 0;
+
+		for (i = 1, node = head; i < index ; i++, node = node.next) {
+		}
+
+		return node.data;
+//		return null;
+	}
+	public Object remove(int index){
+		Node node;
+		int i = 0;
+
+		if (1 == index)
+		{
+			if (head.next == null)
+			{
+				Object DelData = head.data;
+				head = null;
+				this.Size--;
+				return DelData;
+			}
+			else
+			{
+				Node DelNode = head;
+				head = DelNode.next;
+				DelNode.next = null;
+				this.Size--;
+				return	 DelNode.data;
+
+			}
+		}
+		else {
+
+			for (i = 1, node = head; i < index - 1; i++, node = node.next) {
+			}
+			Node DelNode = node.next;
+			node.next = DelNode.next;
+			DelNode.next = null;
+			this.Size--;
+			return DelNode.data;
+		}
+	}
+	
+	public int size(){
+
+		return this.Size;
+	}
+	
+	public void addFirst(Object o){
+		Node NewNode = new Node(o);
+
+		if (null == this.head)
+		{
+			NewNode.next = null;
+			head = NewNode;
+		}
+		else
+		{
+			NewNode.next = head;
+			head = NewNode;
+		}
+
+		this.Size++;
+		
+	}
+	public void addLast(Object o){
+		Node NewNode = new Node(o);
+
+		if (this.Size == 0)
+		{
+			NewNode.next = null;
+			head = NewNode;
+		}
+		else
+		{
+//			int i = 0;
+			Node node;
+			for (node = head; node.next != null; node = node.next) {
+
+			}
+			node.next = NewNode;
+		}
+
+		this.Size++;
+		
+	}
+	public Object removeFirst(){
+		Node DelFirst;
+
+		if (1 == this.Size)
+		{
+			DelFirst = this.head;
+			DelFirst.next = null;
+			head = null;
+		}
+		else
+		{
+			DelFirst = this.head;
+			head = head.next;
+			DelFirst.next = null;
+		}
+		this.Size--;
+
+		return DelFirst.data;
+	}
+	public Object removeLast(){
+		Node DelLast;
+
+		if (1 == this.Size)
+		{
+			DelLast = head;
+			DelLast.next = null;
+			head = null;
+		}
+		else
+		{
+			Node node;
+			for (node = head; node.next.next != null; node = node.next) {
+
+			}
+			DelLast = node.next;
+			node.next = null;
+		}
+		this.Size--;
+
+		return DelLast.data;
+	}
+	public Iterator iterator(){
+		return null;
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+
+		public  Node(Object o)
+		{
+			this.data = o;
+			this.next = null;
+		}
+		
+	}
+}
diff --git a/group16/2562124714/src/com/coding/basic/List.java b/group16/2562124714/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ b/group16/2562124714/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/group16/2562124714/src/com/coding/basic/Queue.java b/group16/2562124714/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..40b8f22607
--- /dev/null
+++ b/group16/2562124714/src/com/coding/basic/Queue.java
@@ -0,0 +1,24 @@
+package com.coding.basic;
+
+public class Queue {
+	private ArrayList elementData = new ArrayList();
+
+	public void enQueue(Object o){
+		elementData.add(o);
+	}
+	
+	public Object deQueue(){
+
+
+		return elementData.get(1);
+	}
+	
+	public boolean isEmpty(){
+
+		return elementData.size() == 0 ? true : false;
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group16/2562124714/src/com/coding/basic/Stack.java b/group16/2562124714/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..9dba3befa5
--- /dev/null
+++ b/group16/2562124714/src/com/coding/basic/Stack.java
@@ -0,0 +1,34 @@
+package com.coding.basic;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+
+//	public Stack()
+//	{
+//		elementData
+//	}
+
+	public void push(Object o){
+		elementData.add(o);
+	}
+	
+	public Object pop(){
+		Object o = elementData.remove(elementData.size());
+		return o;
+	}
+	
+	public Object peek(){
+		Object o = elementData.get(elementData.size());
+		return o;
+	}
+	public boolean isEmpty(){
+		if (elementData.size() == 0)
+		{
+			return true;
+		}
+		return false;
+	}
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group16/2562124714/src/com/coding/basic/TestJunit.java b/group16/2562124714/src/com/coding/basic/TestJunit.java
new file mode 100644
index 0000000000..59ef43a992
--- /dev/null
+++ b/group16/2562124714/src/com/coding/basic/TestJunit.java
@@ -0,0 +1,17 @@
+package com.coding.basic;
+import org.junit.Test;
+import  static  org.junit.Assert.assertEquals;
+
+/**
+ * Created by zhangwj on 2017/2/23.
+ */
+public class TestJunit {
+    @Test
+
+    public void testAdd()
+    {
+        String str = "Junit is working fine";
+        assertEquals("Junit is working fine", str);
+    }
+
+}
diff --git a/group16/2562124714/src/com/coding/basic/TestRunner.java b/group16/2562124714/src/com/coding/basic/TestRunner.java
new file mode 100644
index 0000000000..625ace52c6
--- /dev/null
+++ b/group16/2562124714/src/com/coding/basic/TestRunner.java
@@ -0,0 +1,25 @@
+package com.coding.basic;
+
+import com.sun.net.httpserver.Authenticator;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.notification.Failure;
+import org.junit.runners.model.TestClass;
+
+import javax.xml.transform.Result;
+
+/**
+ * Created by zhangwj on 2017/2/23.
+ */
+public class TestRunner {
+    public  static void main(String[] args)
+    {
+        org.junit.runner.Result result = JUnitCore.runClasses(TestJunit.class);
+
+        for (Failure failure : result.getFailures())
+        {
+            System.out.println(failure.toString());
+        }
+
+        System.out.println(result.wasSuccessful());
+    }
+}
diff --git a/group16/2562124714/src/com/coding/basic/TreeData.java b/group16/2562124714/src/com/coding/basic/TreeData.java
new file mode 100644
index 0000000000..e79b7bd450
--- /dev/null
+++ b/group16/2562124714/src/com/coding/basic/TreeData.java
@@ -0,0 +1,28 @@
+package com.coding.basic;
+
+/**
+ * Created by zhangwj on 2017/2/22.
+ */
+public class TreeData<T extends  Comparable<T>>  implements  Comparable<TreeData<T>>{
+    private int s;
+    private T t;
+
+    public T getT()
+    {
+        return t;
+    }
+
+    public void setT(T o) { t = o;}
+
+    @Override
+    public int compareTo(TreeData<T> o) {
+        return getT().compareTo(o.getT());
+    }
+
+//    public int compareTo(TreeData<T> o)
+//    {
+//
+//    }
+
+
+}
diff --git a/group16/313001956/.classpath b/group16/313001956/.classpath
new file mode 100644
index 0000000000..b42037dde2
--- /dev/null
+++ b/group16/313001956/.classpath
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
+		<attributes>
+			<attribute name="owner.project.facets" value="java"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.web.container"/>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.module.container"/>
+	<classpathentry kind="output" path="build/classes"/>
+</classpath>
diff --git a/group16/313001956/.gitignore b/group16/313001956/.gitignore
new file mode 100644
index 0000000000..84c048a73c
--- /dev/null
+++ b/group16/313001956/.gitignore
@@ -0,0 +1 @@
+/build/
diff --git a/group16/313001956/.project b/group16/313001956/.project
new file mode 100644
index 0000000000..16d7526efa
--- /dev/null
+++ b/group16/313001956/.project
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>assignment</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.wst.jsdt.core.javascriptValidator</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.common.project.facet.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
+		<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
+		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.wst.jsdt.core.jsNature</nature>
+	</natures>
+</projectDescription>
diff --git a/group16/313001956/.settings/.jsdtscope b/group16/313001956/.settings/.jsdtscope
new file mode 100644
index 0000000000..92e666d77d
--- /dev/null
+++ b/group16/313001956/.settings/.jsdtscope
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry excluding="**/bower_components/*|**/node_modules/*|**/*.min.js" kind="src" path="WebContent"/>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.WebProject">
+		<attributes>
+			<attribute name="hide" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.baseBrowserLibrary"/>
+	<classpathentry kind="output" path=""/>
+</classpath>
diff --git a/group16/313001956/.settings/org.eclipse.jdt.core.prefs b/group16/313001956/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..c537b63063
--- /dev/null
+++ b/group16/313001956/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6
diff --git a/group16/313001956/.settings/org.eclipse.wst.common.component b/group16/313001956/.settings/org.eclipse.wst.common.component
new file mode 100644
index 0000000000..2a267dc19d
--- /dev/null
+++ b/group16/313001956/.settings/org.eclipse.wst.common.component
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?><project-modules id="moduleCoreId" project-version="1.5.0">
+    <wb-module deploy-name="assignment">
+        <wb-resource deploy-path="/" source-path="/WebContent" tag="defaultRootSource"/>
+        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src"/>
+        <property name="context-root" value="assignment"/>
+        <property name="java-output-path" value="/assignment/build/classes"/>
+    </wb-module>
+</project-modules>
diff --git a/group16/313001956/.settings/org.eclipse.wst.common.project.facet.core.xml b/group16/313001956/.settings/org.eclipse.wst.common.project.facet.core.xml
new file mode 100644
index 0000000000..611d2dfa73
--- /dev/null
+++ b/group16/313001956/.settings/org.eclipse.wst.common.project.facet.core.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<faceted-project>
+  <fixed facet="jst.web"/>
+  <fixed facet="wst.jsdt.web"/>
+  <fixed facet="java"/>
+  <installed facet="java" version="1.6"/>
+  <installed facet="jst.web" version="3.0"/>
+  <installed facet="wst.jsdt.web" version="1.0"/>
+</faceted-project>
diff --git a/group16/313001956/.settings/org.eclipse.wst.jsdt.ui.superType.container b/group16/313001956/.settings/org.eclipse.wst.jsdt.ui.superType.container
new file mode 100644
index 0000000000..3bd5d0a480
--- /dev/null
+++ b/group16/313001956/.settings/org.eclipse.wst.jsdt.ui.superType.container
@@ -0,0 +1 @@
+org.eclipse.wst.jsdt.launching.baseBrowserLibrary
\ No newline at end of file
diff --git a/group16/313001956/.settings/org.eclipse.wst.jsdt.ui.superType.name b/group16/313001956/.settings/org.eclipse.wst.jsdt.ui.superType.name
new file mode 100644
index 0000000000..05bd71b6ec
--- /dev/null
+++ b/group16/313001956/.settings/org.eclipse.wst.jsdt.ui.superType.name
@@ -0,0 +1 @@
+Window
\ No newline at end of file
diff --git a/group16/313001956/WebContent/META-INF/MANIFEST.MF b/group16/313001956/WebContent/META-INF/MANIFEST.MF
new file mode 100644
index 0000000000..254272e1c0
--- /dev/null
+++ b/group16/313001956/WebContent/META-INF/MANIFEST.MF
@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Class-Path: 
+
diff --git a/group16/313001956/src/com/coding/basic/ArrayList.java b/group16/313001956/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..eaaa690fa6
Binary files /dev/null and b/group16/313001956/src/com/coding/basic/ArrayList.java differ
diff --git a/group16/502059278/.classpath b/group16/502059278/.classpath
new file mode 100644
index 0000000000..fb5011632c
--- /dev/null
+++ b/group16/502059278/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group16/502059278/.gitignore b/group16/502059278/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group16/502059278/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group16/502059278/.project b/group16/502059278/.project
new file mode 100644
index 0000000000..72a951f7c1
--- /dev/null
+++ b/group16/502059278/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>DataStructure</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git "a/group16/502059278/homework/\350\256\241\347\256\227\346\234\272\346\274\253\350\260\210_\344\275\234\344\270\232.docx" "b/group16/502059278/homework/\350\256\241\347\256\227\346\234\272\346\274\253\350\260\210_\344\275\234\344\270\232.docx"
new file mode 100644
index 0000000000..31dfe4c14b
Binary files /dev/null and "b/group16/502059278/homework/\350\256\241\347\256\227\346\234\272\346\274\253\350\260\210_\344\275\234\344\270\232.docx" differ
diff --git a/group16/502059278/src/cn/mark/MyArrayList.java b/group16/502059278/src/cn/mark/MyArrayList.java
new file mode 100644
index 0000000000..9e0e406274
--- /dev/null
+++ b/group16/502059278/src/cn/mark/MyArrayList.java
@@ -0,0 +1,144 @@
+package cn.mark;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 自定义实现ArrayList的数据结构
+ * @author hilih
+ *
+ */
+public class MyArrayList implements MyList{
+    
+    private int size = 0;
+    
+    private Object[] elementData;
+    
+    public MyArrayList(){
+        //默认容量初始化为10
+        this(10);
+    }
+    
+    /**
+     * 初始即指定大小的构造方法
+     * @param size 集合容量
+     */
+    public MyArrayList(int size){
+        if ( size < 0 ){
+            System.out.println("不合法的容量输入");
+            return;
+        }
+        elementData = new Object[size];
+    }
+    
+    /**
+     * 集合增容
+     * @param minSize
+     */
+    private void ensureSize(int minSize){
+        int oldSize = elementData.length;
+        if(minSize > oldSize){
+            int newSize = 3 * oldSize / 2 + 1;
+            if(minSize > newSize){
+                newSize = minSize;
+            }
+            elementData = Arrays.copyOf(elementData, newSize);
+        }
+    }
+    
+    /**
+     * 下标范围判断
+     * @param index
+     */
+    private boolean rangeCheck(int index){
+        if ( index >= size || index < 0 ){
+            System.out.println("索引不合法！");
+            return false;
+        }
+        return true;
+    }
+    
+    @Override 
+    public boolean add(Object o) {
+       ensureSize(size+1);
+       elementData[size++] = o;
+       return true;
+    }
+
+    @Override
+    public boolean add(int index, Object o) {
+        if (!rangeCheck(index)){
+           return false; 
+        }
+        ensureSize(size + 1);
+        System.arraycopy(elementData, index, elementData, index + 1, size - index);
+        elementData[index] = o;
+        size++;
+        return true;
+    }
+
+    @Override
+    public Object get(int index) {
+        if (!rangeCheck(index)){
+            return null; 
+         }
+        Object o = elementData[index];
+        return o;
+    }
+
+    @Override
+    public Object remove(int index) {
+        if (!rangeCheck(index)){
+            return null; 
+         }
+        Object oldValue = elementData[index];
+        int numMoved = size - index - 1;
+        if( numMoved > 0 ){
+            System.arraycopy(elementData, index + 1, elementData, index, numMoved);
+        }
+        return oldValue;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+    
+    
+    
+    @Override
+    public String toString() {
+        StringBuilder s = new StringBuilder();
+        s.append("[");
+        for (int i = 0; i < size; i++){
+            Object o = elementData[i];
+            s.append(o.toString());
+            if( i < size-1 ){
+                s.append(",");
+            }
+        }
+        s.append("]");
+        return s.toString();
+    }
+
+    /**
+     * 判断当前集合是否为空
+     * @return
+     */
+    public boolean isEmpty(){
+        return size == 0;
+    }
+    
+    public static void main(String[] args) {
+      MyList list =  new MyArrayList();
+      list.add("a");
+      list.add("b");
+      list.add("c");
+      list.add(2,"d");
+      Object o = list.get(5);
+      System.out.println(o);
+      System.out.println(list.size());
+      System.out.println(list);
+    }
+}
diff --git a/group16/502059278/src/cn/mark/MyLinkedList.java b/group16/502059278/src/cn/mark/MyLinkedList.java
new file mode 100644
index 0000000000..7f9c3856a2
--- /dev/null
+++ b/group16/502059278/src/cn/mark/MyLinkedList.java
@@ -0,0 +1,67 @@
+package cn.mark;
+/**
+ * 自定义实现LinkedList数据结构
+ * @author hilih
+ *
+ */
+public class MyLinkedList implements MyList{
+	
+	private Node head;
+	private int size;//集合的长度
+
+	/**
+	 * 添加元素
+	 */
+	@Override
+	public boolean add(Object o) {
+		//为空判断
+		if ( o == null ){
+			System.out.println("不允许null的元素插入!");
+			return false;
+		}
+		if(head == null){
+			head = new Node();
+			head.data = o;
+		}else{
+			
+		}
+		
+		return false;
+	}
+
+	@Override
+	public boolean add(int index, Object o) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public Object get(int index) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public Object remove(int index) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public int size() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+	
+	private static class Node{
+		Object data;
+		Node next;
+	}
+
+
+	public static void main(String[] args) {
+		
+
+	}
+
+}
diff --git a/group16/502059278/src/cn/mark/MyList.java b/group16/502059278/src/cn/mark/MyList.java
new file mode 100644
index 0000000000..19bc3f92fe
--- /dev/null
+++ b/group16/502059278/src/cn/mark/MyList.java
@@ -0,0 +1,32 @@
+package cn.mark;
+
+public interface MyList {
+    /**
+     * 向集合中增加元素
+     * @param o 
+     */
+    public boolean add(Object o);
+    /**
+     * 向集合指定的位置中增加元素
+     * @param index 下标
+     * @param o 元素
+     */
+    public boolean add(int index, Object o);
+    /**
+     * 从集合指定位置取出元素
+     * @param index 下标
+     * @return
+     */
+    public Object get(int index);
+    /**
+     * 从集合中删除指定位置的元素
+     * @param index 下标
+     * @return
+     */
+    public Object remove(int index);
+    /**
+     * 当前集合的元素个数
+     * @return
+     */
+    public int size();
+}
\ No newline at end of file
diff --git a/group16/542087872/src/com/coding/basic/ArrayList.java b/group16/542087872/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..1b10b441cf
--- /dev/null
+++ b/group16/542087872/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,88 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[10];
+
+    // 每次乘2增长
+    private void grow() {
+        elementData = Arrays.copyOf(elementData, elementData.length * 2);
+    }
+
+
+	public void add(Object o){
+        if (size >= elementData.length) {
+            this.grow();
+        }
+
+        elementData[size++] = o;
+	}
+	public void add(int index, Object o){
+        if (size >= elementData.length) {
+            this.grow();
+        }
+        System.arraycopy(elementData, index, elementData, index + 1, size - index);
+
+        elementData[index] = o;
+        size++;
+	}
+	
+	public Object get(int index){
+        if (index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+        return elementData[index];
+	}
+	
+	public Object remove(int index){
+        if (index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        Object el = elementData[index];
+        System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
+
+        size--;
+        return el;
+	}
+	
+	public int size(){
+		return size;
+	}
+
+    private class ArrIter implements Iterator {
+        int cursor = 0;
+
+        @Override
+        public boolean hasNext() {
+            return cursor < size;
+        }
+
+        @Override
+        public Object next() {
+            return elementData[cursor++];
+        }
+    }
+	
+	public Iterator iterator(){
+        return new ArrIter();
+	}
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[");
+        for (int i = 0; i < size; i++) {
+            sb.append(elementData[i]);
+            if (i < size - 1) {
+                sb.append(",");
+            }
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+}
diff --git a/group16/542087872/src/com/coding/basic/BinaryTreeNode.java b/group16/542087872/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..df167343a0
--- /dev/null
+++ b/group16/542087872/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,62 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	
+	private int data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+	
+	public int getData() {
+		return data;
+	}
+	public void setData(int 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(int data) {
+		this.data = data;
+	}
+
+	private BinaryTreeNode insertAt(BinaryTreeNode node, int o) {
+		if (o < node.getData()) {
+			if (node.getLeft() != null) {
+				return insertAt(node.getLeft(), o);
+			} else {
+				BinaryTreeNode nowNode = new BinaryTreeNode(o);
+				node.setLeft(nowNode);
+
+				return nowNode;
+			}
+		} else {
+			if (node.getRight() != null) {
+				return insertAt(node.getRight(), o);
+			} else {
+				BinaryTreeNode nowNode = new BinaryTreeNode(o);
+				node.setRight(nowNode);
+				return nowNode;
+			}
+		}
+	}
+
+	public BinaryTreeNode insert(int o){
+		return insertAt(this, o);
+	}
+
+	@Override
+	public String toString() {
+		return "data: " + data;
+	}
+}
diff --git a/group16/542087872/src/com/coding/basic/Iterator.java b/group16/542087872/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..06ef6311b2
--- /dev/null
+++ b/group16/542087872/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/group16/542087872/src/com/coding/basic/LinkedList.java b/group16/542087872/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..144af4ec8d
--- /dev/null
+++ b/group16/542087872/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,192 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+
+	private Node head;
+	private Node tail;
+
+	public void add(Object o){
+		Node nowNode = new Node(o);
+		if (head == null) {
+			head = nowNode;
+		} else {
+			tail.next = nowNode;
+		}
+		tail = nowNode;
+	}
+	public void add(int index , Object o){
+		int count = 0;
+        Node lastOne = null;
+		Node tpHead = head;
+		while (tpHead != null && count != index) {
+			count++;
+            lastOne = tpHead;
+			tpHead = tpHead.next;
+		}
+        if (count != index) {
+            throw new IndexOutOfBoundsException();
+        }
+
+
+        Node nowNode = new Node(o);
+        if (lastOne == null) {
+            head = nowNode;
+            head.next = tpHead;
+        } else {
+            lastOne.next = nowNode;
+            nowNode.next = tpHead;
+        }
+	}
+	public Object get(int index){
+        int count = 0;
+        Node tpHead = head;
+        while (tpHead != null && count != index) {
+            count++;
+            tpHead = tpHead.next;
+        }
+        if (count != index) {
+            throw new IndexOutOfBoundsException();
+        }
+
+		return tpHead.data;
+	}
+	public Object remove(int index){
+        int count = 0;
+        Node lastOne = null;
+        Node tpHead = head;
+        while (tpHead != null && count != index) {
+            count++;
+            lastOne = tpHead;
+            tpHead = tpHead.next;
+        }
+        if (count != index) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        if (lastOne == null) {
+            head = tpHead.next;
+        } else {
+            lastOne.next = tpHead.next;
+        }
+
+        if (tpHead.next == null) {
+            tail = lastOne;
+        }
+
+		return tpHead.data;
+	}
+	
+	public int size(){
+        int count = 0;
+        Node tpHead = head;
+        while (tpHead != null) {
+            count ++;
+            tpHead = tpHead.next;
+        }
+
+        return count;
+	}
+	
+	public void addFirst(Object o){
+        Node nowNode = new Node(o);
+        if (head == null) {
+            head = nowNode;
+            tail = nowNode;
+        } else {
+            nowNode.next = head;
+            head = nowNode;
+        }
+	}
+	public void addLast(Object o){
+        Node nowNode = new Node(o);
+        if (head == null) {
+            head = nowNode;
+            tail = nowNode;
+        } else {
+            tail.next = nowNode;
+            tail = nowNode;
+        }
+	}
+	public Object removeFirst(){
+        if (head == null) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        Node nowValue = head;
+
+        Node nextNode = head.next;
+        if (nextNode == null) {
+            tail = null;
+        }
+        head = nextNode;
+
+		return nowValue.data;
+	}
+	public Object removeLast(){
+        if (head == null) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        Node nowValue = tail;
+
+        Node lastOne = null;
+        Node tpHead = head;
+        while (tpHead != tail) {
+            lastOne = tpHead;
+            tpHead = tpHead.next;
+        }
+        if (lastOne == null) {
+            head = null;
+        } else {
+            lastOne.next = null;
+        }
+        tail = lastOne;
+
+		return nowValue.data;
+	}
+
+    private class LinkIter implements Iterator {
+
+        Node cursor = head;
+
+        @Override
+        public boolean hasNext() {
+            return cursor != null;
+        }
+
+        @Override
+        public Object next() {
+            Node ret = cursor;
+            cursor = cursor.next;
+            return ret.data;
+        }
+    }
+
+	public Iterator iterator(){
+        return new LinkIter();
+	}
+	
+	
+	private static class Node{
+		Object data;
+		Node next;
+
+		public Node(Object data) {
+			this.data = data;
+		}
+	}
+
+    @Override
+    public String toString() {
+        Node tpHead = head;
+        StringBuilder sb = new StringBuilder("[");
+        while (tpHead != null) {
+            sb.append(tpHead.data);
+            sb.append(",");
+            tpHead = tpHead.next;
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+
+}
diff --git a/group16/542087872/src/com/coding/basic/List.java b/group16/542087872/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ b/group16/542087872/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/group16/542087872/src/com/coding/basic/Queue.java b/group16/542087872/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..8e4285464b
--- /dev/null
+++ b/group16/542087872/src/com/coding/basic/Queue.java
@@ -0,0 +1,22 @@
+package com.coding.basic;
+
+public class Queue {
+
+	private LinkedList linkedList = new LinkedList();
+
+	public void enQueue(Object o){
+		linkedList.addLast(o);
+	}
+	
+	public Object deQueue(){
+		return linkedList.removeFirst();
+	}
+	
+	public boolean isEmpty(){
+		return linkedList.size() == 0;
+	}
+	
+	public int size(){
+		return linkedList.size();
+	}
+}
diff --git a/group16/542087872/src/com/coding/basic/Stack.java b/group16/542087872/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..bfe98dd8b7
--- /dev/null
+++ b/group16/542087872/src/com/coding/basic/Stack.java
@@ -0,0 +1,25 @@
+package com.coding.basic;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){
+		elementData.add(o);
+	}
+	
+	public Object pop(){
+		Object o = elementData.get(elementData.size() - 1);
+		elementData.remove(elementData.size() - 1);
+		return o;
+	}
+	
+	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/group16/542087872/src/com/coding/basic/Test.java b/group16/542087872/src/com/coding/basic/Test.java
new file mode 100644
index 0000000000..2db5b2f9ab
--- /dev/null
+++ b/group16/542087872/src/com/coding/basic/Test.java
@@ -0,0 +1,166 @@
+package com.coding.basic;
+
+
+/**
+ * Created by xiaoyuan on 25/02/2017.
+ */
+public class Test {
+    public static void main(String[] args) {
+
+        testArrayList();
+        testLinkedList();
+
+        testQueue();
+        testStack();
+
+
+        testBinaryTreeNode();
+    }
+
+    private static void testBinaryTreeNode() {
+
+        BinaryTreeNode binaryTreeNode = new BinaryTreeNode(10);
+        binaryTreeNode.insert(5);
+        binaryTreeNode.insert(4);
+        binaryTreeNode.insert(6);
+        binaryTreeNode.insert(11);
+
+        traverse(binaryTreeNode);
+
+    }
+
+    private static void traverse(BinaryTreeNode node) {
+        if (node.getLeft() != null) {
+            traverse(node.getLeft());
+        }
+
+        System.out.println("-- " + node.getData() + " --");
+
+        if (node.getRight() != null) {
+            traverse(node.getRight());
+        }
+
+    }
+
+
+    static void testStack() {
+
+        Stack stack = new Stack();
+        stack.push(1);
+        stack.push(2);
+        stack.push(3);
+        stack.push(4);
+
+        System.out.println(stack.size());
+        System.out.println(stack.isEmpty());
+
+        System.out.println(stack.pop());
+        System.out.println(stack.pop());
+        System.out.println(stack.pop());
+        System.out.println(stack.pop());
+
+        System.out.println(stack.isEmpty());
+
+    }
+
+    static void testQueue() {
+        Queue queue = new Queue();
+        queue.enQueue(1);
+        queue.enQueue(2);
+
+        System.out.println(queue.size());
+        System.out.println(queue.deQueue());
+        System.out.println(queue.deQueue());
+        System.out.println(queue.size());
+    }
+    static void testLinkedList() {
+        LinkedList linkedList = new LinkedList();
+        linkedList.add(1);
+        linkedList.add(2);
+
+        System.out.println(linkedList.size());
+        System.out.println(linkedList);
+
+        linkedList.add(4);
+        linkedList.add(5);
+        System.out.println(linkedList.size());
+        System.out.println(linkedList);
+
+
+        linkedList.add(0, 10);
+        linkedList.add(0, 9);
+        System.out.println(linkedList.size());
+        System.out.println(linkedList);
+
+        System.out.println(linkedList.get(3));
+
+        linkedList.remove(0);
+        System.out.println(linkedList.size());
+        System.out.println(linkedList);
+
+
+        linkedList.addFirst(100);
+        linkedList.addLast(8888);
+        System.out.println(linkedList.size());
+        System.out.println(linkedList);
+
+
+        linkedList.removeFirst();
+        linkedList.removeLast();
+        System.out.println(linkedList.size());
+        System.out.println(linkedList);
+
+        Iterator iterator = linkedList.iterator();
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next());
+        }
+
+    }
+
+    static void testArrayList() {
+        ArrayList arrayList = new ArrayList();
+        arrayList.add("1");
+        arrayList.add("2");
+        // test size and add
+        System.out.println(arrayList.size());
+        System.out.println(arrayList);
+
+
+        arrayList.add("3");
+        arrayList.add("4");
+        arrayList.add("5");
+        arrayList.add("6");
+        arrayList.add("7");
+        arrayList.add("8");
+        arrayList.add("9");
+        arrayList.add("10");
+        arrayList.add("11");
+        arrayList.add("12");
+        arrayList.add("13");
+
+        // test size
+        // test grow
+        System.out.println(arrayList.size());
+        System.out.println(arrayList);
+
+        // test add at index
+        arrayList.add(2, 100);
+        System.out.println(arrayList.size());
+        System.out.println(arrayList);
+
+        // test remove
+        arrayList.remove(0);
+        System.out.println(arrayList.size());
+        System.out.println(arrayList);
+        arrayList.remove(2);
+        System.out.println(arrayList.size());
+        System.out.println(arrayList);
+
+        // test iterator
+        Iterator iterator = arrayList.iterator();
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next());
+        }
+
+    }
+}
diff --git a/group16/out/production/214074094/com/reading/blog_test.txt b/group16/out/production/214074094/com/reading/blog_test.txt
new file mode 100644
index 0000000000..b7e5cbfe14
--- /dev/null
+++ b/group16/out/production/214074094/com/reading/blog_test.txt
@@ -0,0 +1 @@
+just test new fork
\ No newline at end of file
diff --git a/group16/out/production/214074094/readme.txt b/group16/out/production/214074094/readme.txt
new file mode 100644
index 0000000000..c1b06ddcc2
--- /dev/null
+++ b/group16/out/production/214074094/readme.txt
@@ -0,0 +1 @@
+I am 北京-Shane
diff --git a/group16/out/production/214074094/src/com/reading/blog_test.txt b/group16/out/production/214074094/src/com/reading/blog_test.txt
new file mode 100644
index 0000000000..b7e5cbfe14
--- /dev/null
+++ b/group16/out/production/214074094/src/com/reading/blog_test.txt
@@ -0,0 +1 @@
+just test new fork
\ No newline at end of file
diff --git a/group17/102228177/.classpath b/group17/102228177/.classpath
new file mode 100644
index 0000000000..d171cd4c12
--- /dev/null
+++ b/group17/102228177/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group17/102228177/.project b/group17/102228177/.project
new file mode 100644
index 0000000000..350a2aab85
--- /dev/null
+++ b/group17/102228177/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>102228177</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group17/102228177/src/data2_19/ArrayList.java b/group17/102228177/src/data2_19/ArrayList.java
new file mode 100644
index 0000000000..0f0be01806
--- /dev/null
+++ b/group17/102228177/src/data2_19/ArrayList.java
@@ -0,0 +1,148 @@
+package data2_19;
+
+import java.util.ConcurrentModificationException;
+import java.util.NoSuchElementException;
+
+
+public class ArrayList implements List{
+	public static final int defLen = 10;
+	private Object[] elements;
+	private int size;
+	private int maxLen;
+	
+	public ArrayList(){
+		size = 0;
+		maxLen = defLen;
+		elements = new Object[defLen];
+	}
+	
+	/**
+	 * 在ArrayList末尾处追加元素
+	 * @param o 添加的元素
+	 */
+	public void add(Object o){
+		if(size >= maxLen){
+			grow();
+		}
+		elements[size] = o;
+		size++;
+	}
+	
+	/**
+	 * 数组扩容
+	 */
+	private void grow(){
+		maxLen = maxLen + (maxLen >> 1);
+		Object[] newArr = new Object[maxLen];
+		System.arraycopy(elements, 0, newArr, 0, size);
+		elements = newArr;
+	}
+	
+	/**
+	 * 在指定索引处添加元素
+	 * @param i 指定索引
+	 * @param o 添加元素
+	 */
+	public void add(int i,Object o){
+		//判断插入位置大于数组实际长度
+		if(i > size){
+			size = i;
+			if(size >= maxLen){//数组大小大于数组最大容量则需要扩容
+				grow();
+			}
+		}
+		//插入位置不大于数组实际长度时，将插入位置的元素向后移。
+		for (int j = size; j > i ; j++) {
+			elements[j] = elements[j-1];
+		}
+		elements[i] = o;
+		size++;
+	}
+	
+	/**
+	 * 获取传入索引的元素
+	 * @param index 索引
+	 * @return 返回传入索引的元素
+	 */
+	public Object get(int index){
+		//索引不在实际范围内
+		if(index < 0||index >= size){
+			throw new ArrayIndexOutOfBoundsException();
+		}
+		for (int i = 0; i < size; i++) {
+			return elements[index];
+		}
+		return null;
+	}
+	
+	/**
+	 * 删除指定索引元素并返回
+	 * @param index
+	 * @return 该索引处元素
+	 */
+	public Object remove(int index){
+		//索引不在实际范围内
+		if(index < 0||index >= size){
+			throw new ArrayIndexOutOfBoundsException();
+		}else{
+			for (int j = index; j < size-1; j++) {
+				elements[j]=elements[j+1];
+			}
+			size--;
+			return elements[index];
+		}
+	}
+	
+	/**
+	 * 获取大小
+	 * @return 
+	 */
+	public int size(){
+		return size;
+	}
+	
+	public Iterator iterator(){
+		return new ArrayListIterator();
+	}
+	
+	private class ArrayListIterator implements Iterator{
+		int cursor;
+		
+		@Override
+		public boolean hasNext() {
+			return cursor != size;
+		}
+
+		@Override
+		public Object next() {
+			int i = cursor;
+			if(i >= size){
+                throw new NoSuchElementException();
+			}
+			if (i >= elements.length){
+				throw new ConcurrentModificationException();
+			}
+			cursor = i+1;        
+			return elements[i];
+		}
+	}
+	
+	public static void main(String[] args) {
+		ArrayList list = new ArrayList();
+		list.add(0);
+		list.add(1);
+		list.add(2);
+		list.add(3);
+		list.add(4);
+		list.add(6, 6);
+		list.remove(3);
+		for (int i = 0; i < list.size(); i++) {
+			System.out.println(i+":"+list.get(i));
+		}
+		
+		Iterator it =  list.iterator();
+		while (it.hasNext()) {
+			System.out.println(it.next());
+		}
+	}
+}
diff --git a/group17/102228177/src/data2_19/BinaryTreeNode.java b/group17/102228177/src/data2_19/BinaryTreeNode.java
new file mode 100644
index 0000000000..6b091c87b3
--- /dev/null
+++ b/group17/102228177/src/data2_19/BinaryTreeNode.java
@@ -0,0 +1,74 @@
+package data2_19;
+
+public class BinaryTreeNode implements Comparable<BinaryTreeNode>{
+	
+	private Object data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+	
+	public BinaryTreeNode(Object o) {
+		this.data = o;
+	}
+	
+	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;
+	}
+	
+	@Override
+	public int compareTo(BinaryTreeNode o) {
+		return (this.data.hashCode() < o.data.hashCode()) ? -1 :
+			((this.data.hashCode() == o.data.hashCode()) ? 0 : 1);
+	}
+	
+	public BinaryTreeNode insert(Object o){
+		BinaryTreeNode node = new BinaryTreeNode(o);
+		insertNode(this,node);
+		return node;
+	}
+
+	private void insertNode(BinaryTreeNode parentNode, BinaryTreeNode node) {
+		//父节点大于添加元素
+		if(parentNode.compareTo(node) == 1){
+			if(parentNode.left == null){
+				parentNode.left = node;
+				return;
+			}
+			insertNode(parentNode.left, node);
+		}
+		//父节点小于添加元素
+		else 
+		if(parentNode.compareTo(node) == -1){
+			if(parentNode.right == null){
+				parentNode.right = node;
+				return;
+			}
+			insertNode(parentNode.right, node);
+		}else{
+			throw new RuntimeException("No duplicate vertex allowed!");
+		}
+	}
+	
+	public static void main(String[] args) {
+		BinaryTreeNode tree = new BinaryTreeNode(5);
+		tree.insert(2);
+		tree.insert(23);
+		tree.insert(7);
+		tree.insert(1);
+	}
+
+}
\ No newline at end of file
diff --git a/group17/102228177/src/data2_19/Iterator.java b/group17/102228177/src/data2_19/Iterator.java
new file mode 100644
index 0000000000..6d1fd8a2e3
--- /dev/null
+++ b/group17/102228177/src/data2_19/Iterator.java
@@ -0,0 +1,8 @@
+package data2_19;
+
+public interface Iterator {
+	
+	public boolean hasNext();
+	public Object next();
+
+}
\ No newline at end of file
diff --git a/group17/102228177/src/data2_19/LinkedList.java b/group17/102228177/src/data2_19/LinkedList.java
new file mode 100644
index 0000000000..87613d0704
--- /dev/null
+++ b/group17/102228177/src/data2_19/LinkedList.java
@@ -0,0 +1,142 @@
+package data2_19;
+
+import java.util.NoSuchElementException;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	private int size;
+	
+	public LinkedList(){
+		size = 0;
+		head = null;
+	}
+	
+	public void add(Object o){
+		Node node = new Node(o);
+		if(head == null){
+			head = node;
+		}else{
+			//p为游标   从头遍历到尾
+			Node p = head;
+			while(p.next != null){
+				p = p.next;
+			}
+			p.next = node;
+		}
+		size++;
+	}
+	
+	public void add(int index , Object o){
+		//判断不为空链表
+		if(head != null){
+			Node p = head;
+			int k = 0;
+			//扫描单链表查找第index-1个节点
+			while(k < index-1 && p.next != null){
+				k++;
+				p = p.next;
+			}
+			//判断是否找到第index-1个节点
+			if(p != null){
+				Node node = new Node(o);
+				node.next = p.next;
+				p.next = node;
+			}
+			size++;
+		}
+	}
+	
+	public Object get(int index){
+		if(index <0 || index >= size){
+			throw new IndexOutOfBoundsException();
+		}else{
+			Node p = head;
+			int k = 0;
+			while(k < index && p.next != null){
+				k++;
+				p = p.next;
+			}
+			return p.data;
+		}
+	}
+	public Object remove(int index){
+		if(index <0 || index >= size){
+			throw new IndexOutOfBoundsException();
+		}else{
+			if(head != null){
+				Node p = head;
+				int k = 0;
+				while(k > index-1 && p.next != null){
+					k++;
+					p = p.next; 
+				}
+				Node next = p.next;
+				p.next = next.next;
+				size--;
+				return next.data;
+			}
+		}
+		return null;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		Node node = new Node(o);
+		node.next = head;
+		head = node;
+		size++;
+	}
+	
+	public void addLast(Object o){
+		Node node = new Node(o);
+		if(head == null){
+			head = node;
+		}else{
+			Node p = head;
+			while(p.next != null){
+				p = p.next; 
+			}
+			p.next = node;
+		}
+		size++;
+	}
+	
+	public Object removeFirst(){
+		if(head == null){
+			 throw new NoSuchElementException();
+		}
+		Node node = head;
+		head = node.next;
+		size--;
+		return node.data;
+	}
+	public Object removeLast(){
+		if(head == null){
+			 throw new NoSuchElementException();
+		}else{
+			Node p = head;
+			int k = 0;
+			while(k < size-1 && p.next != null){
+				k++;
+				p = p.next;
+			}
+			Node last = p.next;
+			p.next = null;
+			size--;
+			return last.data;
+		}
+	}
+	
+	private static class Node{
+		Object data;
+		Node next;
+		private Node(Object o){
+			this.data = o;
+			this.next = null;
+		}
+	}
+}
\ No newline at end of file
diff --git a/group17/102228177/src/data2_19/List.java b/group17/102228177/src/data2_19/List.java
new file mode 100644
index 0000000000..9f1a3f5ce6
--- /dev/null
+++ b/group17/102228177/src/data2_19/List.java
@@ -0,0 +1,10 @@
+package data2_19;
+
+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();
+}
\ No newline at end of file
diff --git a/group17/102228177/src/data2_19/Queue.java b/group17/102228177/src/data2_19/Queue.java
new file mode 100644
index 0000000000..e945f4a67a
--- /dev/null
+++ b/group17/102228177/src/data2_19/Queue.java
@@ -0,0 +1,38 @@
+package data2_19;
+public class Queue {
+	
+	private LinkedList linkedList = new LinkedList();
+	private int elementCount;
+	
+	public Queue() {
+		this.elementCount = 0;
+	}
+	
+	public void enQueue(Object o){
+		linkedList.addLast(o);
+		elementCount++;
+	}
+	
+	public Object deQueue(){
+		Object object = linkedList.removeFirst();
+		elementCount--;
+		return object;
+	}
+	
+	public boolean isEmpty(){
+		return elementCount == 0;
+	}
+	
+	public int size(){
+		return elementCount;
+	}
+	
+	public static void main(String[] args) {
+		Queue queue = new Queue();
+		queue.enQueue(2);
+		queue.enQueue(3);
+		System.out.println(queue.isEmpty());
+		System.out.println(queue.size());
+		System.out.println(queue.deQueue());
+	}
+}
\ No newline at end of file
diff --git a/group17/102228177/src/data2_19/Stack.java b/group17/102228177/src/data2_19/Stack.java
new file mode 100644
index 0000000000..2b17605631
--- /dev/null
+++ b/group17/102228177/src/data2_19/Stack.java
@@ -0,0 +1,44 @@
+package data2_19;
+
+import java.util.EmptyStackException;
+
+public class Stack {
+	private ArrayList elementData;
+	private int elementCount;
+	
+	public Stack() {
+		this.elementData = new ArrayList();
+		this.elementCount = 0;
+	}
+	public void push(Object o){
+		elementData.add(o);
+		elementCount++;
+	}
+	
+	public Object pop(){
+		Object object = elementData.remove(elementCount-1);
+		elementCount--;
+		return object;
+	}
+	
+	public Object peek(){
+		if(isEmpty()){
+			 throw new EmptyStackException();
+		}
+		return elementData.get(elementCount-1);
+	}
+	public boolean isEmpty(){
+		return elementCount==0;
+	}
+	public int size(){
+		return elementCount;
+	}
+	public static void main(String[] args) {
+		Stack stack = new Stack();
+		stack.push(1);
+		stack.push(2);
+		System.out.println(stack.pop());
+		System.out.println(stack.peek());
+		
+	}
+}
\ No newline at end of file
diff --git a/group17/1204187480/code/homework/basic/pom.xml b/group17/1204187480/code/homework/basic/pom.xml
new file mode 100644
index 0000000000..039af72d42
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/pom.xml
@@ -0,0 +1,12 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>basic</artifactId>
+    <parent>
+        <groupId>com.coding</groupId>
+        <artifactId>parent</artifactId>
+        <version>1.0-SNAPSHOT</version>
+        <relativePath>../parent/pom.xml</relativePath>
+    </parent>
+
+</project>
\ No newline at end of file
diff --git a/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/ArrayList.java b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..6ddf8cef58
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/ArrayList.java
@@ -0,0 +1,108 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+public class ArrayList implements List {
+
+    private int size = 0;
+
+    private Object[] elementData = new Object[100];
+
+    private Iterator iterator = new ArrayListIterator();
+
+    private int length() {
+        return elementData.length;
+    }
+
+    private static final int ENLARGE_LENGTH = 100;
+
+    private Object[] enlarge(Object[] origin) {
+        return Arrays.copyOf(origin, origin.length + ENLARGE_LENGTH);
+    }
+
+    private void enLargeElementData() {
+        if (size == length()) {
+            elementData = enlarge(elementData);
+        }
+    }
+
+    public void add(Object o) {
+        enLargeElementData();
+        elementData[size] = o;
+        size++;
+    }
+
+    public void add(int index, Object o) {
+        checkForAdd(index);
+        enLargeElementData();
+        // 备份 index 处及后面的数据
+        Object[] elementsBehindIndex = backBehindElements(elementData, index);
+        // 给index处 设值
+        elementData[index] = o;
+        // 追加 备份的数据
+        appendElement(elementData, index, elementsBehindIndex);
+        size++;
+    }
+
+    private void appendElement(Object[] origin, int pos, Object[] append) {
+        System.arraycopy(append, 0, origin, pos, append.length);
+    }
+
+    private Object[] backBehindElements(Object[] elementData, int index) {
+        int backSize = size - index;
+        Object[] back = new Object[backSize];
+        System.arraycopy(elementData, index, back, 0, backSize);
+        return back;
+    }
+
+    public Object get(int index) {
+        checkIndex(index);
+        return elementData[index];
+    }
+
+    private void checkIndex(int index) {
+        if (index < 0 || index >= size) {
+            throw new ArrayIndexOutOfBoundsException(String.format("index=%s, size=%s", index, size));
+        }
+    }
+
+    private void checkForAdd(int index) {
+        if (index < 0 || index > size) {
+            throw new ArrayIndexOutOfBoundsException(String.format("index=%s, size=%s", index, size));
+        }
+    }
+
+    public Object remove(int index) {
+        checkIndex(index);
+        Object[] back = backBehindElements(elementData, index + 1);
+        System.arraycopy(back, 0, elementData, index, back.length);
+        Object ret = elementData[index];
+        elementData[index] = null;
+        size--;
+        return ret;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public Iterator iterator() {
+        return iterator;
+    }
+
+    private class ArrayListIterator implements Iterator {
+
+        int next = 0;
+
+        @Override
+        public boolean hasNext() {
+           return next < size;
+        }
+
+        @Override
+        public Object next() {
+            return elementData[next++];
+        }
+    }
+
+}
diff --git a/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/BinaryTreeNode.java b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..d7ac820192
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,32 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git a/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/Iterator.java b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..06ef6311b2
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/src/main/java/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/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/LinkedList.java b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..175d3adb74
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/LinkedList.java
@@ -0,0 +1,147 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+
+    private Node head;
+    private int size = 0;
+    private Iterator iterator = new LinkedListIterator();
+
+
+    public void add(Object o) {
+        Node newNode = new Node(o, null);
+        if (head == null) {
+            head = newNode;
+        } else {
+            node(size - 1).next = newNode;
+        }
+        size++;
+    }
+
+    public void add(int index, Object o) {
+        checkForAdd(index);
+        if (index == size) {
+            add(o);
+        }else {
+            Node newNode = new Node(o, null);
+            if (index == 0){
+              addFirst(o);
+            } else {
+                Node preNode = node(index - 1);
+                Node now = preNode.next;
+                preNode.next = newNode;
+                newNode.next = now;
+                size++;
+            }
+        }
+
+    }
+
+    private Node node(int index) {
+        Node x = head;
+        for (int i = 0; i < index; i++) {
+            x = x.next;
+        }
+        return x;
+    }
+
+    public Object get(int index) {
+        checkIndex(index);
+        return node(index).data;
+    }
+
+    /**
+     * 让被删除的引用的持有者指向下一个节点
+     * @param index
+     * @return
+     */
+    public Object remove(int index) {
+        final Object ret;
+        checkIndex(index);
+        if (index == 0) {
+            Node removeNode = head;
+            ret = head.data;
+            head = removeNode.next;
+        } else {
+            Node pre = node(index - 1);
+            Node removeNode = pre.next;
+            ret = removeNode.data;
+            pre.next = removeNode.next;
+        }
+        size--;
+        return ret;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public void addFirst(Object o) {
+        head = new Node(o, head);;
+        size++;
+    }
+
+    public void addLast(Object o) {
+        add(o);
+    }
+
+    public Object removeFirst() {
+        if (size == 0){
+            return null;
+        }else {
+            return remove(0);
+        }
+    }
+
+    public Object removeLast() {
+        return remove(size - 1);
+    }
+
+    public Iterator iterator() {
+        return iterator;
+    }
+
+    private void checkIndex(int index) {
+        if (index < 0 || index >= size) {
+            throw new ArrayIndexOutOfBoundsException(String.format("index=%s, size=%s", index, size));
+        }
+    }
+
+    private void checkForAdd(int index) {
+        if (index < 0 || index > size) {
+            throw new ArrayIndexOutOfBoundsException(String.format("index=%s, size=%s", index, size));
+        }
+    }
+
+    private static class Node {
+        Object data;
+        Node next;
+
+        public Node() {
+        }
+
+        public Node(Object data, Node next) {
+            this.data = data;
+            this.next = next;
+        }
+    }
+
+    private class LinkedListIterator implements Iterator{
+
+        private Node next;
+
+        @Override
+        public boolean hasNext() {
+            return next != null;
+        }
+
+        @Override
+        public Object next() {
+            if (next == null) {
+                throw new IndexOutOfBoundsException("there is no node in list");
+            }
+            Node ret = next;
+            next = next.next;
+            return ret.data;
+        }
+    }
+}
diff --git a/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/List.java b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/List.java
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/src/main/java/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/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/Queue.java b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..0f6caaec6f
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/Queue.java
@@ -0,0 +1,24 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+public class Queue {
+
+	private LinkedList elementData = new LinkedList();
+
+	public void enQueue(Object o){
+		elementData.add(o);
+	}
+	
+	public Object deQueue(){
+		return elementData.remove(0);
+	}
+	
+	public boolean isEmpty(){
+		return size() == 0;
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/Stack.java b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..7d91c326e0
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/src/main/java/com/coding/basic/Stack.java
@@ -0,0 +1,30 @@
+package com.coding.basic;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){
+		elementData.add(o);
+	}
+	
+	public Object pop(){
+		if (isEmpty()) {
+			throw new IllegalStateException("the stack is empty");
+		}
+		return elementData.remove(elementData.size() - 1);
+	}
+	
+	public Object peek(){
+		if (isEmpty()) {
+			throw new IllegalStateException("the stack is empty");
+		}
+		return elementData.get(elementData.size() - 1);
+	}
+
+	public boolean isEmpty(){
+		return size() == 0;
+	}
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group17/1204187480/code/homework/basic/src/test/java/com/coding/api/ArrayListTest.java b/group17/1204187480/code/homework/basic/src/test/java/com/coding/api/ArrayListTest.java
new file mode 100644
index 0000000000..85d3cf6901
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/src/test/java/com/coding/api/ArrayListTest.java
@@ -0,0 +1,25 @@
+package com.coding.api;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by luoziyihao on 2/25/17.
+ */
+public class ArrayListTest {
+
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    @Test
+    public void testAdd(){
+        List<Object> list = new ArrayList<Object>(Arrays.asList(0, 1, 2, 3));
+        logger.info("list={}", list);
+        list.add(5, 2);
+        logger.info("list={}", list);
+    }
+}
diff --git a/group17/1204187480/code/homework/basic/src/test/java/com/coding/api/ArraysTest.java b/group17/1204187480/code/homework/basic/src/test/java/com/coding/api/ArraysTest.java
new file mode 100644
index 0000000000..eb41a7e262
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/src/test/java/com/coding/api/ArraysTest.java
@@ -0,0 +1,22 @@
+package com.coding.api;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+
+/**
+ * Created by luoziyihao on 2/25/17.
+ */
+public class ArraysTest {
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+
+
+    @Test
+    public void testCopyOf(){
+        Object[] a = new Object[]{1, 2, 3, 4};
+        Object[] b = Arrays.copyOf(a, 10);
+        logger.info("a={}, b={}", Arrays.toString(a), Arrays.toString(b));
+    }
+}
diff --git a/group17/1204187480/code/homework/basic/src/test/java/com/coding/api/SystemTest.java b/group17/1204187480/code/homework/basic/src/test/java/com/coding/api/SystemTest.java
new file mode 100644
index 0000000000..efc4022378
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/src/test/java/com/coding/api/SystemTest.java
@@ -0,0 +1,24 @@
+package com.coding.api;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+
+/**
+ * Created by luoziyihao on 2/25/17.
+ */
+public class SystemTest {
+
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+
+        @Test
+    public void testArrayCopy() {
+        int[] a = new int[]{1, 2, 3, 4, 5, 6, 7};
+        int[] b = new int[]{11, 22, 33, 44, 55, 66, 77};
+        System.arraycopy(a, 2, b, 4, 3);
+        logger.info("b={}", Arrays.toString(b));
+
+    }
+}
diff --git a/group17/1204187480/code/homework/basic/src/test/java/com/coding/basic/ArrayListTest.java b/group17/1204187480/code/homework/basic/src/test/java/com/coding/basic/ArrayListTest.java
new file mode 100644
index 0000000000..9241fe72da
--- /dev/null
+++ b/group17/1204187480/code/homework/basic/src/test/java/com/coding/basic/ArrayListTest.java
@@ -0,0 +1,35 @@
+package com.coding.basic;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+/**
+ * Created by luoziyihao on 2/25/17.
+ */
+public class ArrayListTest {
+
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+
+
+    private List list = new ArrayList();
+
+    @Before
+    public void before() {
+
+    }
+
+    @Test
+    public void add() throws Exception {
+        list.add(1);
+    }
+
+    @Test
+    public void get() throws Exception {
+        add();
+        logger.info("{}", list.get(0));
+    }
+
+}
\ No newline at end of file
diff --git a/group17/1204187480/code/homework/parent/pom.xml b/group17/1204187480/code/homework/parent/pom.xml
new file mode 100644
index 0000000000..9d29a4d93e
--- /dev/null
+++ b/group17/1204187480/code/homework/parent/pom.xml
@@ -0,0 +1,95 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.coding</groupId>
+    <artifactId>parent</artifactId>
+    <packaging>pom</packaging>
+    <version>1.0-SNAPSHOT</version>
+    <url>https://github.com/luoziyihao/coding2017</url>
+
+    <properties>
+        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <jdk.version>1.8</jdk.version>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <maven-compiler-plugin.version>3.0</maven-compiler-plugin.version>
+        <logback-classic.version>1.1.7</logback-classic.version>
+        <commons-logging.version>1.2</commons-logging.version>
+        <log4j.version>1.2.17</log4j.version>
+        <junit.version>4.12</junit.version>
+    </properties>
+
+    <dependencies>
+        <!-- 日志 -->
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <version>${logback-classic.version}</version>
+        </dependency>
+        <!-- 配置所有依赖库的日志依赖 start-->
+        <dependency>
+            <groupId>commons-logging</groupId>
+            <artifactId>commons-logging</artifactId>
+            <version>${commons-logging.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>${log4j.version}</version>
+        </dependency>
+        <!-- 配置所有依赖库的日志依赖 end-->
+        <!-- 测试 -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+        </dependency>
+    </dependencies>
+
+    <pluginRepositories>
+        <pluginRepository>
+            <id>alimaven</id>
+            <name>aliyun maven</name>
+            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
+            <releases>
+                <enabled>true</enabled>
+            </releases>
+            <snapshots>
+                <enabled>true</enabled>
+            </snapshots>
+        </pluginRepository>
+    </pluginRepositories>
+    <repositories>
+        <repository>
+            <id>alimaven</id>
+            <name>aliyun maven</name>
+            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
+            <releases>
+                <enabled>true</enabled>
+            </releases>
+            <snapshots>
+                <enabled>true</enabled>
+            </snapshots>
+        </repository>
+    </repositories>
+
+    <build>
+        <finalName>${project.artifactId}</finalName>
+        <plugins>
+            <!-- 编译插件 制定编译级别 -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven.compiler.source}</source>
+                    <target>${maven.compiler.target}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
\ No newline at end of file
diff --git a/group17/1204187480/code/homework/pom.xml b/group17/1204187480/code/homework/pom.xml
new file mode 100644
index 0000000000..e939b51bd0
--- /dev/null
+++ b/group17/1204187480/code/homework/pom.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.coding</groupId>
+    <artifactId>coding2017</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>pom</packaging>
+    <modules>
+        <module>parent</module>
+        <module>basic</module>
+    </modules>
+
+</project>
diff --git a/group17/1264835468/.classpath b/group17/1264835468/.classpath
new file mode 100644
index 0000000000..d171cd4c12
--- /dev/null
+++ b/group17/1264835468/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group17/1264835468/.gitignore b/group17/1264835468/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group17/1264835468/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group17/1264835468/.project b/group17/1264835468/.project
new file mode 100644
index 0000000000..d2cad6d6dd
--- /dev/null
+++ b/group17/1264835468/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>1264835468</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group17/1264835468/src/assignment/BinaryTree.java b/group17/1264835468/src/assignment/BinaryTree.java
new file mode 100644
index 0000000000..a74d5fecc8
--- /dev/null
+++ b/group17/1264835468/src/assignment/BinaryTree.java
@@ -0,0 +1,154 @@
+package assignment;
+
+//
+public class BinaryTree<T extends Comparable<? super T>> implements Iterable<BinaryTreeNode<T>> {
+	private BinaryTreeNode<T> root;
+
+	public BinaryTree(T data) {
+		root = new BinaryTreeNode<T>(data);
+	}
+
+	public BinaryTree(BinaryTreeNode<T> root) {
+		this.root = root;
+	}
+
+	public BinaryTreeNode<T> insert(T data) {
+		BinaryTreeNode<T> node = new BinaryTreeNode<T>(data);
+		if (root == null)
+			root = node;
+		else
+			insert(root, node);
+		return node;
+	}
+
+	public BinaryTreeNode<T> insert(BinaryTreeNode<T> node) {
+		return insert(node.getData());
+	}
+
+	private void insert(BinaryTreeNode<T> current, BinaryTreeNode<T> node) {
+
+		if (current.getData().compareTo(node.getData()) > 0) {
+			if (current.getLeft() == null)
+				current.setLeft(node);
+			else
+				insert(current.getLeft(), node);
+		}
+		else {
+			if (current.getRight() == null)
+				current.setRight(node);
+			else
+				insert(current.getRight(), node);
+		}
+	}
+
+	@Override
+	public String toString() {
+		return new BFSNodeQueue().toString();
+	}
+
+	/**
+	 * 广度优先遍历节点队列
+	 * 
+	 * @author Administrator
+	 *
+	 */
+	private class BFSNodeQueue {
+		private MyQueue<BinaryTreeNode<T>> nodeQueue;
+
+		public BFSNodeQueue() {
+			nodeQueue = new MyQueue<>();
+		}
+
+		public boolean isEmpty() {
+			return nodeQueue.isEmpty();
+		}
+
+		public void enQueue(BinaryTreeNode<T> node) {
+			if (node != null) nodeQueue.enQueue(node);
+		}
+
+		// 出队同时把子节点入队
+		public BinaryTreeNode<T> deQueue() {
+			if (!isEmpty()) {
+				BinaryTreeNode<T> first = nodeQueue.deQueue();
+				enQueue(first.getLeft());
+				enQueue(first.getRight());
+				return first;
+			}
+			throw new QueueIsEmptyException();
+		}
+
+		// 把所有出队节点放进另一个队列中
+		public MyQueue<BinaryTreeNode<T>> getResult() {
+			prepare();
+			MyQueue<BinaryTreeNode<T>> result = new MyQueue<>();
+			while (!isEmpty()) {
+				result.enQueue(deQueue());
+			}
+			return result;
+		}
+
+		private void prepare() {
+			clearQueue();
+			enQueue(root);
+		}
+
+		public void clearQueue() {
+			while (!isEmpty()) {
+				deQueue();
+			}
+		}
+
+		@Override
+		public String toString() {
+			StringBuilder stringBuilder = new StringBuilder();
+
+			Iterator<BinaryTreeNode<T>> iterator = iterator();
+			while (iterator.hasNext()) {
+				stringBuilder.append(iterator.next() + "\n");
+			}
+			return stringBuilder.toString();
+		}
+	}
+
+	@Override
+	public Iterator<BinaryTreeNode<T>> iterator() {
+		return new BFSIterator();
+	}
+
+	private class BFSIterator implements Iterator<BinaryTreeNode<T>> {
+		MyArrayList<BinaryTreeNode<T>> list;
+		Iterator<BinaryTreeNode<T>> iterator;
+
+		public BFSIterator() {
+			MyQueue<BinaryTreeNode<T>> BFSQueue = new BFSNodeQueue().getResult();
+			list = new MyArrayList<>();
+			while (!BFSQueue.isEmpty()) {
+				list.add(BFSQueue.deQueue());
+			}
+			iterator = list.iterator();
+		}
+
+		@Override
+		public boolean hasNext() {
+			return iterator.hasNext();
+		}
+
+		@Override
+		public BinaryTreeNode<T> next() {
+			return iterator.next();
+		}
+	}
+
+	public static void main(String[] args) {
+		BinaryTree<Integer> binaryTree = new BinaryTree<>(5);
+		binaryTree.insert(6);
+		binaryTree.insert(7);
+		binaryTree.insert(4);
+		Iterator<BinaryTreeNode<Integer>> iterator = binaryTree.iterator();
+		while (iterator.hasNext()) {
+			System.out.println(iterator.next());
+		}
+		System.out.println(binaryTree);
+	}
+}
diff --git a/group17/1264835468/src/assignment/BinaryTreeNode.java b/group17/1264835468/src/assignment/BinaryTreeNode.java
new file mode 100644
index 0000000000..81d9e13004
--- /dev/null
+++ b/group17/1264835468/src/assignment/BinaryTreeNode.java
@@ -0,0 +1,58 @@
+package assignment;
+
+public class BinaryTreeNode<T extends Comparable<? super T>> {
+	private T data;
+	private BinaryTreeNode<T> left;
+	private BinaryTreeNode<T> right;
+
+	public BinaryTreeNode(T data) {
+		this.data = data;
+	}
+
+	public T getData() {
+		return data;
+	}
+
+	public void setData(T data) {
+		this.data = data;
+	}
+
+	public BinaryTreeNode<T> getLeft() {
+		return left;
+	}
+
+	public void setLeft(BinaryTreeNode<T> left) {
+		this.left = left;
+	}
+
+	public BinaryTreeNode<T> getRight() {
+		return right;
+	}
+
+	public void setRight(BinaryTreeNode<T> right) {
+		this.right = right;
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder stringBuilder = new StringBuilder();
+		stringBuilder.append("node:" + data);
+		// 非叶节点则加上左右子节点data
+		if (left != null || right != null) {
+			if (left != null)
+				stringBuilder.append(",left:" + left.data);
+			else
+				stringBuilder.append(",left:null");
+			if (right != null)
+				stringBuilder.append(",right:" + right.data);
+			else
+				stringBuilder.append(",right:null");
+		}
+		return stringBuilder.toString();
+	}
+
+	public static void main(String[] args) {
+		// BinaryTreeNode<Integer> binaryTreeNode = new BinaryTreeNode<>(1);
+	}
+
+}
diff --git a/group17/1264835468/src/assignment/Iterable.java b/group17/1264835468/src/assignment/Iterable.java
new file mode 100644
index 0000000000..7cf6048b3d
--- /dev/null
+++ b/group17/1264835468/src/assignment/Iterable.java
@@ -0,0 +1,6 @@
+package assignment;
+
+//
+public interface Iterable<T> {
+	Iterator<T> iterator();
+}
diff --git a/group17/1264835468/src/assignment/Iterator.java b/group17/1264835468/src/assignment/Iterator.java
new file mode 100644
index 0000000000..5152d882c6
--- /dev/null
+++ b/group17/1264835468/src/assignment/Iterator.java
@@ -0,0 +1,7 @@
+package assignment;
+
+public interface Iterator<E> {
+	public boolean hasNext();
+
+	public E next();
+}
diff --git a/group17/1264835468/src/assignment/List.java b/group17/1264835468/src/assignment/List.java
new file mode 100644
index 0000000000..5ab03b0fdf
--- /dev/null
+++ b/group17/1264835468/src/assignment/List.java
@@ -0,0 +1,14 @@
+package assignment;
+
+//
+public interface List<E> {
+	public void add(E o);
+
+	public void add(int index, E o);
+
+	public E get(int index);
+
+	public E remove(int index);
+
+	public int size();
+}
diff --git a/group17/1264835468/src/assignment/MyArrayList.java b/group17/1264835468/src/assignment/MyArrayList.java
new file mode 100644
index 0000000000..ea9ae87755
--- /dev/null
+++ b/group17/1264835468/src/assignment/MyArrayList.java
@@ -0,0 +1,110 @@
+package assignment;
+
+import java.util.Arrays;
+
+public class MyArrayList<E> implements List<E>, Iterable<E> {
+	private Object[] elementData;
+	private static final int DEFAULT_SIZE = 10;
+	private int size;
+
+	public MyArrayList() {
+		this(DEFAULT_SIZE);
+	}
+
+	public MyArrayList(int initSize) {
+		if (initSize < 0) {
+			throw new IllegalArgumentException(initSize + " < 0");
+		}
+		if (initSize == 0) {
+			elementData = new Object[DEFAULT_SIZE];
+		}
+		else {
+			elementData = new Object[initSize];
+		}
+		size = 0;
+	}
+
+	public void add(E o) {
+		growIfNeed();
+		elementData[size++] = o;
+	}
+
+	public void add(int index, E o) {
+		if (index < 0 || index > size) {
+			throw new IllegalArgumentException("index:" + index);
+		}
+		growIfNeed();
+		System.arraycopy(elementData, index, elementData, index + 1, size - index);
+		elementData[index] = o;
+		size++;
+	}
+
+	@SuppressWarnings("unchecked")
+	public E get(int index) {
+		rangeCheck(index);
+		return (E) elementData[index];
+	}
+
+	public E remove(int index) {
+		rangeCheck(index);
+		E target = get(index);
+		System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
+		size--;
+		return target;
+	}
+
+	public int size() {
+		return size;
+	}
+
+	private void rangeCheck(int index) {
+		if (index >= size) {
+			throw new NoSuchElementException("index:" + index);
+		}
+	}
+
+	private void growIfNeed() {
+		if (size == elementData.length)
+			grow();
+	}
+
+	private void grow() {
+		elementData = Arrays.copyOf(elementData, elementData.length * 2);
+	}
+
+	@Override
+	public Iterator<E> iterator() {
+		return new ArrayIterator<>();
+	}
+
+	private class ArrayIterator<E> implements Iterator<E> {
+		private int currentPos = 0;
+
+		@Override
+		public boolean hasNext() {
+			return currentPos < size;
+		}
+
+		@SuppressWarnings("unchecked")
+		@Override
+		public E next() {
+			rangeCheck(currentPos);
+			return (E) elementData[currentPos++];
+		}
+
+	}
+
+	@Override
+	public String toString() {
+		return Arrays.toString(Arrays.copyOf(elementData, size));
+	}
+
+}
+
+class NoSuchElementException extends RuntimeException {
+
+	public NoSuchElementException(String string) {
+		super(string);
+	}
+
+}
diff --git a/group17/1264835468/src/assignment/MyLinkedList.java b/group17/1264835468/src/assignment/MyLinkedList.java
new file mode 100644
index 0000000000..d0f417e845
--- /dev/null
+++ b/group17/1264835468/src/assignment/MyLinkedList.java
@@ -0,0 +1,144 @@
+package assignment;
+
+public class MyLinkedList<E> implements List<E>, Iterable<E> {
+	private Node<E> head;
+	private int size;
+
+	public MyLinkedList() {
+		size = 0;
+	}
+
+	public void add(E o) {
+		if (head == null)
+			addFirst(o);
+		else
+			addLast(o);
+	}
+
+	public void addFirst(E o) {
+		Node<E> oldFirst = head;
+		head = new Node<>(o, oldFirst);
+		size++;
+	}
+
+	public void addLast(E o) {
+		if (head == null) {
+			addFirst(o);
+		}
+		else {
+			Node<E> oldLast = movePtrTo(size - 1);
+			oldLast.next = new Node<>(o, null);
+			size++;
+		}
+
+	}
+
+	public void add(int index, E o) {
+		if (index > size || index < 0) {
+			throw new IllegalArgumentException("index:" + index);
+		}
+		if (index == 0) {
+			addFirst(o);
+			return;
+		}
+		Node<E> temp = movePtrTo(index - 1);
+		Node<E> oldNext = temp.next;
+		Node<E> newNext = new Node<>(o, oldNext);
+		temp.next = newNext;
+		size++;
+	}
+
+	public E remove(int index) {
+		rangeCheck(index);
+		E data;
+		if (index == 0) {
+			data = head.data;
+			head = head.next;
+		}
+		else {
+			Node<E> pre = movePtrTo(index - 1);
+			Node<E> target = pre.next;
+			pre.next = target.next;
+			data = target.data;
+		}
+		size--;
+		return data;
+	}
+
+	public E get(int index) {
+		rangeCheck(index);
+		return movePtrTo(index).data;
+	}
+
+	public int size() {
+		return size;
+	}
+
+	private Node<E> movePtrTo(int index) {
+		Node<E> resultNode = head;
+		for (int i = 0; i < index; i++) {
+			resultNode = resultNode.next;
+		}
+		return resultNode;
+	}
+
+	private void rangeCheck(int index) {
+		if (index >= size) {
+			throw new NoSuchElementException("index:" + index);
+		}
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder stringBuilder = new StringBuilder('[');
+		Node<E> temp = head;
+		while (temp != null) {
+			stringBuilder.append(String.valueOf(temp.toString()) + ",");
+			temp = temp.next;
+		}
+		stringBuilder.delete(stringBuilder.length() - 1, stringBuilder.length());
+		stringBuilder.append(']');
+		return stringBuilder.toString();
+	}
+
+	private static class Node<T> {
+		private T data;
+		private Node<T> next;
+
+		public Node(T data, Node<T> next) {
+			this.data = data;
+			this.next = next;
+		}
+
+		@Override
+		public String toString() {
+			return data.toString();
+		}
+	}
+
+	@Override
+	public Iterator<E> iterator() {
+		return new ListIterator();
+	}
+
+	private class ListIterator implements Iterator<E> {
+		Node<E> currentNode;
+
+		public ListIterator() {
+			currentNode = head;
+		}
+
+		@Override
+		public boolean hasNext() {
+			return currentNode.next != null;
+		}
+
+		@Override
+		public E next() {
+			Node<E> temp = currentNode;
+			currentNode = currentNode.next;
+			return temp.data;
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/group17/1264835468/src/assignment/MyQueue.java b/group17/1264835468/src/assignment/MyQueue.java
new file mode 100644
index 0000000000..d39b19c4b5
--- /dev/null
+++ b/group17/1264835468/src/assignment/MyQueue.java
@@ -0,0 +1,34 @@
+package assignment;
+
+public class MyQueue<T> {
+	private MyLinkedList<T> elementData = new MyLinkedList<>();
+
+	public void enQueue(T o) {
+		elementData.addLast(o);
+	}
+
+	public T deQueue() {
+		if (!isEmpty()) {
+			return elementData.remove(0);
+		}
+		throw new QueueIsEmptyException();
+	}
+
+	public boolean isEmpty() {
+		return elementData.size() == 0;
+	}
+
+	public int size() {
+		return elementData.size();
+	}
+}
+
+class QueueIsEmptyException extends RuntimeException {
+	public QueueIsEmptyException() {
+		super();
+	}
+
+	public QueueIsEmptyException(String string) {
+		super(string);
+	}
+}
diff --git a/group17/1264835468/src/assignment/MyStack.java b/group17/1264835468/src/assignment/MyStack.java
new file mode 100644
index 0000000000..c3d4f9fb9a
--- /dev/null
+++ b/group17/1264835468/src/assignment/MyStack.java
@@ -0,0 +1,39 @@
+package assignment;
+
+public class MyStack<T> {
+	private MyArrayList<T> elementData = new MyArrayList<>();
+
+	public void push(T o) {
+		elementData.add(o);
+	}
+
+	public T pop() {
+		if (!isEmpty()) {
+			T data = elementData.remove(elementData.size() - 1);
+			return data;
+		}
+		throw new StackIsEmptyException();
+	}
+
+	public T peek() {
+		return elementData.get(elementData.size() - 1);
+	}
+
+	public boolean isEmpty() {
+		return elementData.size() == 0;
+	}
+
+	public int size() {
+		return elementData.size();
+	}
+}
+
+class StackIsEmptyException extends RuntimeException {
+	public StackIsEmptyException() {
+		super();
+	}
+
+	public StackIsEmptyException(String string) {
+		super(string);
+	}
+}
diff --git a/group17/1540186032/First/src/ArrayList.java b/group17/1540186032/First/src/ArrayList.java
new file mode 100644
index 0000000000..c039889a8e
--- /dev/null
+++ b/group17/1540186032/First/src/ArrayList.java
@@ -0,0 +1,64 @@
+public class ArrayList implements List {
+
+	private int size = 0;
+
+	private Object[] elementData = new Object[5];
+
+	public void add(Object o) {
+		if (size >= elementData.length) {
+			resize(2 * size);
+		}
+		elementData[size] = o;
+		size++;
+	}
+
+	public void add(int index, Object o) {
+		if (index > size) {
+			throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+					+ size);
+		}
+		if (size >= elementData.length) {
+			resize(2 * size);
+		}
+		for (int i = size; i > index; i--) {
+			elementData[i] = elementData[i - 1];
+		}
+		elementData[index] = o;
+		size++;
+	}
+
+	public Object get(int index) {
+		if (index >= size) {
+			throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+					+ size);
+		}
+		return elementData[index];
+	}
+
+	public Object remove(int index) {
+		Object o = elementData[index];
+		for (int i = index; i < size - 1; i++) {
+			elementData[i] = elementData[i + 1];
+		}
+		elementData[size - 1] = null;
+		size--;
+		return o;
+	}
+
+	public int size() {
+		return size;
+	}
+
+	public Iterator iterator() {
+		return null;
+	}
+
+	private void resize(int n) {
+		Object[] temp = elementData;
+		elementData = new Object[n];
+		for (int i = 0; i < temp.length; i++) {
+			elementData[i] = temp[i];
+		}
+	}
+
+}
diff --git a/group17/1540186032/First/src/BinaryTreeNode.java b/group17/1540186032/First/src/BinaryTreeNode.java
new file mode 100644
index 0000000000..f5ff087138
--- /dev/null
+++ b/group17/1540186032/First/src/BinaryTreeNode.java
@@ -0,0 +1,31 @@
+
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git a/group17/1540186032/First/src/Iterator.java b/group17/1540186032/First/src/Iterator.java
new file mode 100644
index 0000000000..73b303c8c2
--- /dev/null
+++ b/group17/1540186032/First/src/Iterator.java
@@ -0,0 +1,6 @@
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
diff --git a/group17/1540186032/First/src/LinkedList.java b/group17/1540186032/First/src/LinkedList.java
new file mode 100644
index 0000000000..8510036684
--- /dev/null
+++ b/group17/1540186032/First/src/LinkedList.java
@@ -0,0 +1,131 @@
+public class LinkedList implements List {
+	public static void main(String[] args) {
+		LinkedList linkedList = new LinkedList();
+		linkedList.add(0);
+
+		System.out.println(linkedList.get(0));
+
+	}
+
+	private Node first;
+
+	private Node last;
+
+	private int size = 0;
+
+	public void add(Object o) {
+		Node oldLast = last;
+		last = new Node();
+		last.data = o;
+		last.next = null;
+		if (oldLast != null) {
+			oldLast.next = last;
+		}
+		if (first == null) {
+			first = last;
+		}
+		size++;
+	}
+
+	public void add(int index, Object o) {
+		if (index > size) {
+			throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+					+ size);
+		}
+		if (index == 0) {
+			addFirst(o);
+			return;
+		}
+		if (index == size) {
+			addLast(o);
+			return;
+		}
+		Node curserNode = cursor(index - 1);
+		Node newNode = new Node();
+		newNode.data = o;
+		newNode.next = curserNode.next;
+		curserNode.next = newNode;
+		size++;
+	}
+
+	public Object get(int index) {
+		return cursor(index).data;
+	}
+
+	public Object remove(int index) {
+		Node node = cursor(index - 1).next;
+		cursor(index - 1).next = node.next;
+		node.next = null;
+		return node.data;
+	}
+
+	public int size() {
+		return size;
+	}
+
+	public void addFirst(Object o) {
+		Node newNode = new Node();
+		newNode.data = o;
+		if (first == null) {
+			first = newNode;
+		} else {
+			newNode.next = first;
+			first = newNode;
+		}
+		if (last == null) {
+			last = first;
+		}
+		size++;
+	}
+
+	public void addLast(Object o) {
+		Node newNode = new Node();
+		newNode.data = o;
+		if (last == null) {
+			last = newNode;
+		} else {
+			last.next = newNode;
+			last = newNode;
+		}
+		if (first == null) {
+			first = last;
+		}
+		size++;
+	}
+
+	public Object removeFirst() {
+		Node node = first;
+		Node newFirst = first.next;
+		first.next = null;
+		first = newFirst;
+		size--;
+		return node.data;
+	}
+
+	public Object removeLast() {
+		Node node = last;
+		Node newLast = cursor(size - 1);
+		newLast.next = null;
+		last = newLast;
+		size--;
+		return node.data;
+	}
+
+	public Iterator iterator() {
+		return null;
+	}
+
+	private Node cursor(int index) {
+		Node curserNode = first;
+		for (int i = 0; i < index; i++) {
+			curserNode = curserNode.next;
+		}
+		return curserNode;
+	}
+
+	private static class Node {
+		Object data;
+		Node next;
+
+	}
+}
diff --git a/group17/1540186032/First/src/List.java b/group17/1540186032/First/src/List.java
new file mode 100644
index 0000000000..8cb4ba5aff
--- /dev/null
+++ b/group17/1540186032/First/src/List.java
@@ -0,0 +1,8 @@
+
+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/group17/1540186032/First/src/Queue.java b/group17/1540186032/First/src/Queue.java
new file mode 100644
index 0000000000..325fa033d1
--- /dev/null
+++ b/group17/1540186032/First/src/Queue.java
@@ -0,0 +1,23 @@
+
+public class Queue {
+	LinkedList elementData = new LinkedList();
+
+	public void enQueue(Object o) {
+		elementData.add(o);
+	}
+
+	public Object deQueue() {
+		if (elementData.size() == 0) {
+
+		}
+		return elementData.removeFirst();
+	}
+
+	public boolean isEmpty() {
+		return elementData.size() == 0;
+	}
+
+	public int size() {
+		return elementData.size();
+	}
+}
diff --git a/group17/1540186032/First/src/Stack.java b/group17/1540186032/First/src/Stack.java
new file mode 100644
index 0000000000..47f5244f0d
--- /dev/null
+++ b/group17/1540186032/First/src/Stack.java
@@ -0,0 +1,28 @@
+import java.util.EmptyStackException;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+
+	public void push(Object o) {
+		elementData.add(o);
+	}
+
+	public Object pop() {
+		if (elementData.size() == 0) {
+			throw new EmptyStackException();
+		}
+		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/group17/176653813/1766538130226Lesson/.classpath b/group17/176653813/1766538130226Lesson/.classpath
new file mode 100644
index 0000000000..373dce4005
--- /dev/null
+++ b/group17/176653813/1766538130226Lesson/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group17/176653813/1766538130226Lesson/.gitignore b/group17/176653813/1766538130226Lesson/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group17/176653813/1766538130226Lesson/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group17/176653813/1766538130226Lesson/.project b/group17/176653813/1766538130226Lesson/.project
new file mode 100644
index 0000000000..96a5027846
--- /dev/null
+++ b/group17/176653813/1766538130226Lesson/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>1766538130226Lesson</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group17/176653813/1766538130226Lesson/.settings/org.eclipse.jdt.core.prefs b/group17/176653813/1766538130226Lesson/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..3a21537071
--- /dev/null
+++ b/group17/176653813/1766538130226Lesson/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/group17/176653813/1766538130226Lesson/src/com/coding/basic/ArrayList.java b/group17/176653813/1766538130226Lesson/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..61df9ada90
--- /dev/null
+++ b/group17/176653813/1766538130226Lesson/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,80 @@
+package com.coding.basic;
+
+public class ArrayList implements List {
+
+	private int size = 0;
+	private Object[] obj = new Object[5];
+	
+	@Override
+	public void add(Object o) {
+		if(this.size < 0 )
+			System.out.print("Error");
+		this.extend(100);
+		obj[this.size] = o;
+		this.size ++;
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		
+		if(index < 0)
+			System.out.println("Error");
+		if(index < this.size){
+			extend(100);
+			for(int i = this.size;i < index; i--){
+				obj[i+1] = obj[i];
+			}
+			obj[index] = o;
+		}else if(index >= size){
+			extend(100);
+			obj[size] = o;
+		}
+		this.size++;
+	}
+
+	@Override
+	public Object get(int index) {
+		if(index < 0 || index > size){
+			System.out.println("Error");
+			return null;
+		}
+		return obj[index];
+	}
+
+	@Override
+	public Object remove(int index) {
+		if(index < 0 || index > size){
+			System.out.println("Error");
+			return null;
+		}
+		for(int i = index;i <= size;i++){
+			obj[i] = obj[i+1];
+		}
+		size--;
+		return obj[index];
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+	public int length(){
+		return obj.length;
+	}
+	public void extend(int newLength){
+		if (this.size >= obj.length){
+			//��չ����
+			Object[] old = obj;
+			obj = new Object[size+newLength];
+			for(int i = 0;i < size; i++){
+				obj[i] = old[i];
+			}
+		}
+		return;
+	}
+	public void Iteror(){
+		for(int i = 0 ;i < size ; i++){
+			System.out.println(obj[i]);
+		}
+	}
+}
diff --git a/group17/176653813/1766538130226Lesson/src/com/coding/basic/LinkList.java b/group17/176653813/1766538130226Lesson/src/com/coding/basic/LinkList.java
new file mode 100644
index 0000000000..2f4e0e3067
--- /dev/null
+++ b/group17/176653813/1766538130226Lesson/src/com/coding/basic/LinkList.java
@@ -0,0 +1,96 @@
+package com.coding.basic;
+
+public class LinkList implements List{
+
+	private Node head; //ͷ��㲻�������
+	private static class Node{
+		Object data;
+		Node next;
+	}
+	
+	@Override
+	public void add(Object o) {
+		//��һ��û���뵽
+		if(null == head){
+			head = new Node();
+			head.next = null;
+			head.data = o;
+		}else{
+			//β���뷨
+			//Node t = new Node();
+			Node t;
+			Node ins = new Node();
+			t = head;
+			while(t.next != null){
+				t = t.next;
+			}
+			t.next = ins;
+			ins.next = null;
+			ins.data = o;
+		}
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		if(index < 0 ){
+			System.out.println("Error");
+		}else if(index == 0 || index == 1){
+			Node t = new Node();
+			t.next = head.next;
+			head.next = t;
+			t.data = o;
+		}else{
+			Node t = new Node();//��ǰ�ڵ�
+			Node p = new Node();//ǰһ���ڵ�
+			t = head.next;
+			for(int i = 1;i < index;i++){
+				p = t;
+				t = t.next;
+			}
+			Node ins = new Node();
+			p.next = ins;
+			ins.next = t;
+			ins.data = o;
+		}
+		
+	}
+
+	@Override
+	public Object get(int index) {
+		if(index < 0 || head == null){
+			System.out.println("Error");
+			return null;
+		}else{
+			Node t ;
+			t = head;
+			for(int i = 1;i < index;i++){
+				t = t.next;
+			}
+			return t.data;
+		}
+	}
+
+	@Override
+	public Object remove(int index) {
+		
+		return null;
+	}
+
+	public void display(){
+		if(head == null){
+			System.out.println("No Data");
+		}else{
+			Node t ;
+			t = head;
+			while(t != null){
+				System.out.println("******"+t.data);
+				t = t.next;
+			}
+		}
+		
+	}
+	@Override
+	public int size() {
+		return 0;
+	}
+}
diff --git a/group17/176653813/1766538130226Lesson/src/com/coding/basic/List.java b/group17/176653813/1766538130226Lesson/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..124fba53ec
--- /dev/null
+++ b/group17/176653813/1766538130226Lesson/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/group17/176653813/1766538130226Lesson/src/com/coding/basic/Queue.java b/group17/176653813/1766538130226Lesson/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..032b636962
--- /dev/null
+++ b/group17/176653813/1766538130226Lesson/src/com/coding/basic/Queue.java
@@ -0,0 +1,35 @@
+package com.coding.basic;
+
+public class Queue {
+	
+	private LinkList elementData = new LinkList();
+	private int front = 0;
+	private int rear = 0;
+	
+	
+	public void enQueue(Object o){
+		elementData.add(o);
+		rear++;
+	}
+	public Object deQueue(){
+		if(!isEmpty()){
+			Object obj = elementData.remove(front);
+			front++;
+			return obj;
+		}else{
+			System.out.println("Queue is empty");
+			return null;
+		}
+	}
+	public boolean isEmpty(){
+		if(front > rear){
+			return true;
+		}
+		return false;
+	}
+	
+	public int size(){
+		return rear-front+1;
+	}
+}
+	
diff --git a/group17/176653813/1766538130226Lesson/src/com/coding/basic/Stack.java b/group17/176653813/1766538130226Lesson/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..b902dea844
--- /dev/null
+++ b/group17/176653813/1766538130226Lesson/src/com/coding/basic/Stack.java
@@ -0,0 +1,41 @@
+package com.coding.basic;
+
+public class Stack {
+	
+	//
+	private ArrayList elementData = new ArrayList();
+	private int top = 0;
+	
+	public void push(Object o){
+		elementData.add(o);
+		top++;
+	}
+	
+	public Object pop(){
+		if(!isEmpty()){
+			System.out.println("stack is empoty");
+			return null;
+		}
+		Object obj = elementData.remove(top);
+		top--;
+		return obj;
+	}
+	
+	public Object peek(){
+		return elementData.get(top);
+	}
+	
+	public boolean isEmpty(){
+		if(top != 0){
+			return true;
+		}
+		return false;
+	}
+	
+	public int size(){
+		return top++;
+	}
+	
+	
+
+}
diff --git a/group17/176653813/1766538130226Lesson/src/com/coding/basic/Test.java b/group17/176653813/1766538130226Lesson/src/com/coding/basic/Test.java
new file mode 100644
index 0000000000..6f48b4b4fd
--- /dev/null
+++ b/group17/176653813/1766538130226Lesson/src/com/coding/basic/Test.java
@@ -0,0 +1,36 @@
+package com.coding.basic;
+
+import static org.junit.Assert.*;
+
+public class Test {
+
+	@org.junit.Test
+	public void test() {
+		
+/*		ArrayList al = new ArrayList();
+		al.add(1);
+		al.add(2);
+		al.add(3);
+		al.add(4);
+		al.add(5);
+		al.add(200);
+		al.add(10,100);
+		al.Iteror();
+		//System.out.println(al.length());
+		//System.out.println(al.size());
+		System.out.println("==================");
+		al.remove(0);
+		al.Iteror();*/
+		
+		LinkList ls = new LinkList();
+		ls.add(100);
+		ls.add(300);
+		ls.add(500);
+		ls.add(1000);
+		ls.add(3,2000);
+		ls.display();
+		System.out.println(ls.get(4));
+	}
+
+}
+
diff --git a/group17/176653813/RemoteSystemsTempFiles/.project b/group17/176653813/RemoteSystemsTempFiles/.project
new file mode 100644
index 0000000000..5447a64fa9
--- /dev/null
+++ b/group17/176653813/RemoteSystemsTempFiles/.project
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>RemoteSystemsTempFiles</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.rse.ui.remoteSystemsTempNature</nature>
+	</natures>
+</projectDescription>
diff --git a/group17/240094626/.gitignore b/group17/240094626/.gitignore
new file mode 100644
index 0000000000..e59106a7ab
--- /dev/null
+++ b/group17/240094626/.gitignore
@@ -0,0 +1,22 @@
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+#ide config
+.metadata
+.recommenders
+
+*.settings
+*.project
+*.classpath
+*/.settings
+/**/target/**/*
diff --git a/group17/240094626/warm-up/.gitignore b/group17/240094626/warm-up/.gitignore
new file mode 100644
index 0000000000..c7b6e44e1d
--- /dev/null
+++ b/group17/240094626/warm-up/.gitignore
@@ -0,0 +1,4 @@
+/bin/
+*.classpath
+*.project
+/.settings/
diff --git a/group17/240094626/warm-up/src/com/coding/basic/Iterator.java b/group17/240094626/warm-up/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..06ef6311b2
--- /dev/null
+++ b/group17/240094626/warm-up/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/group17/240094626/warm-up/src/com/coding/basic/List.java b/group17/240094626/warm-up/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ b/group17/240094626/warm-up/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/group17/240094626/warm-up/src/com/coding/basic/impl/ArrayList.java b/group17/240094626/warm-up/src/com/coding/basic/impl/ArrayList.java
new file mode 100644
index 0000000000..c20eb376d4
--- /dev/null
+++ b/group17/240094626/warm-up/src/com/coding/basic/impl/ArrayList.java
@@ -0,0 +1,166 @@
+package com.coding.basic.impl;
+
+import java.util.Arrays;
+
+import com.coding.basic.Iterator;
+import com.coding.basic.List;
+
+/**
+ * 
+ * @描述: ArrayList简单实现
+ * @作者:240094626
+ * @创建日期:2017-2-20
+ */
+public class ArrayList implements List  {
+	
+	
+	/**
+	 * @comment:元素数组
+	 */
+	private Object data[] = null;
+	
+	/**
+	 * @comment:数组元素个数
+	 */
+	private int size = 0;
+	
+	/**
+	 * 无参构造函数，初始化容量为10的空列表
+	 */
+	public ArrayList(){
+		this(10);
+	}
+	
+	/**
+	 * @param length
+	 * 构造函数，初始化容量为length的空列表
+	 */
+	public ArrayList(int length){
+		if(length < 0){
+			throw new IllegalArgumentException("初始容量参数非法："+length);
+		}
+		data = new Object[length];
+	}
+	
+	
+	/**
+	 * @createTime: 2017-2-21 下午1:32:28
+	 * @param length
+	 * @return:void
+	 * @comment：列表结构扩展容量，每次增加原来的1/2容量
+	 */
+	private void grow(int length){ 
+		int oldLength = data.length;
+		if(length > oldLength){
+			Object oldData[] = data;
+			int newLength = oldLength*3/2 + 1;
+			if(newLength < length){
+				newLength = length;
+			}
+			data = new Object[newLength];
+			System.arraycopy(oldData, 0, data, 0, oldLength);
+		}
+	}
+	
+	/**
+	 * @createTime: 2017-2-21 下午1:32:05
+	 * @param index
+	 * @return:void
+	 * @comment：检验下标参数是否超限
+	 */
+	private void check(int index) {
+		if( index >= size){
+			throw new IndexOutOfBoundsException("Index:"+index+",size:"+size);
+		}
+	}
+	
+	@Override
+	public void add(Object o) {
+		grow(size+1);
+		data[size++]=o;
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		if( index > size || index < 0){
+			throw new IndexOutOfBoundsException("Index:"+index);
+		}
+		grow(size+1);
+		System.arraycopy(data, index, data, index+1, size-index);
+		data[index] = o;
+		size++;
+		
+	}
+
+	@Override
+	public Object get(int index) {
+		check(index);
+		return data[index];
+	}
+
+	
+
+	@Override
+	public Object remove(int index) {
+		check(index);
+		Object remove = data[index];
+		System.arraycopy(data, index+1, data, index, size-index);
+		data[--size] = null;
+		return remove;
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+	
+
+	@Override
+	public String toString() {
+		return "ArrayList [data=" + Arrays.toString(data) + ", size=" + size
+				+ "]";
+	}
+	
+	public Iterator iterator(){
+		return new ArrayListIterator();
+	}
+	
+	/** 
+	 * @描述: 简单实现迭代器
+	 * @作者:240094626
+	 * @创建日期:2017-2-21
+	 */  
+	private class ArrayListIterator implements Iterator{
+
+		/**
+		 * @column:index
+		 * @comment:当前位置下标
+		 */
+		private int index;
+		
+		/**
+		 * 无参构造，初始化迭代器的下标为0
+		 */
+		public ArrayListIterator(){
+			index = 0;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			if(index < size){
+				return true;
+			}
+			return false;
+		}
+
+		@Override
+		public Object next() {
+			Object o = get(index++);
+			return o;
+		}
+		
+	}
+
+}
+
+
diff --git a/group17/240094626/warm-up/src/com/coding/basic/impl/BinaryTree.java b/group17/240094626/warm-up/src/com/coding/basic/impl/BinaryTree.java
new file mode 100644
index 0000000000..d9478146bd
--- /dev/null
+++ b/group17/240094626/warm-up/src/com/coding/basic/impl/BinaryTree.java
@@ -0,0 +1,82 @@
+package com.coding.basic.impl;
+
+
+/**
+ * 二叉树简单实现(key为int类型)
+ * @author 240094626
+ *
+ */
+public class BinaryTree {
+	private Node rootNode = null;
+	
+	public Node insert(int key){
+		return insert(key,null);
+	}
+	
+	public Node insert(int key ,Object o){
+		Node newNode = new Node(key, o);
+		if(rootNode == null){
+			rootNode = newNode;
+			return rootNode;
+		}
+		Node fatherNode = rootNode;
+		Node currentNode = rootNode;
+		while(currentNode != null){
+			fatherNode = currentNode;
+			if(key < currentNode.key){
+				currentNode = currentNode.left;
+			}else{
+				currentNode = currentNode.right;
+			}
+		}
+		if(key < fatherNode.key){
+			fatherNode.left = newNode;
+		}else{
+			fatherNode.right = newNode;
+		}
+		return newNode;
+	}
+	
+	public Node getNode(int key){
+		return get(rootNode, key);
+	}
+	
+	private Node get(Node n,int key){
+		if(n == null){
+			return null;
+		}
+		if(key < n.key){
+			return get(n.left, key);
+		}else if(key > n.key){
+			return get(n.left, key);
+		}
+		return null;
+	}
+	
+	
+	
+
+	private static class Node{
+		
+		int key;
+		Object data;
+		Node left;
+		Node right;
+		
+		public Node(int key, Object data) {
+			this.key = key;
+			this.data = data;
+			this.left = null;
+			this.right = null;
+		}
+
+		@Override
+		public String toString() {
+			return "Node [key=" + key + ", data=" + data + "]";
+		}
+		
+		
+	}
+
+	
+}
diff --git a/group17/240094626/warm-up/src/com/coding/basic/impl/LinkedList.java b/group17/240094626/warm-up/src/com/coding/basic/impl/LinkedList.java
new file mode 100644
index 0000000000..a48b9e4705
--- /dev/null
+++ b/group17/240094626/warm-up/src/com/coding/basic/impl/LinkedList.java
@@ -0,0 +1,184 @@
+package com.coding.basic.impl;
+
+import java.util.NoSuchElementException;
+
+import com.coding.basic.Iterator;
+import com.coding.basic.List;
+
+/**
+ * 双向链表简单实现
+ * @author 240094626
+ */
+public class LinkedList implements List {
+	/**头节点（空的）*/
+	private Node header = new Node(null, null, null); 
+	/**链表节点长度*/
+	private int size = 0;
+
+	
+	/**
+	 * 无参构造函数，初始化header节点，前后均指向header节点，形成环形链表
+	 * 环形链表：为了使链表节点的开头是header，结尾也是header；
+	 * 		由于实现了List，那么链表就是有序的，根据下标查询时可借助环形特点双向查找，提升效率；
+	 */
+	public LinkedList() {
+		header.next = header.pre = header;
+	}
+	
+	
+	/**
+	 * 将Object o 添加到 节点n之前
+	 * @param o
+	 * @param n
+	 */
+	private void addBefore(Object o, Node n) {
+		Node newNode = new Node(o, n.pre, n);
+		newNode.next.pre = newNode;
+		newNode.pre.next = newNode;
+		size++;
+	}
+	
+	/**
+	 * 根据下标位置查找结点
+	 * @param index
+	 * @return
+	 */
+	private Node getNode(int index) {
+		if(index < 0 || index >= size){
+			throw new IndexOutOfBoundsException("index:"+index);
+		}
+		// 查找从header开始
+		Node n = header;
+		if(index < (size >> 1)){
+			// 往next方向找第index个节点
+			for(int i=0; i < index; i++){
+				n = n.next;
+			}
+		}else{
+			// 往pre方向找第size-index个节点
+			for(int i=size-index; i > 0; i--){
+				n = n.pre;
+			}
+		}
+		return n;
+	}
+	
+	
+	/**
+	 * 移除节点，从当前节点的前后节点间删除当前节点
+	 * @param n
+	 * @return
+	 */
+	private Object remove(Node n){
+		if(n == header){
+			throw new NoSuchElementException("未找到节点");
+		}
+		Object result = n.data;
+		n.pre.next = n.next;
+		n.next.pre = n.pre;
+		n.next = n.pre = null;
+		n.data = null;
+		size--;
+		return result;
+	}
+	
+	@Override
+	public void add(Object o) {
+		// 默认往header前添加
+		addBefore(o,header);
+	}
+
+
+	@Override
+	public void add(int index, Object o) {
+		addBefore(o,index==size?header:getNode(index));
+	}
+
+	@Override
+	public Object get(int index) {
+		Node n = getNode(index);
+		return n.data;
+	}
+
+
+	@Override
+	public Object remove(int index) {
+		return remove(getNode(index));
+	}
+
+
+	@Override
+	public int size() {
+		return size;
+	}
+	/**
+	 * 环形链表结构，header.next就是第一个节点
+	 * @param o
+	 */
+	public void addFirst(Object o){
+		addBefore(o, header.next);
+	}
+	/**
+	 * 环形链表结构，header.pre就是最后一个节点
+	 * @param o
+	 */
+	public void addLast(Object o){
+		addBefore(o, header);
+	}
+	public Object removeFirst(){
+		return remove(header.next);
+	}
+	public Object removeLast(){
+		return remove(header.pre);
+	}
+	
+	public Iterator iterator(){
+		
+		return new LinkedListIterator();
+	}
+	
+	private static class Node{
+		Object data;
+		Node pre;
+		Node next;
+		
+		/**
+		 * 链表节点，带参构造函数
+		 * @param data 节点内容
+		 * @param pre 上一个节点
+		 * @param next 下一个节点
+		 */
+		public Node(Object data, Node pre, Node next) {
+			super();
+			this.data = data;
+			this.pre = pre;
+			this.next = next;
+		}
+		
+	}
+	
+	private class LinkedListIterator implements Iterator{
+		int index ;
+		
+		public LinkedListIterator() {
+			index = 0;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			if(index < size){
+				return true;
+			}
+			return false;
+		}
+
+		@Override
+		public Object next() {
+			Node n = getNode(index++);
+			return n.data;
+		}
+		
+	}
+	
+
+}
diff --git a/group17/240094626/warm-up/src/com/coding/basic/impl/Queue.java b/group17/240094626/warm-up/src/com/coding/basic/impl/Queue.java
new file mode 100644
index 0000000000..3a9aa129e2
--- /dev/null
+++ b/group17/240094626/warm-up/src/com/coding/basic/impl/Queue.java
@@ -0,0 +1,67 @@
+package com.coding.basic.impl;
+
+import com.coding.basic.Iterator;
+
+/**
+ * 队列简单实现
+ * @author 240094626
+ *
+ */
+public class Queue {
+	/**队列元素容器对象*/
+	LinkedList elementData = new LinkedList();
+
+	/**
+	 * 入队列
+	 * @param o
+	 */
+	public void enQueue(Object o){	
+		elementData.add(o);
+	}
+	
+	/**
+	 * 出队列：先进先出，故取出链表首个节点
+	 * @return
+	 */
+	public Object deQueue(){
+		return elementData.removeFirst();
+	}
+	
+	public boolean isEmpty(){
+		if(elementData.size() > 0 ){
+			return false;
+		}
+		return true;
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+	
+	public Iterator iterator(){
+		return new QueueIterator();
+	}
+	
+	private class QueueIterator implements Iterator{
+
+		int index;
+		
+		public QueueIterator() {
+			index = 0;
+		}
+
+		@Override
+		public boolean hasNext() {
+			if(index < elementData.size()){
+				return true;
+			}
+			return false;
+		}
+
+		@Override
+		public Object next() {
+			return elementData.get(index++);
+		}
+		
+	}
+}
diff --git a/group17/240094626/warm-up/src/com/coding/basic/impl/Stack.java b/group17/240094626/warm-up/src/com/coding/basic/impl/Stack.java
new file mode 100644
index 0000000000..d4c3158f94
--- /dev/null
+++ b/group17/240094626/warm-up/src/com/coding/basic/impl/Stack.java
@@ -0,0 +1,78 @@
+package com.coding.basic.impl;
+
+import com.coding.basic.Iterator;
+
+/**
+ * 栈的简单实现
+ * @author 240094626
+ */
+public class Stack {
+	/**长度可变的元素容器*/
+	private ArrayList elementData = new ArrayList();
+	
+	/**
+	 * 压入栈
+	 * @param o
+	 */
+	public void push(Object o){		
+		elementData.add(o);
+	}
+	
+	/**
+	 * 出栈（末尾元素），并移除
+	 * @return Object
+	 */
+	public Object pop(){
+		return elementData.remove(elementData.size()-1);
+	}
+	
+	/**
+	 * 取出栈（末尾元素），不移除
+	 * @return Object
+	 */
+	public Object peek(){
+		return elementData.get(elementData.size()-1);
+	}
+	
+	/**
+	 * 判断栈是否为空
+	 * @return boolean
+	 */
+	public boolean isEmpty(){
+		return elementData.size() == 0 ? true : false;
+	}
+	
+	/**
+	 * 栈的长度，既是容器ArrayList的长度
+	 * @return int
+	 */
+	public int size(){
+		return elementData.size();
+	}
+	
+	public Iterator iterator(){
+		return new StackIterator();
+	}
+	private class StackIterator implements Iterator{
+		int index;
+
+		public StackIterator() {
+			index = 0;
+		}
+
+		@Override
+		public boolean hasNext() {
+			if(index < elementData.size()){
+				return true;
+			}
+			return false;
+		}
+
+		@Override
+		public Object next() {
+			return elementData.get(index);
+		}
+		
+		
+	}
+}
\ No newline at end of file
diff --git a/group17/51075907/HomeWork/.classpath b/group17/51075907/HomeWork/.classpath
new file mode 100644
index 0000000000..10b13d9f7a
--- /dev/null
+++ b/group17/51075907/HomeWork/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry exported="true" kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/jre1.8.0_60"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group17/51075907/HomeWork/.project b/group17/51075907/HomeWork/.project
new file mode 100644
index 0000000000..c27db84883
--- /dev/null
+++ b/group17/51075907/HomeWork/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>HomeWork</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group17/51075907/HomeWork/.settings/org.eclipse.jdt.core.prefs b/group17/51075907/HomeWork/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..43785549a2
--- /dev/null
+++ b/group17/51075907/HomeWork/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.2
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.4
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=warning
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning
+org.eclipse.jdt.core.compiler.source=1.3
diff --git a/group17/51075907/HomeWork/src/day1_HomeWork/ArrayList.java b/group17/51075907/HomeWork/src/day1_HomeWork/ArrayList.java
new file mode 100644
index 0000000000..5a164ce8ca
--- /dev/null
+++ b/group17/51075907/HomeWork/src/day1_HomeWork/ArrayList.java
@@ -0,0 +1,75 @@
+package day1_HomeWork;
+
+ 
+ public class ArrayList implements List {
+ 	
+ 	private int size = 0;
+ 	
+ 	private Object[] elementData = new Object[100];
+ 	
+ 	//�������ռ䳬����ǰ��С,��֤����
+ 	public void ensureCapacity( int newCapacity)
+ 	{
+ 		if ( newCapacity < size)
+ 			return;
+ 		
+ 		Object [] old =elementData;
+ 		elementData =(Object []) new Object[newCapacity];
+ 		for (int i=0; i<size(); i++ )
+ 			elementData[i] =old[i]; 			 		
+ 	}
+ 	
+ 	public void add(Object o){
+ 		add(size(),o);
+ 		return;
+ 	}
+ 	public void add(int index, Object o){
+ 		if( elementData.length== size() )
+ 			ensureCapacity ( size() *2 +1);
+ 		for ( int i = size; i > index; i--)
+ 			elementData[i] =elementData [i-1];
+ 		elementData[index]= o;
+ 		size ++;
+ 		
+ 	}
+ 	
+ 	public Object get(int index){
+ 		if ( index<0 || index >=size())
+ 			throw new ArrayIndexOutOfBoundsException();
+ 		return elementData[index];
+ 	}
+ 	
+ 	public Object remove(int index){
+ 		Object remove_elementData=elementData[index];
+ 		for ( int i=index;i<size()-1;i++)
+ 			elementData[i]= elementData[i+1];
+ 		size --;
+ 		return remove_elementData;
+ 	}
+ 	
+ 	public int size(){
+ 		return size;
+ 	}
+ 	
+ 	public java.util.Iterator iterator(){
+ 		return null;
+ 	}
+ 	
+ 	private class ArrayListIterator implements java.util.Iterator
+ 	{
+ 		private int current =0;
+ 		
+ 		public boolean hasNext()
+ 		{
+ 			return current <size();
+ 		}
+ 		
+ 		public Object next()
+ 		{
+ 			if (!hasNext())
+ 				throw new java.util.NoSuchElementException();
+ 			return elementData[current++];
+ 		}
+ 	}
+ 	
+ }
\ No newline at end of file
diff --git a/group17/51075907/HomeWork/src/day1_HomeWork/LinkedList.java b/group17/51075907/HomeWork/src/day1_HomeWork/LinkedList.java
new file mode 100644
index 0000000000..7a7c6d7b69
--- /dev/null
+++ b/group17/51075907/HomeWork/src/day1_HomeWork/LinkedList.java
@@ -0,0 +1,103 @@
+package day1_HomeWork;
+
+
+public class LinkedList implements List {
+	
+	private Node head;
+	
+	private int size = 0;
+	
+	private int modCount = 0;
+	
+	public void add(Object o){
+		add( size(),o);
+		return true;
+	}
+	public void add(int index , Object o){
+		
+	}
+	public Object get(int index){
+		Node p;
+		if ( index <0||index> size())
+			throw new IndexOutOfBoundsException();
+		
+		if (index < size()/2)
+		{
+			p=beginMarker.next;
+			for (int i =0;i<index;i++)
+				p=p.next;
+		}
+		else
+		{
+			p=endMarker;
+			for (int i=size();i>index;i--)
+				p=p.prev;
+		}
+		return p;
+	}
+	public Object remove(Node p){
+		p.next.prev =p.prev;
+		p.prev.next=p.next;
+		int size;
+		size--;
+		int modCount;
+		modCount++;
+		return p.data;
+	}
+	
+	public int size(){
+		return -1;
+	}
+	
+	public void addFirst(Node p,Object o){
+		Node newNode= new Node (o,p.prev,p);
+		newNode.prev.next= newNode;
+		p.prev =newNode;
+		size++;
+		modCount++;
+	}
+	public void addLast(Object o){
+		
+	}
+	public Object removeFirst(int index){
+		return remove( get(index));
+	}
+	public Object removeLast(){
+		return null;
+	}
+	public java.util.Iterator iterator(){
+		return new LinkedListIterator();
+	}
+	
+	private class LinkedListIterator implements java.util.Iterator{
+     private Node current=beginMarker.next;
+     private int expectedModCount=modCount;
+     private boolean okTORemove=false;
+     
+     public boolean haNext()
+     {
+    	 return current!= endMarker;
+     }
+     public Object next()
+     {
+    	 if (modCount !=expectedModCount)
+    		 throw new java.util.ConcurrentModificationException();
+    	 if (!=hasNext())
+    		 throw new java.util.NoSuchElementException();
+    	 
+    	 
+     }
+	}
+	
+	
+	private static  class Node{
+		public Node(Object o, Node p, Node n)
+		{
+			data =o; next=n; prev=p;
+		}
+		public Object data;
+		public Node next;
+		public Node prev;
+		
+	}
+}
diff --git a/group17/51075907/HomeWork/src/day1_HomeWork/List.java b/group17/51075907/HomeWork/src/day1_HomeWork/List.java
new file mode 100644
index 0000000000..4fce964dce
--- /dev/null
+++ b/group17/51075907/HomeWork/src/day1_HomeWork/List.java
@@ -0,0 +1,9 @@
+package day1_HomeWork;
+
+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/group17/51075907/HomeWork/src/day1_HomeWork/Queue.java b/group17/51075907/HomeWork/src/day1_HomeWork/Queue.java
new file mode 100644
index 0000000000..9a0468c683
--- /dev/null
+++ b/group17/51075907/HomeWork/src/day1_HomeWork/Queue.java
@@ -0,0 +1,19 @@
+package day1_HomeWork;
+
+public class Queue {
+	
+	public void enQueue(Object o){		
+	}
+	
+	public Object deQueue(){
+		return null;
+	}
+	
+	public boolean isEmpty(){
+		return false;
+	}
+	
+	public int size(){
+		return -1;
+	}
+}
diff --git a/group17/51075907/HomeWork/src/day1_HomeWork/Stack.java b/group17/51075907/HomeWork/src/day1_HomeWork/Stack.java
new file mode 100644
index 0000000000..259c5f0910
--- /dev/null
+++ b/group17/51075907/HomeWork/src/day1_HomeWork/Stack.java
@@ -0,0 +1,23 @@
+package day1_HomeWork;
+
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){		
+	}
+	
+	public Object pop(){
+		return null;
+	}
+	
+	public Object peek(){
+		return null;
+	}
+	public boolean isEmpty(){
+		return false;
+	}
+	public int size(){
+		return -1;
+	}
+}
diff --git a/group17/785396327/binarytree/BinaryTree.java b/group17/785396327/binarytree/BinaryTree.java
new file mode 100644
index 0000000000..bf5a6b639c
--- /dev/null
+++ b/group17/785396327/binarytree/BinaryTree.java
@@ -0,0 +1,55 @@
+package binarytree;
+
+/**
+ * Created by william on 2017/2/16.
+ */
+public class BinaryTree {
+    private Node root;
+
+    class Node {
+        private Node left;
+        private Node right;
+        private Comparable data;
+
+        public Node(Node left, Node right, Comparable data) {
+            this.left = left;
+            this.right = right;
+            this.data = data;
+        }
+
+        private void add(Comparable data) {
+            if (this.data.compareTo(data) >= 0)
+                if (this.left == null)
+                    this.left = new Node(null, null, data);
+                else
+                    left.add(data);
+            else if (this.data.compareTo(data) < 0)
+                if (this.right == null)
+                    this.right = new Node(null, null, data);
+                else
+                    this.right.add(data);
+        }
+
+        public Comparable getData() {
+            return this.data;
+        }
+
+        public Node getLeft() {
+            return this.left;
+        }
+
+        public Node getRight() {
+            return this.right;
+        }
+    }
+
+    public void add(Comparable data) {
+        if (this.root == null)
+            root = new Node(null, null, data);
+        else this.root.add(data);
+    }
+
+    public void printByType(SearchType<Node> type) {
+        type.printByType(this.root);
+    }
+}
diff --git a/group17/785396327/binarytree/DLRSearchType.java b/group17/785396327/binarytree/DLRSearchType.java
new file mode 100644
index 0000000000..3d1adbbdc7
--- /dev/null
+++ b/group17/785396327/binarytree/DLRSearchType.java
@@ -0,0 +1,16 @@
+package binarytree;
+
+/**
+ * Created by william on 2017/2/18.
+ */
+public class DLRSearchType implements SearchType<BinaryTree.Node> {
+
+    @Override
+    public void printByType(BinaryTree.Node root) {
+        if (root != null) {
+            System.out.print(root.getData()+" ");
+            printByType(root.getLeft());
+            printByType(root.getRight());
+        }
+    }
+}
diff --git a/group17/785396327/binarytree/LDRSearchType.java b/group17/785396327/binarytree/LDRSearchType.java
new file mode 100644
index 0000000000..da18dbc1b9
--- /dev/null
+++ b/group17/785396327/binarytree/LDRSearchType.java
@@ -0,0 +1,15 @@
+package binarytree;
+
+/**
+ * Created by william on 2017/2/18.
+ */
+public class LDRSearchType implements SearchType<BinaryTree.Node> {
+    @Override
+    public void printByType(BinaryTree.Node root) {
+        if (root != null) {
+            printByType(root.getLeft());
+            System.out.print(root.getData() + " ");
+            printByType(root.getRight());
+        }
+    }
+}
diff --git a/group17/785396327/binarytree/LFSearchType.java b/group17/785396327/binarytree/LFSearchType.java
new file mode 100644
index 0000000000..d983c50ff9
--- /dev/null
+++ b/group17/785396327/binarytree/LFSearchType.java
@@ -0,0 +1,27 @@
+package binarytree;
+
+import java.util.LinkedList;
+
+/**
+ * Created by william on 2017/2/18.
+ */
+public class LFSearchType implements SearchType<BinaryTree.Node> {
+    private LinkedList<BinaryTree.Node> queue = new LinkedList<>();
+
+    @Override
+    public void printByType(BinaryTree.Node root) {
+        if (root == null)
+            return;
+        queue.offer(root);
+        while (!queue.isEmpty()) {
+            BinaryTree.Node curNode = queue.poll();
+            System.out.print(curNode.getData() + " ");
+            if (curNode.getLeft() != null)
+                queue.offer(curNode.getLeft());
+            if (curNode.getRight() != null)
+                queue.offer(curNode.getRight());
+        }
+
+    }
+
+}
diff --git a/group17/785396327/binarytree/LRDSearchType.java b/group17/785396327/binarytree/LRDSearchType.java
new file mode 100644
index 0000000000..250645e6df
--- /dev/null
+++ b/group17/785396327/binarytree/LRDSearchType.java
@@ -0,0 +1,15 @@
+package binarytree;
+
+/**
+ * Created by william on 2017/2/18.
+ */
+public class LRDSearchType implements SearchType<BinaryTree.Node> {
+    @Override
+    public void printByType(BinaryTree.Node root) {
+        if (root != null) {
+            printByType(root.getLeft());
+            printByType(root.getRight());
+            System.out.print(root.getData() + " ");
+        }
+    }
+}
diff --git a/group17/785396327/binarytree/SearchType.java b/group17/785396327/binarytree/SearchType.java
new file mode 100644
index 0000000000..606124a781
--- /dev/null
+++ b/group17/785396327/binarytree/SearchType.java
@@ -0,0 +1,9 @@
+package binarytree;
+
+/**
+ * Created by william on 2017/2/18.
+ */
+public interface SearchType<T> {
+
+    void printByType(T root);
+}
diff --git a/group17/785396327/list/ArrayList.java b/group17/785396327/list/ArrayList.java
new file mode 100644
index 0000000000..9d79bd2013
--- /dev/null
+++ b/group17/785396327/list/ArrayList.java
@@ -0,0 +1,135 @@
+package list;
+
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+/**
+ * Created by william on 2017/2/25.
+ */
+public class ArrayList<T> implements List<T> {
+    private static final int DEFAULT_CAPACITY = 10;
+    private int size;
+    private Object[] elementData;
+
+    public ArrayList() {
+        elementData = new Object[DEFAULT_CAPACITY];
+    }
+
+    public ArrayList(int initialCapacity) {
+        if (initialCapacity < 0)
+            throw new RuntimeException("非法初始化大小参数!");
+        elementData = new Object[initialCapacity];
+    }
+
+    public boolean add(T ele) {
+        grow();
+        elementData[size] = ele;
+        size++;
+        return true;
+    }
+
+    public T get(int index) {
+        checkBounds(index);
+        return (T) elementData[index];
+    }
+
+    public T remove(int index) {
+        checkBounds(index);
+        T removeEle = (T) elementData[index];
+        System.arraycopy(elementData, index + 1, elementData, index, size - index);
+        size--;
+        return removeEle;
+    }
+
+    public boolean add(int index, T ele) {
+        checkBounds(index);
+        size++;//有效元素内容先加，保证长度极限情况grow在添加前生效
+        grow();
+        //将原本数组从待插入的index截取，将原本index后的有效值，复制到原本数组index+1之后
+        System.arraycopy(elementData, index, elementData, index + 1, size - index);
+        elementData[index] = ele;
+        return true;
+    }
+
+    @Override
+    public boolean remove(T ele) {
+        int index;
+        if ((index = indexOf(ele)) == -1)
+            return false;
+        remove(index);
+        return true;
+    }
+
+    private void checkBounds(int index) {
+        if (index < 0 || index >= size)
+            throw new IndexOutOfBoundsException("index : " + index + ", size : [ 0 - " + size + " ]");
+    }
+
+    public int size() {
+        return size;
+    }
+
+    private void grow() {
+        if (size >= elementData.length) {
+            int curLen = elementData.length;
+            int newLen = curLen + (curLen >> 1) > Integer.MAX_VALUE ? Integer.MAX_VALUE : curLen + (curLen >> 1);
+            elementData = Arrays.copyOf(elementData, newLen);
+        }
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    public boolean contains(T ele) {
+        return indexOf(ele) != -1;
+    }
+
+    public int indexOf(T ele) {
+        for (int i = 0; i < size; i++) {
+            if (ele == null)
+                if (null == elementData[i])
+                    return i;
+                else if (ele.equals(elementData[i]))
+                    return i;
+        }
+        return -1;
+    }
+
+    public Iterator<T> iterator() {
+        return new Itr<T>();
+    }
+
+    private class Itr<T> implements Iterator<T> {
+        int cursor;//待遍历元素的下标
+
+        @Override
+        public boolean hasNext() {
+            return cursor != size;
+        }
+
+        @Override
+        public T next() {
+            if (cursor >= size)
+                throw new NoSuchElementException();
+            return (T) elementData[cursor++];
+        }
+
+        @Override
+        public void remove() {
+            if (cursor >= size)
+                throw new NoSuchElementException();
+            ArrayList.this.remove(cursor--);
+        }
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("[ ");
+        for (Object ele : elementData) {
+            sb.append(ele).append(" ");
+        }
+        return sb.append("]").toString();
+    }
+}
diff --git a/group17/785396327/list/Iterator.java b/group17/785396327/list/Iterator.java
new file mode 100644
index 0000000000..0df87c6cf1
--- /dev/null
+++ b/group17/785396327/list/Iterator.java
@@ -0,0 +1,13 @@
+package list;
+
+/**
+ * Created by IBM on 2017/2/25.
+ */
+public interface Iterator<T> {
+
+    boolean hasNext();
+
+    T next();
+
+    void remove();
+}
diff --git a/group17/785396327/list/LinkedList.java b/group17/785396327/list/LinkedList.java
new file mode 100644
index 0000000000..1b1fa0fccb
--- /dev/null
+++ b/group17/785396327/list/LinkedList.java
@@ -0,0 +1,163 @@
+package list;
+
+/**
+ * Created by william on 2017/2/25.
+ */
+public class LinkedList<T> implements List<T> {
+    private int size;
+    private Node<T> first;
+    private Node<T> last;
+
+    private static class Node<T> {
+        Node next;
+        Node prev;
+        T data;
+
+        Node(Node<T> prev, Node next, T data) {
+            this.prev = prev;
+            this.next = next;
+            this.data = data;
+        }
+    }
+
+    @Override
+    public int size() {
+        return this.size;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    public boolean contains(T ele) {
+        Node head = first;
+        while (head != null) {
+            if ((ele == null && head.data == null) || (ele.equals(head.data)))
+                return true;
+            head = head.next;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean add(T ele) {
+        if (first == null)
+            first = last = new Node<T>(null, null, ele);
+        else {
+            //新添加节点的上一个节点是原来链表的最后一个节点
+            Node addNode = new Node(last, null, ele);
+            //原来链表的最后一个节点的下一个节点需要指向新添加的节点
+            last.next = addNode;
+            //更新最后一个节点为新添加的节点
+            last = addNode;
+        }
+        size++;
+        return true;
+    }
+
+    @Override
+    public boolean add(int index, T ele) {
+        checkBounds(index, true);
+        if (index == size) add(ele);
+        else {
+            Node head = first;
+            for (int i = 0; i < size; i++) {
+                if (i == index - 1)//得到要插入位置的前一个节点
+                    head.next = new Node(head, head.next, ele);
+                else
+                    head = head.next;
+            }
+        }
+        size++;
+        return true;
+    }
+
+    @Override
+    public boolean remove(T ele) {
+        if (!contains(ele))
+            return false;
+        Node head = first;
+        Node prev = head.prev;
+        while (head != null) {
+            if ((ele == null && ele == head.data) || ele.equals(head.data)) {
+                prev.next = head.next;
+                size--;
+                return true;
+            }
+            prev = head;
+            head = head.next;
+        }
+        return false;
+    }
+
+    @Override
+    public T remove(int index) {
+        checkBounds(index, false);
+        T removeEle = get(index);
+        remove(removeEle);
+        return removeEle;
+    }
+
+    @Override
+    public T get(int index) {
+        checkBounds(index, false);
+        if (index > (size >> 1)) {
+            //索引位置大于1/2size，从后往前
+            Node tail = last;
+            for (int i = size - 1; i >= 0; i--) {
+                if (i == index)
+                    return (T) tail.data;
+                else
+                    tail = tail.prev;
+            }
+        } else {
+            //从前往后
+            Node head = first;
+            for (int i = 0; i < size; i++) {
+                if (i == index)
+                    return (T) head.data;
+                else
+                    head = head.next;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public int indexOf(T ele) {
+        if (first == null) return -1;
+        Node head = first;
+        for (int i = 0; i < size; i++) {
+            if ((ele == null && ele == head.data) || ele.equals(head.data))
+                return i;
+            head = head.next;
+        }
+        return -1;
+    }
+
+    /**
+     * 指定位置查找元素和插入元素到指定位置IndexOutofBounds的判断标准不一样
+     *
+     * @param index
+     * @param isInsert
+     */
+    private void checkBounds(int index, boolean isInsert) {
+        if (isInsert && (index < 0 || index > size))//允许插入到最后一个元素之后，不能排除=
+            throw new IndexOutOfBoundsException("index : " + index + ", size : [ 0 - " + size + " ]");
+        if (index < 0 || index >= size)//查询从0 --- size-1
+            throw new IndexOutOfBoundsException("index : " + index + ", size : [ 0 - " + size + " ]");
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("[ ");
+        Node head = first;
+        while (head != null) {
+            sb.append(head.data + " ");
+            head = head.next;
+        }
+        return sb.append("]").toString();
+    }
+}
diff --git a/group17/785396327/list/List.java b/group17/785396327/list/List.java
new file mode 100644
index 0000000000..706f9f29bb
--- /dev/null
+++ b/group17/785396327/list/List.java
@@ -0,0 +1,25 @@
+package list;
+
+/**
+ * Created by william on 2017/2/25.
+ */
+public interface List<T> {
+
+    int size();
+
+    boolean isEmpty();
+
+    boolean contains(T ele);
+
+    boolean add(T ele);
+
+    boolean add(int index, T ele);
+
+    boolean remove(T ele);
+
+    T remove(int index);
+
+    T get(int index);
+
+    int indexOf(T ele);
+}
diff --git a/group17/785396327/queue/Queue.java b/group17/785396327/queue/Queue.java
new file mode 100644
index 0000000000..68bea83b77
--- /dev/null
+++ b/group17/785396327/queue/Queue.java
@@ -0,0 +1,41 @@
+package queue;
+
+import java.util.NoSuchElementException;
+
+/**
+ * Created by william on 2017/2/25.
+ */
+public class Queue<T> extends LinkedList<T> {
+
+    public boolean add(T ele) {
+        return add(ele);
+    }
+
+    public T element() {
+        if (size() == 0)
+            throw new NoSuchElementException("队列中没有元素！");
+        return get(0);
+    }
+
+    public boolean offer(T ele) {
+        return add(ele);
+    }
+
+    public T peek() {
+        if (size() == 0)
+            return null;
+        return get(0);
+    }
+
+    public T poll() {
+        if (size() == 0)
+            return null;
+        return remove(0);
+    }
+
+    public T remove() {
+        if (size() == 0)
+            throw new NoSuchElementException("队列中没有元素！");
+        return remove(0);
+    }
+}
diff --git a/group17/785396327/stack/Stack.java b/group17/785396327/stack/Stack.java
new file mode 100644
index 0000000000..c917809cc3
--- /dev/null
+++ b/group17/785396327/stack/Stack.java
@@ -0,0 +1,29 @@
+package stack;
+
+import java.util.EmptyStackException;
+
+/**
+ * Created by william on 2017/2/25.
+ */
+public class Stack<T> extends ArrayList {
+
+    public boolean empty() {
+        return isEmpty();
+    }
+
+    public T peek() {
+        if (size() == 0)
+            throw new EmptyStackException();
+        return (T) get(0);
+    }
+
+    public T pop() {
+        if (size() == 0)
+            throw new EmptyStackException();
+        return (T) remove(0);
+    }
+
+    public void push(T ele) {
+        add(0, ele);
+    }
+}
diff --git a/group17/82427129/.gitignore b/group17/82427129/.gitignore
new file mode 100644
index 0000000000..e0db6fed9c
--- /dev/null
+++ b/group17/82427129/.gitignore
@@ -0,0 +1,7 @@
+/.metadata/
+/RemoteSystemsTempFiles/
+
+/JavaUtil/.settings/
+
+.classpath
+.project
diff --git a/group17/82427129/JavaUtil/.gitignore b/group17/82427129/JavaUtil/.gitignore
new file mode 100644
index 0000000000..b83d22266a
--- /dev/null
+++ b/group17/82427129/JavaUtil/.gitignore
@@ -0,0 +1 @@
+/target/
diff --git a/group17/82427129/JavaUtil/pom.xml b/group17/82427129/JavaUtil/pom.xml
new file mode 100644
index 0000000000..974fb14110
--- /dev/null
+++ b/group17/82427129/JavaUtil/pom.xml
@@ -0,0 +1,27 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>com.coding.basic</groupId>
+	<artifactId>JavaUtil</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<configuration>
+					<source>1.7</source>
+					<target>1.7</target>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+	<dependencies>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.7</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+</project>
\ No newline at end of file
diff --git a/group17/82427129/JavaUtil/src/main/java/com/coding/basic/ArrayList.java b/group17/82427129/JavaUtil/src/main/java/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..07f92770c9
--- /dev/null
+++ b/group17/82427129/JavaUtil/src/main/java/com/coding/basic/ArrayList.java
@@ -0,0 +1,100 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	
+	private Object[] elementData;
+	
+	private static Object[] EMPTY_ELEMENTDATA = {};
+	
+	private static int INITIALCAPACITY = 10;
+	
+	public ArrayList(){
+		elementData = EMPTY_ELEMENTDATA;
+	}
+	
+	public ArrayList(int initialCapacity){
+		elementData = new Object[INITIALCAPACITY];
+	}
+	
+	public void add(Object o){
+		ensureCapacity(size+1);
+		elementData[size++] = o;
+	}
+	
+	public void add(int index, Object o){
+		rangeCheckForAdd(index);
+		
+		ensureCapacity(size+1);
+		System.arraycopy(elementData, index, elementData, index+1, size-index);
+		elementData[index] = o;
+		size++;
+	}
+	
+	public Object set(int index, Object o){
+		rangeCheck(index);
+		
+		Object oldValue = elementData[index];
+		elementData[index] = o;
+		return oldValue;
+	}
+	
+	public Object get(int index){
+		rangeCheck(index);
+		return elementData[index];
+	}
+	
+	public Object remove(int index){
+		rangeCheck(index);
+		Object oldValue = elementData[index];
+		int movedLength = size - index - 1;
+		if(movedLength > 0)//��Ҫɾ�����һ��Ԫ��ʱ������Ҫ�ƶ����飬ֻ��Ҫ�����һ��Ԫ����null
+			System.arraycopy(elementData, index+1, elementData, index, size-index-1);
+		elementData[--size] = null;
+		return oldValue;
+	}
+	
+	private void rangeCheckForAdd(int index){
+		if( index > size || index<0 ){
+			throw new IndexOutOfBoundsException(outofIndex(index));
+		}
+	}
+	private void rangeCheck(int index){
+		if( index >= size || index < 0){
+			throw new IndexOutOfBoundsException(outofIndex(index));
+		}
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+	
+	private void ensureCapacity(int minCapacity){
+		if(elementData == EMPTY_ELEMENTDATA){
+			minCapacity = Math.max(minCapacity, INITIALCAPACITY);//���addall�״����ӵ������ͱ�INITIALCAPACITY��
+		}
+		if(minCapacity - elementData.length > 0){
+			grow(minCapacity);
+		}
+	}
+	
+	private void grow(int minCapcity){
+		int oldCapacity = elementData.length;
+		int newCapcity = oldCapacity + (oldCapacity>>1);
+		if(newCapcity - minCapcity < 0){
+			newCapcity = minCapcity;
+		}
+		elementData = Arrays.copyOf(elementData, newCapcity);
+	}
+	
+	private String outofIndex(int index){
+		return "Index: "+index+", Size: "+size;
+	}
+}
diff --git a/group17/82427129/JavaUtil/src/main/java/com/coding/basic/BinaryTreeNode.java b/group17/82427129/JavaUtil/src/main/java/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..d7ac820192
--- /dev/null
+++ b/group17/82427129/JavaUtil/src/main/java/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,32 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git a/group17/82427129/JavaUtil/src/main/java/com/coding/basic/Iterator.java b/group17/82427129/JavaUtil/src/main/java/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..06ef6311b2
--- /dev/null
+++ b/group17/82427129/JavaUtil/src/main/java/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/group17/82427129/JavaUtil/src/main/java/com/coding/basic/LinkedList.java b/group17/82427129/JavaUtil/src/main/java/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..601c803f74
--- /dev/null
+++ b/group17/82427129/JavaUtil/src/main/java/com/coding/basic/LinkedList.java
@@ -0,0 +1,180 @@
+package com.coding.basic;
+
+import java.util.NoSuchElementException;
+
+public class LinkedList implements List {
+	private int size = 0;
+	
+	private Node first;
+	
+	private Node last;
+	
+	public void add(Object o){
+		add(size,o);
+	}
+	public void add(int index , Object o){
+		rangeCheck(index);
+		
+		if(index == size){
+			linkLast(o);
+		}else{
+			linkBefore(o, indexOf(index));
+		}
+	}
+	private void linkBefore(Object o ,Node succ){
+		final Node prev = succ.prev;
+		final Node newNode = new Node(prev, o, succ);
+		succ.prev = newNode;
+		if(prev == null){
+			first = newNode;
+		}else{
+			prev.next = newNode;
+		}
+		size++;
+	}
+	private void linkLast(Object o){
+		final Node succ = last;
+		final Node newNode = new Node(succ, o, null);
+		last = newNode;
+		if(succ == null){
+			first = newNode;
+		}else{
+			succ.next = newNode;
+		}
+		size++;
+	}
+	private void rangeCheck(int index) {
+		if(index > size|| index < 0 )
+			throw new IndexOutOfBoundsException("Size"+size+":index"+index);
+	}
+	private void elementIndexCheck(int index){
+		if(index >=size||index < 0)
+			throw new IndexOutOfBoundsException("Size"+size+":index"+index);
+	}
+	/**
+	 * ��ȡ���±ꡱΪindex��ֵ,
+	 * indexΪsizeʱ����null
+	 * @param index
+	 * @return
+	 */
+	private Node indexOf(int index){
+		if(index < (this.size>>1) ){
+			Node x = first;
+			for (int i = 0; i < index; i++) {
+				x = x.next;
+			}
+			return x;
+		}else{
+			Node x = last;
+			for (int i = this.size-1; i > index; i--) {
+				x = x.prev;
+			}
+			return x;
+		}
+	}
+
+	public Object get(int index){
+		elementIndexCheck(index);
+		
+		return indexOf(index);
+	}
+	public Object remove(int index){
+		elementIndexCheck(index);
+		
+		if(index == 0){
+			return removeFirst();
+		}else if(index == size) {
+			return removeLast();
+		}else{
+			return unlinkNode(indexOf(index));
+		}
+	}
+	
+	private Object unlinkNode(Node node) {
+		final Node next = node.next;
+		final Node prev = node.prev;
+		final Object element = node.data;
+		if(next == null){
+			last = node;
+		}else{
+			next.prev = node;
+			node.next = next;
+		}
+		if(prev == null){
+			first = node;
+		}else{
+			prev.next = node;
+			node.prev = prev;
+		}
+		size--;
+		node.data = null;
+		
+		return element;
+	}
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		linkBefore(o, first);
+	}
+	
+	public void addLast(Object o){
+		linkLast(o);
+	}
+	
+	public Object removeFirst(){
+		if(first == null)
+			throw new NoSuchElementException("first is null");
+		
+		Object oldData = first.data;
+		final Node next = first.next;
+		first.data = null;
+		first.next = null;//GC
+		first = next;
+		
+		if(next == null){
+			last = null;
+		}else{
+			next.prev = null;
+		}
+		size--;
+		
+		return oldData;
+	}
+	
+	public Object removeLast(){
+		if(last == null)
+			throw new NoSuchElementException("last is null");
+		
+		Object oldData = last.data;
+		final Node prev = last.prev;
+		last.prev = null;
+		last.data = null;//GC
+		last = prev;
+		
+		if(prev == null){
+			first = null;
+		}else{
+			prev.next = null;
+		}
+		size--;
+		
+		return oldData;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+	
+	private static class Node{
+		Object data;
+		Node next;
+		Node prev;
+		Node(Node prev,Object data,Node next){
+			this.data = data;
+			this.next = next;
+			this.prev = prev;
+		}
+	}
+}
\ No newline at end of file
diff --git a/group17/82427129/JavaUtil/src/main/java/com/coding/basic/List.java b/group17/82427129/JavaUtil/src/main/java/com/coding/basic/List.java
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ b/group17/82427129/JavaUtil/src/main/java/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/group17/82427129/JavaUtil/src/main/java/com/coding/basic/Queue.java b/group17/82427129/JavaUtil/src/main/java/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..ffed2d52c4
--- /dev/null
+++ b/group17/82427129/JavaUtil/src/main/java/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.addLast(o);
+	}
+	
+	public Object deQueue(){
+		return elementData.removeLast();
+	}
+	
+	public boolean isEmpty(){
+		return size() == 0;
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group17/82427129/JavaUtil/src/main/java/com/coding/basic/Stack.java b/group17/82427129/JavaUtil/src/main/java/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..2d47d3eaea
--- /dev/null
+++ b/group17/82427129/JavaUtil/src/main/java/com/coding/basic/Stack.java
@@ -0,0 +1,32 @@
+package com.coding.basic;
+
+import java.util.EmptyStackException;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){
+		elementData.add(o);
+	}
+	
+	public Object pop(){
+		int length = size();
+		Object lastData = peek();
+		elementData.remove(length - 1);
+		
+		return lastData;
+	}
+	
+	public Object peek(){
+		if(size()<=0)
+			throw new EmptyStackException();
+		
+		return elementData.get(size()-1);
+	}
+	public boolean isEmpty(){
+		return size() == 0;
+	}
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group17/876385982/.classpath b/group17/876385982/.classpath
new file mode 100644
index 0000000000..fb5011632c
--- /dev/null
+++ b/group17/876385982/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group17/876385982/.gitignore b/group17/876385982/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group17/876385982/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group17/876385982/.project b/group17/876385982/.project
new file mode 100644
index 0000000000..4062c6c28f
--- /dev/null
+++ b/group17/876385982/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>876385982</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group17/876385982/src/test/Test.java b/group17/876385982/src/test/Test.java
new file mode 100644
index 0000000000..b023a3ea07
--- /dev/null
+++ b/group17/876385982/src/test/Test.java
@@ -0,0 +1,10 @@
+package test;
+
+public class Test {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		System.out.println("Test!");
+	}
+
+}
diff --git "a/group17/article/\345\206\231\344\270\200\347\257\207\346\226\207\347\253\240\344\273\213\347\273\215cpu, \345\206\205\345\255\230, \347\243\201\347\233\230, \346\214\207\344\273\244\344\273\245\345\217\212\344\273\226\344\273\254\344\271\213\351\227\264\347\232\204\345\205\263\347\263\273_20170226.md" "b/group17/article/\345\206\231\344\270\200\347\257\207\346\226\207\347\253\240\344\273\213\347\273\215cpu, \345\206\205\345\255\230, \347\243\201\347\233\230, \346\214\207\344\273\244\344\273\245\345\217\212\344\273\226\344\273\254\344\271\213\351\227\264\347\232\204\345\205\263\347\263\273_20170226.md"
new file mode 100644
index 0000000000..0cec6481d5
--- /dev/null
+++ "b/group17/article/\345\206\231\344\270\200\347\257\207\346\226\207\347\253\240\344\273\213\347\273\215cpu, \345\206\205\345\255\230, \347\243\201\347\233\230, \346\214\207\344\273\244\344\273\245\345\217\212\344\273\226\344\273\254\344\271\213\351\227\264\347\232\204\345\205\263\347\263\273_20170226.md"	
@@ -0,0 +1,56 @@
+# 写一篇文章介绍cpu, 内存, 磁盘, 指令以及他们之间的关系
+
+## 须知
+---
+
+交作业时请在QQ 号后面填上各自的文章链接, 比如:
+
+51075907 http://m.blog.csdn.net/article/details?id=57083764
+
+## 文章
+---
+
+1204187480
+
+102228177  http://note.youdao.com/noteshare?id=74a51e7f93461dfb77c69a1cf4755624&sub=004F10FA5D2046ABAA060F19C0D2A18F
+
+876385982 http://www.totoro-fly.com/?p=59
+
+785396327
+
+1059107701
+
+240094626
+
+82427129 http://blog.csdn.net/walk_er/article/details/57406278
+
+296910598
+
+1264835468
+
+516886559
+
+1282579502
+
+614982500
+
+865797761
+
+1540186032  http://blog.csdn.net/mpx_xb/article/details/56679603
+
+176653813
+
+116665530
+
+51075907 http://m.blog.csdn.net/article/details?id=57083764
+
+1158154002
+
+345450234
+
+919764878
+
+1368331120
+
+517970312
+
diff --git a/group18/1078285863/javaStudy/src/basicStruct/BasicStruct.java b/group18/1078285863/javaStudy/src/basicStruct/BasicStruct.java
new file mode 100644
index 0000000000..1461dedf79
--- /dev/null
+++ b/group18/1078285863/javaStudy/src/basicStruct/BasicStruct.java
@@ -0,0 +1,11 @@
+package basicStruct;
+//
+
+public class BasicStruct {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}
diff --git a/group18/1078285863/javaStudy/src/simpleArrayList/SimpleArrayList.java b/group18/1078285863/javaStudy/src/simpleArrayList/SimpleArrayList.java
new file mode 100644
index 0000000000..689fdccaf5
--- /dev/null
+++ b/group18/1078285863/javaStudy/src/simpleArrayList/SimpleArrayList.java
@@ -0,0 +1,140 @@
+package simpleArrayList;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class SimpleArrayList {
+	//�洢array������
+	private Object[] elementData;
+	
+	//Ĭ������
+	public static final int default_capacity = 10;
+	
+	//array��Ԫ�صĸ���
+	private int size;
+	
+	//Ĭ�Ϲ��캯��
+	public SimpleArrayList(){
+		//�����СĬ��Ϊ10������
+		this.elementData = new Object[default_capacity];
+	}
+	
+	//���ι��캯��,�Լ�ָ��������С
+	public SimpleArrayList(int initialCapacity) {
+		if(initialCapacity <= 0){
+			//������Ч
+			throw new IllegalArgumentException("IllegalArgument Error");
+		}
+		if(initialCapacity < default_capacity)
+		{
+			initialCapacity = default_capacity;
+		}
+		
+		this.elementData = new Object[initialCapacity];
+	}
+	
+	//������������Ԫ��
+	public boolean Add(int index,Object o)
+	{
+		if(index > size || index <0)
+		{
+			return false;
+		}
+		
+		//����Ԫ��
+		for (int i = 0; i < size; i++) {
+			if(o.equals(elementData[i]))
+			{
+				//�ƶ�Ԫ�صĸ���
+				int nMove = size -index -1;
+				if(nMove > 0){
+					System.arraycopy(elementData, index, elementData, index+1,nMove);
+					elementData[index] = null;
+				}
+				else {
+					return false;
+				}
+			}
+		}
+		
+		return true;
+	}
+	
+	//����Ԫ��
+	//����ֵ:�Ƿ����ӳɹ�
+	public boolean Add(Object obj)
+	{
+		if (null == obj) {
+			throw new IllegalArgumentException("invalid Argument!");
+		}
+		//��array����
+		ensureCapacityInternal(size + 1);
+		
+		//����β��Ԫ�� = ��ֵ
+		elementData[size++] = obj;
+		
+		return true;
+	}
+	
+	public void clear()
+	{
+		//��elementData��Ԫ��ָ��NULL,��ʹ�������ջ�������
+		for (int i = 0; i < elementData.length; i++) {
+			elementData[i] = null;
+		}
+		
+		//arrayԪ�ظ�������
+		size = 0;
+	}
+	
+	//�Ƴ�array�е�Ԫ��
+	public boolean remove(Object obj)
+	{
+		//����elementData,����Ԫ��
+		for (int index = 0; index < size; index++) {
+			if(obj.equals(elementData[index]))//�Ƿ����
+			{
+				 fastRemove(index);
+                 return true;
+			}
+		}
+		return false;
+	}
+	
+	private void fastRemove(int index) {
+		//�ƶ�Ԫ�صĸ���
+        int numMoved = size - index - 1;
+        if (numMoved > 0)
+        	//��index�������Դ���ǰ�ƶ�
+            System.arraycopy(elementData, index+1, elementData, index,numMoved);
+        elementData[--size] = null;
+    }
+	
+	//����Ԫ���ܴ�С
+	 public int size() {
+	        return size;
+	 }
+	 
+	 public Object get(int index) {
+		    //У�����
+	        if(index > size || index < 0)
+	        	throw new IllegalArgumentException();
+
+	        return elementData[index];
+	    }
+	
+	//�漰��������ݿռ�����,��ʱ�Ȳ�����
+	private void ensureCapacityInternal(int minCapacity) {
+		//�������,��ǰ���������޷�����������ʱ,�Ƿ񳬹��˵�ǰ����ĳ���
+		System.out.println("element data length is "+elementData.length);
+       if(minCapacity - elementData.length > 0)
+       {
+    	   //����Ϊ��ǰ������1.5��
+    	   int oldCapacity = elementData.length;
+    	   int newCapacity = oldCapacity *3/2;
+    	   
+    	   //�ڲ�����������,��elementData��Ԫ�ؿ�����������
+    	   elementData = Arrays.copyOf(elementData, newCapacity);
+       }
+    }
+}
diff --git a/group18/1078285863/javaStudy/src/simpleLinkedList/SimpleLinkedList.java b/group18/1078285863/javaStudy/src/simpleLinkedList/SimpleLinkedList.java
new file mode 100644
index 0000000000..0f11532723
--- /dev/null
+++ b/group18/1078285863/javaStudy/src/simpleLinkedList/SimpleLinkedList.java
@@ -0,0 +1,197 @@
+package simpleLinkedList;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+
+import javax.sound.sampled.Line;
+
+public class SimpleLinkedList {
+	//LinkedList<E>
+	private int size = 0;
+	private Node head = null;
+	private Node tail = null;
+	
+	private static  class Node{
+		Object data;
+		Node next;//ָ���һ��Ԫ��
+		Node prev; //ָ��ǰһ��Ԫ��
+	}
+	
+	public void add(Object o){
+		addLast(o);
+	}
+	public void add(int index , Object o){
+		//���ҵ�indexλ�õ�Ԫ��
+		Node tmp = null;
+		for (int i = 0; i < index; i++) {
+			tmp = tmp.next;
+		}
+		
+		Node pre = tmp.prev;
+		Node next = tmp.next;
+		
+		if (null == pre) {
+			addFirst(o);	//����ͷ��
+		}
+		else if(null == next){
+			addLast(o);	//����β��
+		}
+		else {
+			add(o);
+		}
+	}
+	public Object get(int index){
+		if (index > size || index <0) {
+			throw new IllegalArgumentException();
+		}
+		
+		Node temp = null;
+		for(int i=0;i<index;i++){
+			temp = temp.next;
+		}
+		
+		return temp.data;
+	}
+	
+	public Object remove(Node delNode){
+		Object element = delNode.data;
+		//����ǰ��Ԫ�غͺ���Ԫ��
+		Node prev = delNode.prev;
+		Node next = delNode.next;
+		
+		if(null == head || null == tail){
+			return null;
+		}
+		
+		//ɾ�����ǵ�һ��Ԫ��
+		if(null == prev){
+			head = next;
+		}
+		else if (null == next) {
+			tail = prev;
+		}
+		else {
+			prev.next = next;
+			next.prev = prev;
+		}
+		
+		//ɾ���ڵ�Ԫ��
+		delNode.prev = null;
+		delNode.next = null;
+		delNode.data = null;
+		
+		return element;
+	}
+	
+	public Object remove(int index){
+		//��λ��Ԫ��
+		Node temp = null;
+		for(int i=0;i<index;i++){
+			temp = temp.next;
+		}
+		
+		return null;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		//��¼ԭͷ���ڵ�
+		final Node tmpHead = head;
+		
+		//�����½ڵ㲢��ֵ
+		Node newNode = new Node();
+		if (null == newNode) {
+			throw new OutOfMemoryError();
+		}
+		newNode.data = o;
+		newNode.next = null;
+		newNode.prev = null;
+		
+		if (null == head) {
+			head = tail = newNode;
+		}
+		else {
+			newNode.next = tmpHead;
+			tmpHead.prev = newNode;
+			//����ͷ��Ԫ��ָ��
+			head = newNode;
+		}
+	}
+	public void addLast(Object o){
+		//��¼ԭβ��Ԫ��
+		final Node tmpTail = tail;
+		
+		//�����½ڵ㲢��ֵ
+		Node newNode = new Node();
+		if (null == newNode) {
+			throw new OutOfMemoryError();
+		}
+		newNode.data = o;
+		newNode.next = null;
+		
+		//���ǵ�һ�β���
+		if(null == tail){
+			head = newNode;
+			tail = newNode;
+		}
+		else {
+			tail.next = newNode;
+			newNode.prev = tmpTail;
+			tail = newNode;
+		}
+		
+		//ͳ��Ԫ�ظ���
+		size++;
+	}
+	public Object removeFirst(){
+		//����ͷ���ڵ�
+		Object element = head.data;
+		Node nextNode = head.next;
+		
+		//�ͷ�ͷ���
+		head.data = null;
+		head.next = null;
+		
+		//ֻ��һ��Ԫ��
+		if (head == tail) {
+			head = tail = null;
+		}
+		else {
+			head = nextNode;
+			nextNode.prev = null;
+		}
+		
+		//����Ԫ������
+		size--;
+		
+		return element;
+	}
+	public Object removeLast(){
+		//��¼β��Ԫ��
+		Object element = tail.data;
+		Node prev = tail.prev;
+		
+		//�ͷ�β���׶�
+		tail.next = null;
+		tail.data = null;
+		
+		//������β��
+		tail = prev;
+		
+		if (head == tail) {
+			head = null;
+			tail = null;
+		}
+		else {
+			prev.next = null;
+		}
+		size--;
+		return element;
+	}
+	public Iterator iterator(){
+		return null;
+	}
+}
\ No newline at end of file
diff --git a/group18/1078285863/javaStudy/src/simpleQueue/SimpleQueue.java b/group18/1078285863/javaStudy/src/simpleQueue/SimpleQueue.java
new file mode 100644
index 0000000000..562917b211
--- /dev/null
+++ b/group18/1078285863/javaStudy/src/simpleQueue/SimpleQueue.java
@@ -0,0 +1,22 @@
+package simpleQueue;
+
+import java.util.LinkedList;;
+
+public class SimpleQueue {
+	LinkedList<Object> queueList = new LinkedList();
+	public void enQueue(Object o){	
+		queueList.add(o);
+	}
+	
+	public Object deQueue(){
+		return queueList.removeFirst();
+	}
+	
+	public boolean isEmpty(){
+		return queueList.isEmpty();
+	}
+	
+	public int size(){
+		return queueList.size();
+	}
+}
\ No newline at end of file
diff --git a/group18/1078285863/javaStudy/src/simpleStack/SimpleStack.java b/group18/1078285863/javaStudy/src/simpleStack/SimpleStack.java
new file mode 100644
index 0000000000..bfbea7b1db
--- /dev/null
+++ b/group18/1078285863/javaStudy/src/simpleStack/SimpleStack.java
@@ -0,0 +1,44 @@
+package simpleStack;
+
+import java.util.ArrayList;
+
+public class SimpleStack {
+private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){	
+		elementData.add(o);
+	}
+	
+	public Object pop(){
+		//�ж϶����Ƿ�Ϊ��
+		Object obj = peek();
+		if(obj != null)
+		{
+			elementData.remove(obj);
+			return obj;
+		}
+		else {
+			return null;
+		}
+	}
+	
+	public Object peek(){
+		if(elementData.isEmpty()){
+			return null;
+		}
+		else {
+			int lastIndex = elementData.size() -1;
+			Object obj = elementData.get(lastIndex);
+			return obj;
+		}
+		
+	}
+	public boolean isEmpty(){
+		boolean bEmpty = false;
+		bEmpty = elementData.isEmpty()?true:false;
+		return bEmpty;
+	}
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group18/1159828430/20170219/.classpath b/group18/1159828430/20170219/.classpath
new file mode 100644
index 0000000000..2d7497573f
--- /dev/null
+++ b/group18/1159828430/20170219/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group18/1159828430/20170219/.gitignore b/group18/1159828430/20170219/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group18/1159828430/20170219/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group18/1159828430/20170219/.project b/group18/1159828430/20170219/.project
new file mode 100644
index 0000000000..da66c3a498
--- /dev/null
+++ b/group18/1159828430/20170219/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>20170219</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group18/1159828430/20170219/src/com/coding/basic/ArrayList.java b/group18/1159828430/20170219/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..c8db730110
--- /dev/null
+++ b/group18/1159828430/20170219/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,145 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+/**
+ * @author Hipple
+ * @Time：2017年2月20日 下午8:53:31
+ * @version 1.0
+ */
+public class ArrayList implements List {
+	
+	//元素数量
+	private int size = 0;
+	
+	//默认容量
+	private final int defaultCapacity = 10;
+	
+	//存储元素的容器
+	private static Object[] elementData;
+	
+	//无参构造器
+	public ArrayList(){
+		elementData = new Object[defaultCapacity];
+	}
+	
+	//指定容量的构造器
+	public ArrayList(int capacity){
+		if (capacity < 0) {
+			//非法参数
+			throw new IllegalArgumentException("Illegal Capacity: "+ capacity);
+		}
+		elementData = new Object[capacity];
+	}
+	
+	//添加元素
+	public boolean add(Object o){
+		ensureCapacityInternal(size + 1);
+		elementData[size++] = o;
+		return true;
+	}
+	
+	//添加元素到指定位置
+	public void add(int index, Object o){
+		rangeCheck(index);
+		//将当前位置及后续元素后移一位
+		ensureCapacityInternal(size + 1);
+		System.arraycopy(elementData, index, elementData, index+1, size-index);
+		elementData[index] = o;
+		size++;
+	}
+	
+	//根据下表获取值
+	public Object get(int index){
+		rangeCheck(index); 
+		return elementData[index];
+	}
+	
+	//删除元素
+	public Object remove(int index){
+		rangeCheck(index);
+		Object oldValue = elementData[index];
+		int numMoved = size - index - 1;  
+	    if (numMoved > 0) {
+	    	//要删除的元素不是最后一个时，将当前元素及后续元素左移一位
+	        System.arraycopy(elementData, index+1, elementData, index, numMoved); 
+	    }
+	    elementData[--size] = null;//自动回收
+		return oldValue;
+	}
+	
+	//删除元素
+	public boolean remove(Object o) {
+		// 由于ArrayList中允许存放null，因此下面通过两种情况来分别处理。
+		if (o == null) {
+			for (int index = 0; index < size; index++){
+				if (elementData[index] == null) {
+					fastRemove(index);
+					return true;
+				}
+			}
+		} else {
+			for (int index = 0; index < size; index++){
+				if (o.equals(elementData[index])) {
+					fastRemove(index);
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+	
+	//返回现有元素数量
+	public int size(){
+		return size;
+	}
+	
+	//是否为空
+	public boolean isEmpty(){
+		return size == 0;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+	
+	//动态增加ArrayList大小
+    private void ensureCapacityInternal(int minCapacity) {
+    	//当前数组无法再存放时将数组长度增加至原长度的1.5倍
+        if (minCapacity - elementData.length > 0) {
+        	int newCapacity = (elementData.length * 3)/2;
+        	elementData = Arrays.copyOf(elementData, newCapacity);
+        }
+            
+    }
+    
+    //检查是否下标越界
+    private void rangeCheck(int index){
+    	if (index < 0 || index > this.size) {
+    		throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
+    	}
+    }
+    
+    //删除元素，与remove的 差别就是没有下标检查
+	private void fastRemove(int index) {
+		int numMoved = size - index - 1;
+		if (numMoved > 0){
+			System.arraycopy(elementData, index + 1, elementData, index, numMoved);
+		}
+		elementData[--size] = null; 
+	}
+    
+}
+class testArrayList{
+    public static void main(String[] args) {
+        ArrayList arrayList = new ArrayList();
+        for (int i = 0; i < 10; i++) {
+            arrayList.add(i+1);
+        }
+        arrayList.add(5,15);
+        arrayList.remove(11);
+        for (int i = 0; i < arrayList.size(); i++) {
+            System.out.println("value is "+arrayList.get(i));
+        }
+    }
+}
diff --git a/group18/1159828430/20170219/src/com/coding/basic/Iterator.java b/group18/1159828430/20170219/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..0ce3f762ba
--- /dev/null
+++ b/group18/1159828430/20170219/src/com/coding/basic/Iterator.java
@@ -0,0 +1,11 @@
+package com.coding.basic;
+/**
+ * @author Hipple
+ * @Time：2017年2月20日 下午8:56:05
+ * @version 1.0
+ */
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
\ No newline at end of file
diff --git a/group18/1159828430/20170219/src/com/coding/basic/LinkedList.java b/group18/1159828430/20170219/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..433715d5ad
--- /dev/null
+++ b/group18/1159828430/20170219/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,238 @@
+package com.coding.basic;
+
+import java.util.NoSuchElementException;
+
+/**
+ * @author Hipple
+ * @Time：2017年2月21日 下午8:00:21
+ * @version 1.0
+ */
+public class LinkedList implements List {
+    
+    //头结点
+    private Node first;
+    
+    //尾结点
+    private Node last;
+    
+    //元素数量
+    private int size = 0;
+    
+    //无参构造器
+    public LinkedList(){
+    }
+    
+    public boolean add(Object o){
+        linkLast(o);
+        return true;
+    }
+    
+    public void add(int index , Object o){
+    	checkPositionIndex(index);
+    	if (index == size) {
+			linkLast(o);
+		} else {
+			linkBefore(o, node(index));
+		}
+    }
+    
+    public Object remove(int index){
+    	checkElementIndex(index);
+        return unlink(node(index));
+    }
+    
+    public Object get(int index){
+    	checkElementIndex(index);
+    	return node(index).data;
+    }
+    
+    public void addFirst(Object o){
+    	linkFirst(o);
+    }
+    
+    public void addLast(Object o){
+        linkLast(o);
+    }
+    
+    public Object removeFirst(){
+    	final Node f = first;
+    	if (f == null) {
+    		throw new NoSuchElementException();
+    	}
+        return unlinkFirst(f);
+    }
+    
+    public Object removeLast(){
+    	final Node l = last;
+    	if (l == null) {
+    		throw new NoSuchElementException();
+    	}
+        return unlinkLast(l);
+    }
+    
+    public int size(){
+        return size;
+    }
+    
+    //检查是否为空
+    public boolean isEmpty(){
+    	return size == 0;
+    }
+    
+    //获取头节点
+    public Object getFirst() {
+        final Node f = first;
+        if (f == null)
+            throw new NoSuchElementException();
+        return f.data;
+    }
+    
+    public Iterator iterator(){
+        return null;
+    }
+    
+    //头部增加节点
+    private void linkFirst(Object data){
+        final Node f = first;//f存储老的头部节点待用
+        final Node newNode = new Node(null, data, first);//后项指针指向first，前项指针null
+        first = newNode;//将新节点变为头部节点
+        if (f == null) {//头节点为null则代表链表为空，那么新节点也是既是头结点也是尾结点
+            last = newNode;
+        } else {//老的头部节点前项指针指向新节点
+            f.previous = newNode;
+        }
+        size++;
+    }
+    
+    //尾部增加节点
+    private void linkLast(Object data){
+        final Node l = last;//l存储老的尾部节点待用
+        final Node newNode = new Node(last, data, null);//前项指针指向last，后项指针null
+        last = newNode;//将新节点变为尾部节点
+        if (l == null) {//尾节点为null则代表链表为空，那么新节点也是既是头结点也是尾结点
+            first = newNode;
+        } else {//老的尾部节点后项指针指向新节点
+            l.next = newNode;
+        }
+        size++;
+    }
+    
+    //指定index插入节点
+    private void linkBefore(Object o, Node oldNode){
+    	final Node pred = oldNode.previous;
+    	final Node newNode = new Node(pred, o, oldNode);
+    	oldNode.previous = newNode;//旧节点前项指针指向新节点
+    	if (pred == null) {//pred为null代表oldNode为头节点
+			first = newNode;
+		} else {
+			pred.next = newNode;
+		}
+    	size++;
+    	
+    }
+    
+    //删除头部节点并返回节点值
+    private Object unlinkFirst(Node f){
+    	final Object element = f.data;//保存头节点的值
+    	final Node next = f.next;
+    	f.data = null;//GC自动回收
+    	f.next = null;
+    	first = next;//将头节点的下一节点变为头节点
+    	if (next == null) {//如果next为空，则代表f同时为尾节点，此时整个链表为空
+    		last = null;
+    	} else {
+    		next.previous = null;
+    	}
+    	size--;
+    	return element;
+    }
+    
+    //删除尾部节点并返回该节点的值
+    private Object unlinkLast(Node l){
+    	final Object element = l.data;//保存尾节点的值
+    	final Node prev = l.previous;
+    	l.previous = null;
+    	l.data = null;//GC自动回收
+    	last = prev;//将尾节点的上一节点变为尾节点
+    	if (prev == null) {//如果prev为空，则代表l同时为头节点，此时整个链表为空
+    		first = null;
+    	} else {
+    		prev.next = null;
+    	}
+    	size--;
+    	return element;
+    }
+    
+    //删除指定节点
+    private Object unlink(Node x){
+    	final Object element = x.data;
+    	final Node prev = x.previous;
+    	final Node next = x.next;
+    	if (prev == null) {//prev为空代表要删除的是头节点
+    		unlinkFirst(x);
+		} else {//prev后项指针指向next
+			prev.next = next;
+			x.previous = null;
+		}
+    	if (next == null) {//next为空代表要删除的是尾节点
+    		unlinkLast(x);
+		} else {//next前项指针指向prev
+			next.previous = prev;
+			x.next = null;
+		}
+    	x.data = null;
+    	size--;
+    	return element;
+    }
+    
+    //查找结点
+    private Node node(int index){
+    	if (index < (size>>1)) {//判断循环方向
+    		Node x = first;
+    		for (int i = 0; i < index; i++) {
+    			x = x.next;
+    		}
+    		return x;
+    	} else {
+    		Node x = last;
+    		for (int i = size - 1; i > index; i--) {
+    			x = x.previous;
+    		}
+    		return x;
+    	}
+    }
+    
+    //检查下标是否合法
+    private void checkElementIndex(int index){
+    	if (!isElementIndex(index)) {
+    		throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
+    	}
+    }
+    
+    private void checkPositionIndex(int index){
+    	if (!isPositionIndex(index)) {
+    		throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
+    	}
+    }
+    
+    //检查该参数是否为现有元素的索引。
+    private boolean isElementIndex(int index) {
+        return index >= 0 && index < size;
+    }
+
+    //检查参数是否是迭代器或添加操作的有效位置的索引
+    private boolean isPositionIndex(int index) {
+        return index >= 0 && index <= size;
+    }
+    
+    private static class Node{
+        Object data;
+        Node next;
+        Node previous;
+        Node(Node previous, Object data, Node next) {
+             this.data = data;
+             this.next = next;
+             this.previous = previous;
+        }
+    }
+}
\ No newline at end of file
diff --git a/group18/1159828430/20170219/src/com/coding/basic/List.java b/group18/1159828430/20170219/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..08e0f9e2d5
--- /dev/null
+++ b/group18/1159828430/20170219/src/com/coding/basic/List.java
@@ -0,0 +1,13 @@
+package com.coding.basic;
+/**
+ * @author Hipple
+ * @Time：2017年2月20日 下午8:52:08
+ * @version 1.0
+ */
+public interface List {
+	public boolean add(Object o);
+	public void add(int index, Object o);
+	public Object get(int index);
+	public Object remove(int index);
+	public int size();
+}
\ No newline at end of file
diff --git a/group18/1159828430/20170219/src/com/coding/basic/Queue.java b/group18/1159828430/20170219/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..e91779fdb2
--- /dev/null
+++ b/group18/1159828430/20170219/src/com/coding/basic/Queue.java
@@ -0,0 +1,31 @@
+package com.coding.basic;
+/**
+ * @author Hipple
+ * @Time：2017年2月23日 下午11:00:00
+ * @version 1.0
+ */
+
+public class Queue {
+	private LinkedList elementData = new LinkedList();
+	
+	public Queue(){
+		
+	}
+	
+	public void enQueue(Object o){
+		elementData.addLast(o);
+	}
+	
+	public Object deQueue(){
+		elementData.getFirst();
+		return null;
+	}
+	
+	public boolean isEmpty(){
+		return elementData.isEmpty();
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group18/1159828430/20170219/src/com/coding/basic/Stack.java b/group18/1159828430/20170219/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..ef5b637050
--- /dev/null
+++ b/group18/1159828430/20170219/src/com/coding/basic/Stack.java
@@ -0,0 +1,57 @@
+package com.coding.basic;
+
+import java.util.EmptyStackException;
+
+/**
+ * @author Hipple
+ * @Time：2017年2月23日 下午10:59:39
+ * @version 1.0
+ */
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public Stack(){
+		
+	}
+	
+	//入栈  
+	public void push(Object o){
+		elementData.add(o);
+	}
+	
+	//出栈
+	public Object pop(){
+		if (elementData.isEmpty()) {
+			throw new EmptyStackException();
+		}
+		final Object o = peek();
+		elementData.remove(o);//重新写根据对象remove
+		return o;
+	}
+	
+	public Object peek(){
+		if (elementData.isEmpty()) {
+			throw new EmptyStackException();
+		}
+		final Object o = elementData.get(elementData.size()-1);
+		return o;
+	}
+	public boolean isEmpty(){
+		return size() == 0;
+	}
+	public int size(){
+		return elementData.size();
+	}
+}
+class TestStack {  
+    public static void main(String[] args){  
+    	Stack myStack=new Stack();  
+        myStack.push("a");  
+        myStack.push(2);  
+        myStack.push("123");  
+        myStack.push("ahu");  
+        while(!myStack.isEmpty()){  
+            System.out.println(myStack.pop());
+        }  
+    }  
+} 
diff --git a/group18/1159828430/README.md b/group18/1159828430/README.md
new file mode 100644
index 0000000000..387ebebf6d
--- /dev/null
+++ b/group18/1159828430/README.md
@@ -0,0 +1,2 @@
+# 2017编程提高群
+这里是1159828430 大连—书生 的代码提交区
diff --git a/group18/744888802/dataStructure/pom.xml b/group18/744888802/dataStructure/pom.xml
new file mode 100644
index 0000000000..3b262d6184
--- /dev/null
+++ b/group18/744888802/dataStructure/pom.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>dataStructure</groupId>
+    <artifactId>dataStructure</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.6</source>
+                    <target>1.6</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+
+</project>
\ No newline at end of file
diff --git a/group18/744888802/dataStructure/src/main/java/com/coding/basic/ArrayList.java b/group18/744888802/dataStructure/src/main/java/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..728edc3500
--- /dev/null
+++ b/group18/744888802/dataStructure/src/main/java/com/coding/basic/ArrayList.java
@@ -0,0 +1,109 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+
+	//每次增加的长度
+	private Integer addArrayLength = 10;
+	//初始  数组长度
+	private Object[] elementData = new Object[10];
+	
+	public void add(Object o){
+		if(size < elementData.length)
+		{
+			elementData[size]=o;
+		}else{
+			//扩容数组
+			 grow();
+			elementData[size] = 0;
+		}
+		size++;
+		
+	}
+	public void add(int index, Object o){
+		if(index>size)
+		{
+			throw new RuntimeException("ArrayIndexOutOfBoundsException");
+		}
+
+		//截取索引开始到原数组结尾  组成一个新的数组
+		Object [] tempObjs =  Arrays.copyOfRange(elementData,index,elementData.length);
+		//覆盖原有索引位置的对象
+		elementData[index] = o;
+		//数组扩容
+		elementData = Arrays.copyOf(elementData,elementData.length+1);
+
+		//将临时生成的数组合并回原数组
+		System.arraycopy(tempObjs,0,elementData,index+1,tempObjs.length);
+		size++;
+	}
+
+	
+	public Object get(int index){
+		return elementData[index];
+	}
+	
+	public Object remove(int index){
+
+		if(index>size)
+		{
+			throw new RuntimeException("ArrayIndexOutOfBoundsException");
+		}
+
+		Object o = elementData[index];
+
+		//截取索引开始到原数组结尾  组成一个新的数组
+		Object [] tempObjs =  Arrays.copyOfRange(elementData,index+1,elementData.length);
+		elementData = Arrays.copyOf(elementData,elementData.length-1);
+		//将临时生成的数组合并回原数组
+		System.arraycopy(tempObjs,0,elementData,index,tempObjs.length);
+		size--;
+
+		return o;
+	}
+	
+	public int size(){
+		return this.size;
+	}
+	
+	public Iterator iterator(){
+		ArratListIterator arratListIterator = new ArratListIterator(this);
+
+		return arratListIterator;
+	}
+
+	private void grow(){
+		elementData = Arrays.copyOf(elementData,elementData.length+addArrayLength);
+	}
+
+	class ArratListIterator implements Iterator{
+
+		ArrayList arrayList = new ArrayList();
+
+		int index = 0;
+
+		ArratListIterator(ArrayList arrayList){
+
+			this.arrayList = arrayList;
+			index = arrayList.size;
+		}
+
+		@Override
+		public boolean hasNext() {
+			if(index == 0)
+			{
+				return false;
+			}
+			return true;
+		}
+
+		@Override
+		public Object next() {
+			return this.arrayList.get(--index);
+		}
+	}
+	
+}
diff --git a/group18/744888802/dataStructure/src/main/java/com/coding/basic/BinaryTreeNode.java b/group18/744888802/dataStructure/src/main/java/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..8fc6e03297
--- /dev/null
+++ b/group18/744888802/dataStructure/src/main/java/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,84 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	
+	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) {
+
+		BinaryTreeNode binaryTreeNode = new BinaryTreeNode();
+		binaryTreeNode.data = o;
+
+		add(this, binaryTreeNode);
+		return this;
+	}
+
+	private void add(BinaryTreeNode binaryTreeNodeOld, BinaryTreeNode binaryTreeNodeNew) {
+		if (binaryTreeNodeOld.data == null) {
+			binaryTreeNodeOld.data = binaryTreeNodeNew.data;
+			return;
+		}
+
+
+		if (binaryTreeNodeOld.left == null) {
+			binaryTreeNodeOld.left = binaryTreeNodeNew;
+			return;
+		}
+		if (binaryTreeNodeOld.right == null) {
+			if (comparator(binaryTreeNodeNew, binaryTreeNodeOld.left)){
+				binaryTreeNodeOld.right = binaryTreeNodeNew;
+			}else{
+				binaryTreeNodeOld.right = binaryTreeNodeOld.left;
+				binaryTreeNodeOld.left = binaryTreeNodeNew;
+			}
+			return;
+		}
+
+		if(comparator(binaryTreeNodeOld.left, binaryTreeNodeNew))
+		{
+			add(binaryTreeNodeOld.left,binaryTreeNodeNew);
+			return;
+		}
+
+		if(comparator(binaryTreeNodeOld.right, binaryTreeNodeNew)){
+			add(binaryTreeNodeOld.right,binaryTreeNodeNew);
+			return;
+		}else{
+			binaryTreeNodeNew.left = binaryTreeNodeOld.right;
+			binaryTreeNodeOld.right = binaryTreeNodeNew;
+		}
+
+
+
+
+	}
+
+	private boolean comparator(BinaryTreeNode binaryTreeNode1, BinaryTreeNode binaryTreeNode2) {
+		if ((Integer) binaryTreeNode1.getData() > (Integer) binaryTreeNode2.getData()) {
+			return true;
+		}
+		return false;
+	}
+	
+}
diff --git a/group18/744888802/dataStructure/src/main/java/com/coding/basic/Iterator.java b/group18/744888802/dataStructure/src/main/java/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..06ef6311b2
--- /dev/null
+++ b/group18/744888802/dataStructure/src/main/java/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/group18/744888802/dataStructure/src/main/java/com/coding/basic/LinkedList.java b/group18/744888802/dataStructure/src/main/java/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..098246a4bb
--- /dev/null
+++ b/group18/744888802/dataStructure/src/main/java/com/coding/basic/LinkedList.java
@@ -0,0 +1,237 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	private Node last;
+
+	private int size = 0;
+	
+	public void add(Object o){
+		addLast(o);
+
+	}
+	public void add(int index , Object o){
+
+		Node node = new Node();
+		node.data = o;
+		if(size == 0)
+		{
+			throw new NullPointerException(" linked list is null");
+		}
+		if(index == 0)
+		{
+			node.next=head;
+			head = node;
+		}
+		Node nodeNow = head;
+		for(int i=1;i<size;i++)
+		{
+			Node nextNode = nodeNow.next;
+			if(i == index)
+			{
+				node.next = nextNode;
+				nodeNow.next = node;
+				break;
+			}
+			nodeNow = nodeNow.next;
+		}
+		size++;
+
+		
+	}
+	public Object get(int index){
+		if(size == 0)
+		{
+			throw new NullPointerException("linked list is null");
+		}
+		if(index >=size)
+		{
+			throw new IndexOutOfBoundsException(" this index too big by this list");
+		}
+
+		Node nodeNow = head;
+		for(int i=0;i<size;i++)
+		{
+			if(i == index)
+			{
+				return nodeNow.data;
+			}
+			nodeNow = nodeNow.next;
+		}
+		return null;
+	}
+	public Object remove(int index){
+
+		if(index >=size)
+		{
+			throw new IndexOutOfBoundsException(" this index too big by this list");
+		}
+		if(size == 0)
+		{
+			throw new NullPointerException("linked list is null");
+		}
+		if(index == 0)
+		{
+			if(size == 1)
+			{
+				size = 0;
+				return head.data;
+			}
+			Object o = head.data;
+			head.next = null;
+
+			head = head.next;
+			return o;
+
+		}
+		Node result = null;
+
+
+		Node beforeNode = head;
+		Node nextNode = head.next;
+		for(int i=1;i<size;i++)
+		{
+			if(index == i)
+			{
+				beforeNode.next = nextNode.next;
+				size--;
+				return nextNode.data;
+			}
+			beforeNode = nextNode;
+			nextNode = nextNode.next;
+		}
+
+
+		return result;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		if(head == null)
+		{
+			Node node = new Node();
+			node.data = o;
+			head = node;
+			last = node;
+		}else{
+			Node node = new Node();
+			node.data = o;
+			node.next = last;
+			head = node;
+		}
+		size++;
+	}
+	public void addLast(Object o){
+		if(head == null)
+		{
+			Node node = new Node();
+			node.data = o;
+			head = node;
+			last = node;
+		}else{
+			Node node = new Node();
+			node.data = o;
+			last.next = node;
+			last = node;
+		}
+		size++;
+	}
+	public Object removeFirst(){
+		if(size == 0)
+		{
+			throw new NullPointerException(" this linkedlist is null");
+		}
+		if(size == 1)
+		{
+			size = 0;
+		}
+
+		head = head.next;
+		size--;
+		return head.data;
+	}
+	public Object removeLast(){
+
+		if(size==0)
+		{
+			throw new NullPointerException("this linkedlist is null ");
+		}
+
+		if(size == 1)
+		{
+			size = 0;
+			return head;
+		}
+
+
+
+		Node nowNode = head;
+		Node beforeNode = head;
+		for(int i=0;i<size;i++)
+		{
+			if(nowNode.next == null)
+			{
+				beforeNode.next = null;
+				last = beforeNode;
+				size--;
+				return last;
+
+
+			}
+			nowNode = nowNode.next;
+			beforeNode = nowNode;
+		}
+
+
+
+
+		size--;
+
+		return last.data;
+
+	}
+	public Iterator iterator(){
+		return null;
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+	}
+	class LinkedListIterator implements Iterator{
+		private LinkedList linkedList ;
+		private int countNum = 0;
+
+		public LinkedListIterator(LinkedList linkedList)
+		{
+			this.linkedList = linkedList;
+			countNum = linkedList.size;
+		}
+
+
+
+		@Override
+		public boolean hasNext() {
+			if(countNum == 0)
+			{
+				return false;
+			}
+			return true;
+		}
+
+		@Override
+		public Object next() {
+
+			Object obj = linkedList.get(countNum--);
+			linkedList.removeLast();
+
+			return obj;
+		}
+	}
+
+}
diff --git a/group18/744888802/dataStructure/src/main/java/com/coding/basic/List.java b/group18/744888802/dataStructure/src/main/java/com/coding/basic/List.java
new file mode 100644
index 0000000000..09ab70edc5
--- /dev/null
+++ b/group18/744888802/dataStructure/src/main/java/com/coding/basic/List.java
@@ -0,0 +1,13 @@
+package com.coding.basic;
+
+public interface List {
+    void add(Object o);
+
+    void add(int index, Object o);
+
+    Object get(int index);
+
+    Object remove(int index);
+
+    int size();
+}
diff --git a/group18/744888802/dataStructure/src/main/java/com/coding/basic/Queue.java b/group18/744888802/dataStructure/src/main/java/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..b2d8758c20
--- /dev/null
+++ b/group18/744888802/dataStructure/src/main/java/com/coding/basic/Queue.java
@@ -0,0 +1,21 @@
+package com.coding.basic;
+
+public class Queue extends LinkedList{
+
+	//队列尾部加一个
+	public void enQueue(Object o){
+		super.addLast(o);
+	}
+	//队列头部减少一个
+	public Object deQueue(){
+		return super.removeFirst();
+	}
+	
+	public boolean isEmpty(){
+		return super.size()==0;
+	}
+	
+	public int size(){
+		return super.size();
+	}
+}
diff --git a/group18/744888802/dataStructure/src/main/java/com/coding/basic/Stack.java b/group18/744888802/dataStructure/src/main/java/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..a4efc797dc
--- /dev/null
+++ b/group18/744888802/dataStructure/src/main/java/com/coding/basic/Stack.java
@@ -0,0 +1,47 @@
+package com.coding.basic;
+
+public class Stack extends LinkedList {
+//	private ArrayList elementData = new ArrayList();
+
+
+	/**
+	 * 栈顶插入元素
+	 * @param o
+	 */
+	public void push(Object o){
+		super.addFirst(o);
+	}
+
+	/**
+	 * 获取栈顶元素 并且删除
+	 */
+	public Object pop(){
+		if(super.size()==0)
+		{
+			return null;
+		}
+		Object o = super.get(0);
+		super.removeFirst();
+		return o;
+	}
+
+
+	/**
+	 * 获取栈顶元素 不删除
+	 * @return
+	 */
+	public Object peek(){
+		if(super.size()==0)
+		{
+			return null;
+		}
+		return super.get(0);
+	}
+
+	public boolean isEmpty(){
+		return super.size()==0;
+	}
+	public int size(){
+		return super.size();
+	}
+}
diff --git a/group18/744888802/dataStructure/src/main/java/com/coding/basic/TestMain.java b/group18/744888802/dataStructure/src/main/java/com/coding/basic/TestMain.java
new file mode 100644
index 0000000000..b7547ac809
--- /dev/null
+++ b/group18/744888802/dataStructure/src/main/java/com/coding/basic/TestMain.java
@@ -0,0 +1,29 @@
+package com.coding.basic;
+
+import com.coding.domain.UserInfo;
+
+/**
+ * Created by hushuai on 2017/2/20.
+ */
+public class TestMain {
+
+    public static void main(String[] args) {
+
+
+        ArrayList arrayList = new ArrayList();
+        for(int i=0;i<5;i++)
+        {
+            arrayList.add(new UserInfo("name-"+i));
+        }
+
+
+        Iterator iterator = arrayList.iterator();
+        while (iterator.hasNext()){
+            UserInfo userInfo = (UserInfo)iterator.next();
+            System.out.println(userInfo.getName());
+
+        }
+
+    }
+
+}
diff --git a/group18/784140710/week01/.gitignore b/group18/784140710/week01/.gitignore
new file mode 100644
index 0000000000..68bcada58d
--- /dev/null
+++ b/group18/784140710/week01/.gitignore
@@ -0,0 +1,4 @@
+/bin/
+.settings
+.classpath
+.project
diff --git a/group18/784140710/week01/src/com/coding/basic/ArrayIterator.java b/group18/784140710/week01/src/com/coding/basic/ArrayIterator.java
new file mode 100644
index 0000000000..9af5e3a1a7
--- /dev/null
+++ b/group18/784140710/week01/src/com/coding/basic/ArrayIterator.java
@@ -0,0 +1,27 @@
+package com.coding.basic;
+
+public class ArrayIterator implements Iterator{
+
+	private int index = 0;
+	private List list ;
+	
+	public ArrayIterator(List list){
+		this.list = list;
+	}
+	
+	@Override
+	public boolean hasNext() {
+		
+		if(index<list.size()){
+			return true;
+		}else{
+			return false;
+		}
+	}
+
+	@Override
+	public Object next() {
+		return list.get(index++);
+	}
+	
+}
diff --git a/group18/784140710/week01/src/com/coding/basic/ArrayList.java b/group18/784140710/week01/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..28d38159ef
--- /dev/null
+++ b/group18/784140710/week01/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,84 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[5];
+	
+	public void add(Object o){
+		if(++size > elementData.length){
+			elementData = Arrays.copyOf(elementData, elementData.length*2);
+		}
+		elementData[size-1] = o;
+		
+	}
+	public void add(int index, Object o){
+		Object[] tmp = new Object[elementData.length];
+		
+		if(index<0 || index >elementData.length-1){
+			return;
+		}
+		if(++size > elementData.length){
+			elementData = Arrays.copyOf(elementData, elementData.length*2);
+			tmp = new Object[elementData.length];
+		}
+		System.arraycopy(elementData, 0, tmp, 0, index);
+		System.arraycopy(elementData, index, tmp, index+1, size-index);
+		tmp[index] = o;
+		elementData=tmp;
+		
+	}
+	
+	public Object get(int index){
+		if(index<0 || index >elementData.length-1){
+			return null;
+		}
+		return elementData[index];
+	}
+	
+	public Object remove(int index){
+		Object o=null;
+		o = elementData[index];
+		if(--size%5 == 0){
+			elementData = Arrays.copyOf(elementData, elementData.length/2);
+		}else if(index == size-1){
+			elementData[index] = null;
+		}else if(index == size-1){
+			
+			System.arraycopy(elementData, index+1, elementData, index, size-index-1);
+		}
+		
+		return o;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public Iterator iterator(){
+		return new ArrayIterator(this);
+	}
+	
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/group18/784140710/week01/src/com/coding/basic/BinaryTree.java b/group18/784140710/week01/src/com/coding/basic/BinaryTree.java
new file mode 100644
index 0000000000..01b7a90a43
--- /dev/null
+++ b/group18/784140710/week01/src/com/coding/basic/BinaryTree.java
@@ -0,0 +1,65 @@
+package com.coding.basic;
+
+
+public class BinaryTree {
+
+	private BinaryTreeNode root;
+	
+	public void insert(Integer o){
+		BinaryTreeNode node = new BinaryTreeNode(o);
+		if(root == null){
+			root = node;
+		}else{
+			BinaryTreeNode current = root;
+			BinaryTreeNode parent;
+			
+			while(true){
+				parent = current;
+				if(o<parent.getData()){
+					current = parent.getLeft();
+					if(current == null){
+						parent.setLeft(node);
+						return;
+					}
+				}else{
+					current = parent.getRight();
+					if(current == null){
+						parent.setRight(node);
+						return;
+					}
+				}
+			}
+		}
+	}
+	
+	public BinaryTreeNode find(Integer i){
+		
+		BinaryTreeNode node = root;
+		
+		while(node != null){
+			if(i<node.getData()){
+				node = node.getLeft();
+			}else if(i>node.getData()){
+				node = node.getRight();
+			}else{
+				return node;
+			}
+		}
+		
+		return null;
+	}
+	
+	
+}
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/group18/784140710/week01/src/com/coding/basic/BinaryTreeNode.java b/group18/784140710/week01/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..15cbb94d28
--- /dev/null
+++ b/group18/784140710/week01/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,66 @@
+package com.coding.basic;
+
+
+public class BinaryTreeNode {
+
+	private Integer data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+	
+	public BinaryTreeNode(Integer data){
+		this.data = data;
+	}
+	
+	public Integer getData() {
+		return data;
+	}
+	public void setData(Integer 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;
+	}
+	
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/group18/784140710/week01/src/com/coding/basic/Iterator.java b/group18/784140710/week01/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..06ef6311b2
--- /dev/null
+++ b/group18/784140710/week01/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/group18/784140710/week01/src/com/coding/basic/LinkedList.java b/group18/784140710/week01/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..eb0b6fbeae
--- /dev/null
+++ b/group18/784140710/week01/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,114 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	private int size = 0;
+	
+	public void add(Object o){
+		++size;
+		Node node = new Node(o);
+		
+		if(head == null){
+			head = node;
+			return;
+		}
+		Node tmp = new Node(o);
+		tmp = head;
+		while(tmp.next!=null){
+			tmp = tmp.next;
+		}
+		tmp.next = node;
+	}
+	public void add(int index , Object o){
+		++size;
+		Node node = new Node(o);
+		Node tmp = new Node(o);
+		tmp = head;
+		int i =0;
+		while(tmp.next!=null && i<index-1){
+			tmp = tmp.next;
+			i++;
+		}
+		node.next = tmp.next;
+		tmp.next = node;
+		
+	}
+	public Object get(int index){
+		
+		if(head == null){
+			return null;
+		}
+		Node tmp = head;
+		int i =0;
+		while(tmp.next!=null && i<index){
+			tmp = tmp.next;
+			i++;
+		}
+		return tmp;
+	}
+	public Object remove(int index){
+		--size;
+		Node node = null;
+		if(head == null){
+			return null;
+		}
+		Node tmp = head;
+		int i = 0;
+		while(tmp.next!=null && i<index-1){
+			tmp = tmp.next;
+			i++;
+		}
+		node = tmp.next;
+		tmp.next = node.next;
+		
+		return node;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		++size;
+		Node node = new Node(o);
+		node.next = head;
+		head = node;
+	}
+	public void addLast(Object o){
+		add(o);
+	}
+	public Object removeFirst(){
+		--size;
+		if(head == null){
+			return null;
+		}
+		Node tmp = head;
+		head = head.next;
+		return tmp;
+	}
+	public Object removeLast(){
+		--size;
+		Node tmp = head;
+		Node node = null;
+		while(tmp.next!=null){
+			node = tmp;
+			tmp = tmp.next;
+		}
+		
+		node.next = null;
+		return tmp;
+	}
+	public Iterator iterator(){
+		return new ArrayIterator(this);
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		public Node(Object data){
+			this.data = data;
+		}
+	}
+}
diff --git a/group18/784140710/week01/src/com/coding/basic/List.java b/group18/784140710/week01/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ b/group18/784140710/week01/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/group18/784140710/week01/src/com/coding/basic/Queue.java b/group18/784140710/week01/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..4b03bb0565
--- /dev/null
+++ b/group18/784140710/week01/src/com/coding/basic/Queue.java
@@ -0,0 +1,21 @@
+package com.coding.basic;
+
+public class Queue {
+	private LinkedList list = new LinkedList();
+	public void enQueue(Object o){	
+		
+		list.addLast(o);
+	}
+	
+	public Object deQueue(){
+		return list.removeFirst();
+	}
+	
+	public boolean isEmpty(){
+		return list.removeFirst() == null ? true:false;
+	}
+	
+	public int size(){
+		return list.size();
+	}
+}
diff --git a/group18/784140710/week01/src/com/coding/basic/Stack.java b/group18/784140710/week01/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..674ef3e5e9
--- /dev/null
+++ b/group18/784140710/week01/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 false;
+	}
+	public int size(){
+		return -1;
+	}
+}
diff --git a/group18/784140710/week01/src/com/coding/test/Test01.java b/group18/784140710/week01/src/com/coding/test/Test01.java
new file mode 100644
index 0000000000..348aea7823
--- /dev/null
+++ b/group18/784140710/week01/src/com/coding/test/Test01.java
@@ -0,0 +1,62 @@
+package com.coding.test;
+
+import org.junit.Test;
+
+import com.coding.basic.ArrayList;
+import com.coding.basic.Iterator;
+import com.coding.basic.LinkedList;
+import com.coding.basic.Stack;
+
+public class Test01 {
+
+	@Test
+	public void testStack(){
+		
+		Stack stack = new Stack();
+		stack.push("1");
+		stack.push("2");
+		stack.push("3");
+		Object o = stack.peek();
+		Object o1 = stack.pop();
+		System.out.println();
+	}
+	
+	@Test
+	public void test01(){
+		ArrayList list = new ArrayList();
+		list.add("a");
+		list.add("b");
+		list.add("c");
+		list.add("d");
+		list.add("e");
+		list.add("asd");
+		
+		Iterator it = list.iterator();
+		while(it.hasNext()){
+			System.out.println((String)it.next());
+		}
+//		list.add(2,"3");
+//		list.remove(2);
+//		Object o = list.get(4);
+//		System.out.println(o);
+	}
+	
+	@Test
+	public void test02(){
+		LinkedList list = new LinkedList();
+		list.add("1");
+		list.add("2");
+		list.add("3");
+//		list.addFirst("0");
+		list.add("4");
+		list.add("5");
+//		list.removeFirst();
+//		Object o1 = list.removeLast();
+//		Object o = list.remove(3);
+		Iterator it = list.iterator();
+		while(it.hasNext()){
+			System.out.println(it.next());
+		}
+	}
+	
+}
diff --git a/group18/784140710/week01/src/com/coding/test/TestBinaryTree.java b/group18/784140710/week01/src/com/coding/test/TestBinaryTree.java
new file mode 100644
index 0000000000..2d6f5c262c
--- /dev/null
+++ b/group18/784140710/week01/src/com/coding/test/TestBinaryTree.java
@@ -0,0 +1,20 @@
+package com.coding.test;
+
+import com.coding.basic.BinaryTree;
+import com.coding.basic.BinaryTreeNode;
+
+public class TestBinaryTree {
+
+	public static void main(String[] args) {
+		
+		BinaryTree tree = new BinaryTree();
+		tree.insert(87);
+		tree.insert(17);
+		tree.insert(88);
+		tree.insert(36);
+		BinaryTreeNode i = tree.find(17);
+		BinaryTreeNode i1 = tree.find(12);
+		System.out.println();
+	}
+	
+}
diff --git a/group18/935542673/Coding/.classpath b/group18/935542673/Coding/.classpath
new file mode 100644
index 0000000000..63024e81ef
--- /dev/null
+++ b/group18/935542673/Coding/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="junit"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/group18/935542673/Coding/.gitignore b/group18/935542673/Coding/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group18/935542673/Coding/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group18/935542673/Coding/.project b/group18/935542673/Coding/.project
new file mode 100644
index 0000000000..8b11575db2
--- /dev/null
+++ b/group18/935542673/Coding/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Coding</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyArrayListTest.java b/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyArrayListTest.java
new file mode 100644
index 0000000000..f8bb390595
--- /dev/null
+++ b/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyArrayListTest.java
@@ -0,0 +1,92 @@
+package com.ikook.basic_data_structure;
+
+import static org.junit.Assert.*;
+
+import java.util.Date;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * 此单元测试只测试了正常情况，一些异常情况没有测试。
+ * @author ikook
+ */
+public class MyArrayListTest {
+	
+	private MyArrayList list;
+	
+	@Before
+	public void setUp() {
+		list = new MyArrayList();
+		list.add("111");
+		list.add("222");
+		list.add(33);
+		list.add("444");
+		list.add(new Date());
+		list.add("666");
+		list.add("777");
+		list.add("888");
+		list.add("999");
+	}
+
+	@Test
+	public void testAdd() {
+		//测试add(Object obj)方法
+		list.add(100);
+		assertEquals(10, list.size());
+		
+		//测试add(int index, Object obj)方法
+		list.add(3, 444);
+		assertEquals(444, list.get(3));
+		
+		assertEquals("444", list.get(4));
+		assertEquals(11, list.size());
+	}
+	
+	@Test
+	public void testIsEmpty() {
+		
+		assertEquals(false, list.isEmpty());
+	}
+	
+	@Test
+	public void testGet() {
+		assertEquals("111", list.get(0));
+		assertEquals(new Date(), list.get(4));
+	}
+	
+	@Test
+	public void testRemove() {
+	
+		// 测试remove(int index)方法
+		assertEquals(33, list.remove(2));
+		assertEquals("444", list.get(2));
+		
+		// 测试remove(Object obj)方法
+		assertEquals(true, list.remove("222"));
+		assertEquals("444", list.get(1));
+	}
+	
+	@Test
+	public void testSet() {
+		assertEquals(33, list.set(2, "333"));
+		assertEquals("333", list.get(2));
+	}
+	
+	@Test
+	public void testIterator() {
+		int i = 0;
+		for(MyIterator iter = list.iterator(); iter.hasNext();) {
+			Object str = (Object) iter.next();
+			assertEquals(list.get(i++), str);
+		}
+		
+		int j = list.size();
+		for(MyIterator iter = list.iterator(); iter.hasNext();) {
+		        iter.next();
+			iter.remove();
+			assertEquals( --j , list.size());
+		}
+	}
+
+}
diff --git a/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyBinarySearchTreeTest.java b/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyBinarySearchTreeTest.java
new file mode 100644
index 0000000000..59e1ad3797
--- /dev/null
+++ b/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyBinarySearchTreeTest.java
@@ -0,0 +1,64 @@
+package com.ikook.basic_data_structure;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * 此单元测试只测试了正常情况，一些异常情况没有测试。
+ * @author ikook
+ */
+public class MyBinarySearchTreeTest {
+	
+	private MyBinarySearchTree tree;
+	
+	@Before
+	public void setUp() {
+		tree = new MyBinarySearchTree();
+		
+		tree.insert(3);
+		tree.insert(8);
+	}
+
+	@SuppressWarnings("static-access")
+	@Test
+	public void testInsert() {
+		tree.insert(1);
+		tree.insert(4);
+		tree.insert(6);
+		tree.insert(2);
+		tree.insert(10);
+		tree.insert(9);
+		
+		assertEquals("1 2 3 4 6 8 9 10 ", tree.inorderTraverse(tree.root));
+	}
+
+	@Test
+	public void testFind() {
+		tree.insert(1);
+		tree.insert(4);
+		tree.insert(6);
+		tree.insert(2);
+		tree.insert(10);
+		tree.insert(9);
+		
+		assertEquals(false, tree.find(5));
+		assertEquals(true, tree.find(10));
+	}
+
+	@SuppressWarnings("static-access")
+	@Test
+	public void testDelete() {
+		tree.insert(1);
+		tree.insert(4);
+		tree.insert(6);
+		tree.insert(2);
+		tree.insert(10);
+		tree.insert(9);
+		
+		assertEquals(false, tree.delete(5));
+		assertEquals(true, tree.delete(4));
+		assertEquals("1 2 3 6 8 9 10 ", tree.inorderTraverse(tree.root));
+	}
+}
diff --git a/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyLinkedListTest.java b/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyLinkedListTest.java
new file mode 100644
index 0000000000..d479408183
--- /dev/null
+++ b/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyLinkedListTest.java
@@ -0,0 +1,131 @@
+package com.ikook.basic_data_structure;
+
+import static org.junit.Assert.*;
+
+import java.util.Date;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * 此单元测试只测试了正常情况，一些异常情况没有测试。
+ * @author ikook
+ */
+public class MyLinkedListTest {
+
+	private MyLinkedList list;
+
+	@Before
+	public void setUp() {
+		list = new MyLinkedList();
+		list.add("111");
+		list.add(222);
+		list.add("333");
+	}
+
+	@Test
+	public void testAddFirst() {
+		list.addFirst(444);
+		assertEquals(4, list.size());
+		assertEquals(444, list.get(0));
+		assertEquals(444, list.getFirst());
+
+	}
+
+	@Test
+	public void testAddLast() {
+		list.addLast("444");
+		assertEquals(4, list.size());
+		assertEquals("444", list.getLast());
+		assertEquals("444", list.get(3));
+	}
+
+	@Test
+	public void testAddObject() {
+		list.add(new Date());
+		assertEquals(new Date(), list.get(3));
+	}
+
+	@Test
+	public void testAddIntObject() {
+		list.add(1, "222");
+		assertEquals("222", list.get(1));
+		assertEquals(4, list.size());
+	}
+
+	@Test
+	public void testSize() {
+		assertEquals(3, list.size());
+	}
+
+	@Test
+	public void testIsEmpty() {
+		assertEquals(false, list.isEmpty());
+
+		MyLinkedList list = new MyLinkedList();
+		assertEquals(true, list.isEmpty());
+	}
+
+	@Test
+	public void testGetFirst() {
+		assertEquals("111", list.getFirst());
+	}
+
+	@Test
+	public void testGetLast() {
+		assertEquals("333", list.getLast());
+	}
+
+	@Test
+	public void testGet() {
+		assertEquals(222, list.get(1));
+	}
+
+	@Test
+	public void testSet() {
+		assertEquals(222, list.set(1, new Date()));
+		assertEquals(new Date(), list.get(1));
+	}
+
+	@Test
+	public void testRemoveFirst() {
+		assertEquals("111", list.removeFirst());
+		assertEquals(222, list.getFirst());
+	}
+
+	@Test
+	public void testRemoveLast() {
+		assertEquals("333", list.removeLast());
+		assertEquals(222, list.getLast());
+	}
+
+	@Test
+	public void testRemoveObject() {
+		assertEquals(true, list.remove((Integer) 222));
+		assertEquals("333", list.get(1));
+	}
+
+	@Test
+	public void testRemoveInt() {
+		assertEquals(222, list.remove(1));
+		assertEquals("333", list.get(1));
+
+	}
+	
+	@Test
+	public void testIterator() {
+		int i = 0;
+		for(MyIterator iter = list.iterator(); iter.hasNext();) {
+			Object str = (Object) iter.next();
+			assertEquals(list.get(i++), str);
+		}
+		
+		int j = list.size();
+		for(MyIterator iter = list.iterator(); iter.hasNext();) {
+		        iter.next();
+			iter.remove();
+			assertEquals( --j , list.size());
+		}
+	}
+
+}
diff --git a/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyQueueTest.java b/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyQueueTest.java
new file mode 100644
index 0000000000..8fb8ba825f
--- /dev/null
+++ b/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyQueueTest.java
@@ -0,0 +1,54 @@
+package com.ikook.basic_data_structure;
+
+import static org.junit.Assert.*;
+
+import java.util.Date;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * 此单元测试只测试了正常情况，一些异常情况没有测试。
+ * @author ikook
+ */
+public class MyQueueTest {
+	
+	private MyQueue queue;
+	
+	@Before
+	public void setUp() {
+		queue = new MyQueue();
+		
+		queue.enQueue(111);
+		queue.enQueue("222");
+		queue.enQueue(new Date());
+	}
+
+	@Test
+	public void testEnQueue() {
+		queue.enQueue(444);
+		assertEquals(4, queue.size());
+	}
+
+	@Test
+	public void testDeQueue() {
+		assertEquals(111, queue.deQueue());
+	}
+	
+	@Test
+	public void testSize() {
+		assertEquals(3, queue.size());
+		
+		MyQueue queue = new MyQueue();
+		assertEquals(0, queue.size());
+	}
+	
+	@Test
+	public void testIsEmpty() {
+		assertEquals(false, queue.isEmpty());
+		
+		MyQueue queue = new MyQueue();
+		assertEquals(true, queue.isEmpty());
+	}
+
+}
diff --git a/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyStackTest.java b/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyStackTest.java
new file mode 100644
index 0000000000..fe1084e343
--- /dev/null
+++ b/group18/935542673/Coding/junit/com/ikook/basic_data_structure/MyStackTest.java
@@ -0,0 +1,55 @@
+package com.ikook.basic_data_structure;
+
+import static org.junit.Assert.*;
+
+import java.util.Date;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * 此单元测试只测试了正常情况，一些异常情况没有测试。
+ * @author ikook
+ */
+public class MyStackTest {
+
+	private MyStack stack;
+
+	@Before
+	public void setUp() {
+		stack = new MyStack();
+		stack.push(111);
+		stack.push("222");
+		stack.push(333);
+		stack.push(new Date());
+		stack.push("555");
+	}
+
+	@Test
+	public void testPush() {
+		stack.push(93554);
+		assertEquals(6, stack.size());
+	}
+
+	@Test
+	public void testPop() {
+		assertEquals("555", stack.pop());
+		assertEquals(4, stack.size());
+		
+		assertEquals(new Date(), stack.pop());
+	}
+
+	@Test
+	public void testGetTop() {
+		assertEquals("555", stack.getTop());
+	}
+
+	@Test
+	public void testIsEmpty() {
+		assertEquals(false, stack.isEmpty());
+		
+		MyStack stack = new MyStack();
+		assertEquals(true, stack.isEmpty());
+	}
+
+}
diff --git a/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyArrayList.java b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyArrayList.java
new file mode 100644
index 0000000000..6891a76879
--- /dev/null
+++ b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyArrayList.java
@@ -0,0 +1,215 @@
+package com.ikook.basic_data_structure;
+
+import java.util.ConcurrentModificationException;
+import java.util.NoSuchElementException;
+
+/**
+ * @author ikook;  QQ号码: 935542673
+ */
+public class MyArrayList implements MyList{
+
+	private Object[] elementData;
+	
+	private int size;
+	
+	/**
+	 * 使Object[]的长度默认为10；
+	 */
+	public MyArrayList() {
+		this(10);
+	}
+	 
+	/**
+	 * 在构造函数中初始化集合的长度
+	 * @param initialCapacity
+	 */
+	public MyArrayList(int initialCapacity) {
+		if(initialCapacity < 0) {
+			try {
+				throw new Exception();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+		this.elementData = new Object[initialCapacity];
+	}
+
+	/**
+	 * 在集合中添加元素
+	 * @param obj
+	 */
+	public void add(Object obj) {
+		
+		ensureCapacity();
+		elementData[size++] = obj;
+		
+	}
+	
+	/**
+	 * 添加元素到集合的指定位置
+	 * @param index
+	 * @param obj
+	 */
+	public void add(int index, Object obj) {
+		rangeCheck(index);
+		ensureCapacity();
+	
+		System.arraycopy(elementData, index, elementData, index + 1, size-index);
+		elementData[index] = obj;
+		size++;
+	}
+	
+	/**
+	 * 返回集合的长度
+	 * @return
+	 */
+	public int size() {
+		return size;
+	}
+	
+	/**
+	 * 判断集合是非为空
+	 * @return
+	 */
+	public boolean isEmpty() {
+		return size == 0;
+	}
+	
+	/**
+	 * 获取集合指定位置的元素
+	 * @param index
+	 * @return
+	 */
+	public Object get(int index) {
+		rangeCheck(index);
+		return elementData[index];
+	}
+	
+	/**
+	 * 删除指定位置的对象
+	 * @param index
+	 */
+	public Object remove(int index) {
+		
+		rangeCheck(index);
+		
+		Object oldValue = elementData[index];
+		
+		int numMoved = size - index - 1;
+	    if (numMoved > 0){
+	   		System.arraycopy(elementData, index+1, elementData, index,
+                       numMoved);
+	    }
+	    elementData[--size] = null; 
+	    
+	    return oldValue;
+	}
+	
+	/**
+	 * 删除指定的对象(Object 对象)
+	 * @param obj
+	 */
+	public boolean remove(Object obj){
+		for(int i = 0; i < size; i++) {
+			if(get(i).equals(obj)) {
+				remove(i);
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * 更改集合中指定位置的元素，并返回原来的对象
+	 * @param index
+	 * @param obj
+	 * @return
+	 */
+	public Object set(int index, Object obj) {
+		rangeCheck(index);
+		
+		Object oldValue = elementData[index];
+		elementData[index] = obj;
+		
+		return oldValue;
+	}
+	
+	/**
+	 * 集合扩容封装类
+	 */
+	private void ensureCapacity() {
+		if(size == elementData.length) {
+			Object[] newArray = new Object[size * 2 + 1];
+			System.arraycopy(elementData, 0, newArray, 0, elementData.length);
+			elementData = newArray;
+		}
+	}
+	
+	/**
+	 * 判断集合范围是否越界的封装类
+	 * @param index
+	 */
+	private void rangeCheck(int index) {
+		if(index < 0 || index >= size) {
+			try {
+				throw new Exception("索引异常");
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+	}
+	
+	/**
+	 * 返回一个迭代器的实现
+	 * @return
+	 */
+	public MyIterator iterator() {
+		return new Iter();
+	}
+	
+	/**
+	 * 迭代器的实现类
+	 * @author ikook
+	 */
+	private class Iter implements MyIterator {
+		
+		int cursor; // 返回下一个元素的索引
+		int lastRet = -1; // 返回最后一个元素的索引(始终指向刚遍历完的元素)，如果没有元素了，则为 -1
+
+		@Override
+		public boolean hasNext() {
+			return cursor != size;  // cursor 等于 size 则集合遍历完。
+		}
+
+		@Override
+		public Object next() {
+			
+			try{
+				int i = cursor;
+				Object next = get(i);
+				lastRet = i;
+				cursor = i + 1;
+				return next;
+			} catch (IndexOutOfBoundsException e) {
+				throw new NoSuchElementException("没有找到指定的元素, 迭代器遍历失败");
+			}
+			
+		}
+
+		@Override
+		public void remove() {
+			if (lastRet < 0) {
+				throw new IllegalStateException("非法状态异常，删除失败");
+			}
+			
+			try{
+				MyArrayList.this.remove(lastRet);
+				cursor = lastRet;
+				lastRet = -1;
+			} catch (IndexOutOfBoundsException e) {
+				throw new ConcurrentModificationException("竞争者改变异常，删除失败");
+			}
+		}
+		
+	}
+}
\ No newline at end of file
diff --git a/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyBinarySearchTree.java b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyBinarySearchTree.java
new file mode 100644
index 0000000000..d30be18a7a
--- /dev/null
+++ b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyBinarySearchTree.java
@@ -0,0 +1,200 @@
+package com.ikook.basic_data_structure;
+
+/**
+ * @author ikook;  QQ号码: 935542673
+ */
+public class MyBinarySearchTree {
+
+	public static Node root;
+
+	public MyBinarySearchTree() {
+		root = null;
+	}
+	
+	/**
+	 * 插入操作
+	 * @param id
+	 */
+	public void insert(int id) {
+		Node newNode = new Node(id); 
+		if (root == null) {
+			root = newNode;
+			return;
+		}
+		Node current = root; //当前节点
+		Node parent = null;  //父节点，即上一个节点
+		while (true) {
+			parent = current;
+			if (id < current.data) {
+				current = current.left;
+				if (current == null) {
+					parent.left = newNode;
+					return;
+				}
+			} else {
+				current = current.right;
+				if (current == null) {
+					parent.right = newNode;
+					return;
+				}
+			}
+		}
+	}
+
+	/**
+	 * 查找操作
+	 * @param id
+	 * @return
+	 */
+	public boolean find(int id) {
+		Node current = root;
+		while (current != null) {
+			if (current.data == id) {
+				return true;
+			} else if (current.data > id) {
+				current = current.left;
+			} else {
+				current = current.right;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * 删除操作
+	 * @param id
+	 * @return
+	 */
+	public boolean delete(int id) {
+		if (root == null) // 根节点为空，则树为空，返回false。
+			return false;
+		else {
+			Node parent = root;
+			Node current = root;
+			boolean isLeftChild = false; // 是否在左子树，默认为false：即不在。
+			// 找到删除点以及是否在左子树
+			while (current.data != id) {
+				parent = current;
+				if (current.data > id) {
+					isLeftChild = true;
+					current = current.left;
+				} else {
+					isLeftChild = false;
+					current = current.right;
+				}
+				if (current == null) {
+					return false;
+				}
+			}
+			
+			// 如果删除节点的左节点为空，右节点也为空。
+			if (current.left == null && current.right == null) {
+				if (current == root) {
+					root = null;
+				}
+				if (isLeftChild == true) {
+					parent.left = null;
+				} else {
+					parent.right = null;
+				}
+			}
+			// 如果删除节点只有一个子节点，则该节点为左节点或者右节点。
+			else if (current.right == null) {
+				if (current == root) {
+					root = current.left;
+				} else if (isLeftChild) {
+					parent.left = current.left;
+				} else {
+					parent.right = current.left;
+				}
+			} else if (current.left == null) {
+				if (current == root) {
+					root = current.right;
+				} else if (isLeftChild) {
+					parent.left = current.right;
+				} else {
+					parent.right = current.right;
+				}
+			} 
+			// 如果删除节点左节点右节点都不为空。
+			else if (current.left != null && current.right != null) {
+				
+				// 寻找删除节点的后继者：这说明已经发现最小元素在右子树中
+				Node successor = getSuccessor(current);
+				if (current == root) {
+					root = successor;
+				} else if (isLeftChild) {
+					parent.left = successor;
+				} else {
+					parent.right = successor;
+				}
+				successor.left = current.left;
+			}
+			return true;
+		}
+	}
+
+	/**
+	 * 获取删除节点的后继者：删除节点的后继者是在其右节点树中最小的节点
+	 * @param deleleNode
+	 * @return
+	 */
+	private Node getSuccessor(Node deleleNode) {
+		Node successsor = null;
+		Node successsorParent = null;
+		Node current = deleleNode.right;
+		while (current != null) {
+			successsorParent = successsor;
+			successsor = current;
+			current = current.left;
+		}
+		// 检查后继者是否有右节点
+		// 如果有右节点树，则将其添加到successorParent(后继者父节点)的左节点。
+		if (successsor != deleleNode.right) {
+			successsorParent.left = successsor.right;
+			successsor.right = deleleNode.right;
+		}
+		return successsor;
+	}
+
+	/**
+	 * 显示二叉树
+	 * @param root
+	 * @param sb
+	 */
+	private void display(Node root, StringBuilder sb) {
+		if (root != null) {
+			display(root.left, sb);
+			sb.append(root.data + " ");
+			display(root.right, sb);
+		}
+	}
+
+	/**
+	 * 中序遍历：左子树->根节点->右子树
+	 * @param root
+	 * @return
+	 */
+	public String inorderTraverse(Node root) {
+		StringBuilder sb = new StringBuilder();
+		this.display(root, sb);
+		return sb.toString();
+	}
+}
+
+/**
+ * 用于表示节点
+ * @author ikook
+ */
+class Node {
+
+	int data;
+	Node left;
+	Node right;
+
+	public Node(int data) {
+		this.data = data;
+		left = null;
+		right = null;
+	}
+}
\ No newline at end of file
diff --git a/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyIterator.java b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyIterator.java
new file mode 100644
index 0000000000..1fe7a69fcb
--- /dev/null
+++ b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyIterator.java
@@ -0,0 +1,14 @@
+package com.ikook.basic_data_structure;
+
+/**
+ * @author ikook   QQ号码: 935542673
+ */
+public interface MyIterator {
+	
+	public boolean hasNext();  // 判断是否有元素没有被遍历
+	
+	public Object next();  // 返回游标当前位置的元素并将游标移动到下一个位置
+	
+	public void remove();  // 删除游标左边的元素，在执行完 next 之后该操作只能执行一次
+
+}
diff --git a/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyLinkedList.java b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyLinkedList.java
new file mode 100644
index 0000000000..a255657911
--- /dev/null
+++ b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyLinkedList.java
@@ -0,0 +1,359 @@
+package com.ikook.basic_data_structure;
+
+import java.util.NoSuchElementException;
+
+/**
+ * @author ikook;  QQ号码: 935542673
+ */
+public class MyLinkedList implements MyList{
+
+	private Node first;
+	private Node last;
+	private int size;
+	
+	/**
+	 * 在链表的头部插入新的元素
+	 * @param obj
+	 */
+	public void addFirst(Object obj) {
+		final Node f = first;
+		final Node newNode = new Node(null, obj, f);
+		first = newNode;
+		if (f == null)
+			last = newNode;
+		else
+			f.previous = newNode;
+		size++;
+	}
+
+	/**
+	 * 在链表尾部插入新的元素
+	 * @param obj
+	 */
+	public void addLast(Object obj) {
+		final Node l = last;
+		final Node newNode = new Node(l, obj, null);
+		last = newNode;
+		if (l == null)
+			first = newNode;
+		else
+			l.next = newNode;
+		size++;
+	}
+
+	/**
+	 * 在链表中插入新的元素
+	 * @param obj
+	 */
+	public void add(Object obj) {
+		addLast(obj);
+	}
+
+	/**
+	 * 在指定位置插入新的元素
+	 * @param index
+	 * @param obj
+	 */
+	public void add(int index, Object obj) {
+		if (!(index >= 0 && index <= size)) {
+			throw new IndexOutOfBoundsException("索引位置越界");
+		}
+
+		if (index == size) {
+			addLast(obj);
+		} else {
+			Node temp = node(index);
+			final Node pred = temp.previous;
+			final Node newNode = new Node(pred, obj, temp);
+			temp.previous = newNode;
+			if (pred == null)
+				first = newNode;
+			else
+				pred.next = newNode;
+			size++;
+		}
+	}
+	
+	/**
+	 * 返回集合的size。
+	 * @return
+	 */
+	public int size() {
+		return size;
+	}
+	
+	/**
+	 * 判断集合是非为空
+	 * @return
+	 */
+	public boolean isEmpty() {
+		return size == 0;
+	}
+
+	/**
+	 * 获取链表头部的元素
+	 * @return
+	 */
+	public Object getFirst() {
+		final Node f = first;
+		if (f == null) {
+			throw new NoSuchElementException("没有找到指定的元素");
+		}
+		
+		return f.data;
+	}
+
+	/**
+	 * 获取链表尾部的元素
+	 * @return
+	 */
+	public Object getLast() {
+		final Node l = last;
+		if (l == null) {
+			throw new NoSuchElementException("没有找到指定的元素");
+		}
+		
+		return l.data;
+	}
+	
+	/**
+	 * 获取指定位置的元素
+	 * @param index
+	 * @return
+	 */
+	public Object get(int index) {
+		rangeCheckElementIndex(index);
+		return node(index).data;
+	}
+
+	/**
+	 * 更改指定位置的元素
+	 * @param index
+	 * @param element
+	 * @return
+	 */
+	public Object set(int index, Object element) {
+		rangeCheckElementIndex(index);
+		Node temp = node(index);
+		Object oldValue = temp.data;
+		temp.data = element;
+		return oldValue;
+	}
+
+
+	/**
+	 * 删除链表头部的元素
+	 * @return
+	 */
+	public Object removeFirst() {
+		final Node f = first;
+		if (f == null) {
+			throw new NoSuchElementException("没有找到指定的元素");
+		}
+		
+		final Object element = f.data;
+		final Node next = f.next;
+		f.data = null;
+		f.next = null;
+		first = next;
+		if (next == null) {
+			last = null;
+		} else {
+			next.previous = null;
+		}
+		size--;
+		
+		return element;
+	}
+
+	/**
+	 * 删除链表尾部的元素
+	 * @return
+	 */
+	public Object removeLast() {
+		final Node l = last;
+		if (l == null){
+			throw new NoSuchElementException("没有找到指定的元素");
+		}
+		
+		final Object element = l.data;
+		final Node prev = l.previous;
+		l.data = null;
+		l.previous = null;
+		last = prev;
+		if (prev == null) {
+			first = null;
+		} else {
+			prev.next = null;
+		}
+		size--;
+		
+		return element;
+	}
+	
+	/**
+	 * 删除指定元素
+	 * @param o
+	 * @return
+	 */
+	public boolean remove(Object o) {
+		if (o == null) {
+			for (Node temp = first; temp != null; temp = temp.next) {
+				if (temp.data == null) {
+					deleteElement(temp);
+					return true;
+				}
+			}
+		} else {
+			for (Node temp = first; temp != null; temp = temp.next) {
+				if (o.equals(temp.data)) {
+					deleteElement(temp);
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * 删除指定位置的元素
+	 * @param index
+	 * @return
+	 */
+	public Object remove(int index) {
+		rangeCheckElementIndex(index);
+		return deleteElement(node(index));
+	}
+	
+	/**
+	 * 删除指定节点元素
+	 * @param temp
+	 * @return
+	 */
+	private Object deleteElement(Node temp) {
+		final Object element = temp.data;
+		final Node next = temp.next;
+		final Node prev = temp.previous;
+
+		if (prev == null) {
+			first = next;
+		} else {
+			prev.next = next;
+			temp.previous = null;
+		}
+
+		if (next == null) {
+			last = prev;
+		} else {
+			next.previous = prev;
+			temp.next = null;
+		}
+
+		temp.data = null;
+		size--;
+		
+		return element;
+	}
+
+	/**
+	 * 检查索引元素的范围
+	 * @param index
+	 */
+	private void rangeCheckElementIndex(int index) {
+		if (!(index >= 0 && index < size)) {
+			throw new IndexOutOfBoundsException("索引越界");
+		}
+	}
+
+	/**
+	 * 返回指定索引位置的节点
+	 * @param index
+	 * @return
+	 */
+	Node node(int index) {
+		if (index < (size >> 1)) {
+			Node temp = first;
+			for (int i = 0; i < index; i++)
+				temp = temp.next;
+			return temp;
+		} else {
+			Node temp = last;
+			for (int i = size - 1; i > index; i--)
+				temp = temp.previous;
+			return temp;
+		}
+	}
+
+	/**
+	 * 用于表示一个节点
+	 * @author ikook
+	 */
+	private static class Node {
+		Node previous; // 上一个节点
+		Object data;
+		Node next; // 下一个节点
+
+		public Node(Node previous, Object data, Node next) {
+			this.previous = previous;
+			this.data = data;
+			this.next = next;
+		}
+	}
+	
+	/**
+	 * 返回一个迭代器的实现类
+	 * @return
+	 */
+	public MyIterator iterator() {
+		return new LinkIter();
+	}
+	
+	/**
+	 * 迭代器的实现类
+	 * @author ikook
+	 */
+	private class LinkIter implements MyIterator {
+		private Node lastRet; //始终指向刚遍历完的节点
+		private Node next; // 当前指向的节点
+		private int nextIndex; //当前节点的索引值
+		
+		LinkIter () {
+			next = node(0);
+			nextIndex = 0;
+		}
+
+		@Override
+		public boolean hasNext() {
+			return nextIndex < size;
+		}
+
+		@Override
+		public Object next() {
+			if(!hasNext()) {
+				throw new NoSuchElementException("没有找到指定的元素, 迭代器遍历失败");
+			}
+			
+			lastRet = next;
+			next = next.next;
+			nextIndex++;
+			return lastRet.data;
+		}
+
+		@Override
+		public void remove() {
+			if(lastRet == null) {
+				throw new IllegalStateException("非法状态异常，删除失败");
+			}
+			
+			Node lastNext = lastRet.next;
+			deleteElement(lastRet);
+			if(next == lastRet) {
+				next = lastNext;
+			} else {
+				nextIndex--;
+			}
+			lastRet = null;
+		}
+		
+	}
+}
diff --git a/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyList.java b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyList.java
new file mode 100644
index 0000000000..f1fa613d0e
--- /dev/null
+++ b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyList.java
@@ -0,0 +1,22 @@
+package com.ikook.basic_data_structure;
+
+/**
+ * @author ikook   QQ号码: 935542673
+ */
+public interface MyList {
+	
+	public void add(Object o);
+	public void add(int index, Object o);
+	
+	public int size();
+	
+	public boolean isEmpty();
+	
+	public Object get(int index);
+	
+	public Object remove(int index);
+	public boolean remove(Object obj);
+	
+	public Object set(int index, Object obj);
+	
+}
diff --git a/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyQueue.java b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyQueue.java
new file mode 100644
index 0000000000..824d7579c6
--- /dev/null
+++ b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyQueue.java
@@ -0,0 +1,42 @@
+package com.ikook.basic_data_structure;
+
+/**
+ * @author ikook;  QQ号码: 935542673
+ */
+public class MyQueue {
+	
+	private MyLinkedList queue = new MyLinkedList();
+	
+	/**
+	 * 入队操作
+	 * @param obj
+	 */
+	public void enQueue(Object obj) {
+		queue.addLast(obj);
+	}
+	
+	/**
+	 * 出队操作
+	 * @return
+	 */
+	public Object deQueue() {
+		return queue.removeFirst();
+	}
+	
+	/**
+	 * 队列的长度
+	 * @return
+	 */
+	public int size() {
+		return queue.size();
+	}
+	
+	/**
+	 * 队列是否为空
+	 * @return
+	 */
+	public boolean isEmpty() {
+		return queue.isEmpty();
+	}
+
+}
diff --git a/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyStack.java b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyStack.java
new file mode 100644
index 0000000000..0ad6c05910
--- /dev/null
+++ b/group18/935542673/Coding/src/com/ikook/basic_data_structure/MyStack.java
@@ -0,0 +1,73 @@
+package com.ikook.basic_data_structure;
+
+/**
+ * @author ikook;  QQ号码: 935542673
+ */
+public class MyStack {
+
+	private MyArrayList elementDate = new MyArrayList();
+
+	/**
+	 * 入栈操作
+	 * @param obj
+	 */
+	public void push(Object obj) {
+		elementDate.add(obj);
+	}
+
+	/**
+	 * 出栈操作
+	 * @return
+	 */
+	public Object pop() {
+		emptyExce();
+		return elementDate.remove(topIndex());
+	}
+
+	/**
+	 * 获取栈顶元素
+	 * @return
+	 */
+	public Object getTop() {
+		emptyExce();		
+		return 	elementDate.get(topIndex());
+	}
+
+	/**
+	 * 判断栈是否为空
+	 * @return
+	 */
+	public boolean isEmpty() {
+		return size() == 0;
+	}
+	
+	/**
+	 * 获取栈的深度
+	 * @return
+	 */
+	public int size() {
+		return elementDate.size();
+	}
+	
+	/**
+	 * 栈顶元素所在索引封装类
+	 * @return
+	 */
+	private int topIndex() {
+		return size() - 1;
+	}
+	
+	/**
+	 * 队列为空异常处理封装类
+	 */
+	private void emptyExce() {
+		if (isEmpty()) {
+			try {
+				throw new Exception("队列为空");
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+	}
+	
+}
diff --git a/group18/935542673/Coding/src/com/ikook/basic_data_structure/README.md b/group18/935542673/Coding/src/com/ikook/basic_data_structure/README.md
new file mode 100644
index 0000000000..a565fb7148
--- /dev/null
+++ b/group18/935542673/Coding/src/com/ikook/basic_data_structure/README.md
@@ -0,0 +1,83 @@
+##  2017编程提高社群作业：实现基本的数据结构(2017.2.19)
+
+1. 实现了ArrayList、LinkedList、Queue(依靠LinkedList实现)、Stack(依靠ArrayList实现)
+
+   1.1  ArrayList实现了一下方法：
+
+   ```
+    （1）add(Object): 添加元素到集合；
+    （2）add(int, Object): 添加元素到集合的指定位置；
+    （3）size(): 返回集合的大小，类型为 int；
+    （4）isEmpty(): 判断集合是否为空，类型为 boolean；
+    （5）get(int): 获取集合指定位置的元素；
+    （6）remove(int): 删除指定位置的对象；
+    （7）remove(Object): 删除指定的对象；
+    （8）set(int, Object): 更改集合中指定位置的元素，并返回原来的对象；
+    （9）iterator(): 返回一个迭代器的实现类。
+   ```
+
+   1.2  LinkedList实现了一下方法：
+
+   ```
+    （1）addFirst(Object): 在链表头部插入新的元素；
+    （2）addLast(Object): 在链表尾部插入新的元素；
+    （3）add(Object): 在链表中插入新的元素；
+    （4）add(int, Object): 在链表指定位置插入新的元素；
+    （5）size(): 返回链表的大小，类型为 int；
+    （6）isEmpty(): 判断链表是否为空，类型为 boolean；
+    （7）getFirst(): 获取链表头部的元素；
+    （8）getLast():  获取链表尾部的元素；
+    （9）get(int): 获取链表指定位置的元素；
+    （10）set(int, Object): 更改链表中指定位置的元素，并返回原来的对象。
+    （11）removeFirst(): 删除链表头部的元素；
+    （12）removeLast(int):  删除链表尾部的元素；
+    （13）remove(Object): 删除指定元素；
+    （14）remove(int): 删除指定位置的元素；
+    （15）iterator(): 返回一个迭代器的实现类。         
+   ```
+
+   1.3  Queue实现了一下方法：
+
+   ```
+    （1）enQueue(Object): 入队操作；
+    （2）deQueue(): 出队操作；
+    （3）size(): 返回队列的长度；
+    （4）isEmpty(): 判断队列是否为空。
+   ```
+
+   1.4  Stack实现了一下方法：
+
+   ```
+    （1）push(Object)：入栈操作；
+    （2）pop()：出栈操作；
+    （3）getTop()：获取栈顶元素；
+    （4）isEmpty()：判断栈是否为空；
+    （5）size()：获取栈的深度。
+   ```
+   ​
+
+2. 实现了BinarySearchTree、Iterator接口
+
+   2.1  BinarySearchTree实现了一下方法：
+
+   ```
+     （1）insert(int)：插入操作；
+     （2）find(int)：查找操作；
+     （3）delete(int)：删除操作；
+     （4）inorderTraverse(Node)：遍历操作，采用中序遍历。
+   ```
+
+   2.2  Iterator定义了一下方法：
+
+   ```
+     （1）hasNext()：判断是否有元素没有被遍历；
+     （2）next()：返回游标当前位置的元素并将游标移动到下一个位置；
+     （3）remove()：删除游标左边的元素，在执行完 next 之后该操作只能执行一次。
+   ```
+   ​
+
+3. 对应以上类做了单元测试
+
+    说明：由于作业以实现基本的数据结构为主，则在实现单元测试时，只对正常情况进行了测试，一些异常情况并进行编写测试用例。
+
+   点击查看: [unit test](https://github.com/china-kook/coding2017/tree/master/group18/935542673/Coding/junit/com/ikook/basic_data_structure)
\ No newline at end of file
diff --git "a/group18/935542673/Datum/\345\205\263\344\272\216.metadata\347\233\256\345\275\225\345\222\214.gitignore\344\275\277\347\224\250\347\232\204\351\227\256\351\242\230.docx" "b/group18/935542673/Datum/\345\205\263\344\272\216.metadata\347\233\256\345\275\225\345\222\214.gitignore\344\275\277\347\224\250\347\232\204\351\227\256\351\242\230.docx"
new file mode 100644
index 0000000000..d169fd91bf
Binary files /dev/null and "b/group18/935542673/Datum/\345\205\263\344\272\216.metadata\347\233\256\345\275\225\345\222\214.gitignore\344\275\277\347\224\250\347\232\204\351\227\256\351\242\230.docx" differ
diff --git a/group20/.gitignore b/group20/.gitignore
new file mode 100644
index 0000000000..389e717ef0
--- /dev/null
+++ b/group20/.gitignore
@@ -0,0 +1,43 @@
+# Java class files
+*.class
+
+# Generated files
+bin/
+gen/
+out/
+target/
+
+# Gradle files
+.gradle/
+build/
+
+# Local configuration file (sdk path, etc)
+local.properties
+
+# Proguard folder generated by Eclipse
+proguard/
+
+# Log Files
+*.log
+
+# Intellij
+*.iml
+.idea/workspace.xml
+.idea/tasks.xml
+.idea/gradle.xml
+.idea/dictionaries
+.idea/libraries
+.idea
+
+# Project generated files
+.project
+.settings
+.classpath
+.com
+.metadata
+
+# Mac file
+.DS_Store
+
+# Do not ignore .jar file
+!*.jar
diff --git a/group20/1040154728/1040154728Learning/src/SinglyLinkedList/LinkedList0.java b/group20/1040154728/1040154728Learning/src/SinglyLinkedList/LinkedList0.java
new file mode 100644
index 0000000000..7cdf1e7f26
--- /dev/null
+++ b/group20/1040154728/1040154728Learning/src/SinglyLinkedList/LinkedList0.java
@@ -0,0 +1,75 @@
+package SinglyLinkedList;
+
+/**
+ * Created by Honoka on 2/16/2017.
+ */
+public class LinkedList0 {
+    //Node class represents a list node
+    private class Node
+    {
+        String value;
+        Node next;
+        /**
+         * Constructor
+         * @param val The element to store in this node.
+         * @param n The reference to the next node.
+         */
+        Node (String val, Node n)
+        {
+            value = val;
+            next = n;
+        }
+
+        /**
+         * Constructor
+         * @param val The element to store in this node.
+         */
+        Node(String val)
+        {
+            value = val;
+            next = null;
+        }
+    }
+    //Reference to the first node in the list
+    private Node first = null;
+    /**
+     * Constructor
+     * Builds a linked list
+     */
+    public LinkedList0()
+    {
+        //test
+        first = new Node("Apple");
+        first.next = new Node("Peach");
+        first.next.next = new Node("Kiwi");
+        first = new Node("Blueberry",first);
+
+        //Using an array to add elements into list
+        String[] fruits = {"Banana", "Cherry"};
+        for (String f : fruits)
+        {
+            first = new Node(f, first);
+        }
+    }
+    /**
+     * print method
+     * traverses the list and prints all elements
+     */
+    public void print()
+    {
+        Node reference = first;
+        while(reference != null)
+        {
+            System.out.println(reference.value + " ");
+            reference = reference.next;
+        }
+    }
+
+    //Main test method
+    public static void main(String [] args)
+    {
+        LinkedList0 list = new LinkedList0();
+        System.out.println("The elements inside this list are ");
+        list.print();
+    }
+}
diff --git a/group20/1040154728/1040154728Learning/src/SinglyLinkedList2/LinkedList1.java b/group20/1040154728/1040154728Learning/src/SinglyLinkedList2/LinkedList1.java
new file mode 100644
index 0000000000..8c93bbc640
--- /dev/null
+++ b/group20/1040154728/1040154728Learning/src/SinglyLinkedList2/LinkedList1.java
@@ -0,0 +1,242 @@
+package SinglyLinkedList2;
+/**
+ * Created by Honoka on 2/16/2017.
+ */
+public class LinkedList1 {
+    private class Node
+    {
+        String value;
+        Node next;
+
+        Node(String val, Node n)
+        {
+            value = val;
+            next = n;
+        }
+        Node(String val)
+        {
+            //Call the other(daddy(or sister(whatever))) constructor.
+            this(val, null);
+        }
+    }
+
+    private Node first; // head
+    private Node last;  //the last element in list
+
+    public LinkedList1()
+    {
+        first = null;
+        last = null;
+    }
+
+    /**This method checks to see
+     * if the list is empty
+     * @return true if list is empty
+     */
+    public boolean isEmpty()
+    {
+        return first == null;
+    }
+
+    /**
+     * size method returns the length of the list
+     * @return The number of the elements in the list
+     */
+    public int size()
+    {
+        int counter = 0;
+        Node p = first;
+        while (p != null)
+        {
+            counter ++;
+            p = p.next;
+        }
+        return counter;
+    }
+
+    /**
+     * add method add an element to the end of the list
+     * @param element the value to add
+     */
+    public void add(String element)
+    {
+        if (isEmpty())
+        {
+            //Obviously, add the element to the first position in the list
+            first = new Node(element);
+            last = first;
+        }
+        else
+        {
+            //add to the end of existing list
+            last.next = new Node(element);
+            last = last.next;
+        }
+    }
+
+    /**
+     * add method, or you might call it insert method since it can
+     * add element to a specific position
+     * @param index The position at which to add the element
+     * @param element you should know what is this
+     */
+    public void add (int index, String element)
+    {
+        if (index < 0 || index > size())
+        {
+            String message = String.valueOf(index);
+            throw new IndexOutOfBoundsException(message);
+        }
+
+        //index is at least 0
+        if(index == 0)
+        {
+            //new element add to the head
+            first = new Node(element, first);
+            if (last == null)
+            {
+                last = first;
+            }
+            return;
+        }
+        //set a reference predecessor to point to the node that
+        //will be the predecessor of the new node
+        Node predecessor = first;
+        for (int k = 1; k <= index - 1; k++)
+        {
+            predecessor = predecessor.next;
+        }
+        //Splice in a node containing the new element
+        predecessor.next = new Node(element, predecessor.next);
+
+        //if there is a new last element
+        if(predecessor.next.next == null)
+            last = predecessor.next;
+    }
+
+    /**
+     * toString method, like print method, hopefully it will display the contents of the list
+     * @return say something I'm giving up on you(
+     */
+    public String toString()
+    {
+        StringBuffer strBuilder = new StringBuffer();
+        //Use p to walk down the list
+        Node p = first;
+        while (p != null)
+        {
+            strBuilder.append(p.value + "\n");
+            p = p.next;
+        }
+        return strBuilder.toString();
+    }
+
+    /**
+     * remove method removes the element with the position you want
+     * @param index the position of the element that you want to remove
+     * @return the removed element
+     */
+    public String remove (int index)
+    {
+        /* Index out of bounds */
+        if (index < 0 || index >= size())
+        {
+            String message = String.valueOf(index);
+            throw new IndexOutOfBoundsException(message);
+        }
+        String element = null;
+        if(index == 0)
+        {
+            //Removal of first item in the list
+            element = first.value;
+            first = first.next;
+            if (first == null)
+            {
+                last = null;
+            }
+        }
+        else
+        {
+            /* find the predecessor of the element to be removed */
+            Node predecessor = first;
+
+            /* Move predecessor forward index - 1 times */
+            for (int k = 1; k <= index - 1; k++)
+            {
+                predecessor = predecessor.next;
+                /* Store the value to return */
+                element = predecessor.next.value;
+                /* Route link around the node to be removed */
+                predecessor.next = predecessor.next.next;
+                /* Check if predecessor is now last */
+                if(predecessor.next == null)
+                {
+                    last = predecessor;
+                }
+            }
+        }
+        return element;
+    }
+
+    /**
+     * The remove method removes an element
+     * @param element the element to remove
+     * @return true if the remove succeeded
+     */
+    public boolean remove(String element)
+    {
+        if (isEmpty())
+        {
+            return false;
+        }
+
+        if (element.equals(first.value))
+        {
+            //Removal of first element in the list
+            first = first.next;
+            if(first == null)
+            {
+                last = null;
+            }
+            return true;
+        }
+
+        /* Find the predecessor of the element to remove */
+        Node predecessor = first;
+        while (predecessor.next != null &&
+                !predecessor.next.value.equals(element))
+        {
+            predecessor = predecessor.next;
+        }
+        /* predecessor.next == null OR predecessor.next.value is element */
+        if(predecessor.next == null)
+        {
+            return false;
+        }
+        /* predecessor.next.value is element */
+        predecessor.next = predecessor.next.next;
+
+        /* check if predecessor is now last */
+        if (predecessor.next == null)
+        {
+            last = predecessor;
+        }
+        return true;
+    }
+
+    public static void main (String [] args)
+    {
+        LinkedList1 testList = new LinkedList1();
+        testList.add("Apple");
+        testList.add("Banana");
+        testList.add(0,"Blueberry");
+        testList.add(2,"Cherry");
+        testList.add(4,"Peach");
+        System.out.println("The list has : ");
+        System.out.println(testList);
+        testList.remove("Cherry");
+        testList.remove(2);
+        System.out.println("The list has : ");
+        System.out.println(testList);
+    }
+}
diff --git a/group20/1040154728/1040154728Learning/src/honoka.md b/group20/1040154728/1040154728Learning/src/honoka.md
new file mode 100644
index 0000000000..ff92a7f300
--- /dev/null
+++ b/group20/1040154728/1040154728Learning/src/honoka.md
@@ -0,0 +1,5 @@
+##Honoka's blog link is down below.
+
+https://honokabiu.github.io/
+
+Super simple...
diff --git a/group20/1107837739/1107837739Learning/lib/hamcrest-core-1.3.jar b/group20/1107837739/1107837739Learning/lib/hamcrest-core-1.3.jar
new file mode 100644
index 0000000000..9d5fe16e3d
Binary files /dev/null and b/group20/1107837739/1107837739Learning/lib/hamcrest-core-1.3.jar differ
diff --git a/group20/1107837739/1107837739Learning/lib/junit-4.12.jar b/group20/1107837739/1107837739Learning/lib/junit-4.12.jar
new file mode 100644
index 0000000000..3a7fc266c3
Binary files /dev/null and b/group20/1107837739/1107837739Learning/lib/junit-4.12.jar differ
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/Main.java b/group20/1107837739/1107837739Learning/src/org/korben/Main.java
new file mode 100644
index 0000000000..671f67a9a7
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/Main.java
@@ -0,0 +1,8 @@
+package org.korben;
+
+public class Main {
+
+    public static void main(String[] args) {
+        System.out.println("Hello Korben : )");
+    }
+}
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/list/KArrayList.java b/group20/1107837739/1107837739Learning/src/org/korben/list/KArrayList.java
new file mode 100644
index 0000000000..4d6236b537
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/list/KArrayList.java
@@ -0,0 +1,169 @@
+package org.korben.list;
+
+import java.util.Objects;
+
+/**
+ * Korben's ArrayList
+ *
+ * Created by Korben on 18/02/2017.
+ */
+public class KArrayList<T> implements KList<T> {
+
+    private int size;
+    private Object[] dataArray = new Object[0];
+
+    @Override
+    public int size() {
+        return this.size;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return this.size == 0;
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        for (Object obj : dataArray) {
+            if (Objects.equals(obj, o)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Object[] toArray() {
+        Object[] array = new Object[size];
+        System.arraycopy(dataArray, 0, array, 0, size);
+        return array;
+    }
+
+    @Override
+    public boolean add(T o) {
+        ensureCapacity(size + 1);
+        dataArray[size] = o;
+        size++;
+        return true;
+    }
+
+    @Override
+    public boolean remove(T o) {
+        int index = indexOf(o);
+        if (index < 0) {
+            return false;
+        }
+
+        System.arraycopy(dataArray, index + 1, dataArray, index, size - 1 - index);
+        dataArray[size - 1] = null;
+
+        size--;
+
+        return true;
+    }
+
+    @Override
+    public void clear() {
+        for (int i = 0; i < size; i++) {
+            dataArray[i] = null;
+        }
+        size = 0;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T get(int index) {
+        if (index < -1 || index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        return (T) dataArray[index];
+    }
+
+    @Override
+    public T set(int index, T element) {
+        if (index < -1 || index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        dataArray[index] = element;
+
+        return element;
+    }
+
+    @Override
+    public void add(int index, T element) {
+        if (index < -1 || index > size) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        ensureCapacity(size + 1);
+
+        System.arraycopy(dataArray, index, dataArray, index + 1, size - index);
+
+        dataArray[index] = element;
+        size++;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T remove(int index) {
+        if (index < -1 || index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        T removeData = (T) dataArray[index];
+        System.arraycopy(dataArray, index + 1, dataArray, index, size - 1 - index);
+        dataArray[size - 1] = null;
+        size--;
+        return removeData;
+    }
+
+    @Override
+    public int indexOf(T o) {
+        for (int i = 0; i < size; i++) {
+            if (Objects.equals(o, dataArray[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public KIterator<T> iterator() {
+        return new ArrayListIterator(this);
+    }
+
+    private void ensureCapacity(int minCapacity) {
+        if (minCapacity > dataArray.length) {
+            int newCapacity = Math.max(minCapacity, dataArray.length * 2);
+            Object[] newDataArray = new Object[newCapacity];
+            System.arraycopy(dataArray, 0, newDataArray, 0, dataArray.length);
+
+            dataArray = newDataArray;
+        }
+    }
+
+    private class ArrayListIterator implements KIterator<T> {
+        private int position;
+        private KArrayList<T> list;
+
+        ArrayListIterator(KArrayList<T> list) {
+            this.list = list;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return position < list.size();
+        }
+
+        @Override
+        public T next() {
+            if (hasNext()) {
+                return list.get(position++);
+            }
+            return null;
+        }
+    }
+}
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/list/KIterator.java b/group20/1107837739/1107837739Learning/src/org/korben/list/KIterator.java
new file mode 100644
index 0000000000..c29e566178
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/list/KIterator.java
@@ -0,0 +1,10 @@
+package org.korben.list;
+
+/**
+ * Created by Korben on 24/02/2017.
+ */
+public interface KIterator<T> {
+    boolean hasNext();
+
+    T next();
+}
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/list/KLinkedList.java b/group20/1107837739/1107837739Learning/src/org/korben/list/KLinkedList.java
new file mode 100644
index 0000000000..e14efad19c
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/list/KLinkedList.java
@@ -0,0 +1,172 @@
+package org.korben.list;
+
+import java.util.Objects;
+
+/**
+ * Korben's LinkedList
+ *
+ * Created by Korben on 18/02/2017.
+ */
+public class KLinkedList<T> implements KList<T> {
+
+    private int size;
+
+    private Node<T> head;
+
+    private Node<T> last;
+
+    public KLinkedList() {
+        this.head = new Node<>(null);
+    }
+
+    @Override
+    public int size() {
+        return this.size;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return this.size == 0;
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        Node node = this.head;
+        while (node.next != null) {
+            node = node.next;
+            if (Objects.equals(node.data, o)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public Object[] toArray() {
+        return new Object[0];
+    }
+
+    @Override
+    public boolean add(T o) {
+        if (this.last == null) {
+            this.last = new Node<>(o);
+            this.last.pre = this.head;
+            this.head.next = this.last;
+        } else {
+            Node<T> oldLast = this.last;
+            this.last = new Node<>(o);
+            this.last.pre = oldLast;
+            oldLast.next = this.last;
+        }
+        this.size++;
+        return true;
+    }
+
+    @Override
+    public boolean remove(T o) {
+        Node node = this.head;
+        while (node.next != null) {
+            node = node.next;
+            if (Objects.equals(node.data, o)) {
+                node.pre.next = node.next;
+                if (node.next != null) {
+                    node.next.pre = node.pre;
+                }
+                this.size--;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void clear() {
+        this.head.next = null;
+        this.last = null;
+
+        this.size = 0;
+    }
+
+    @Override
+    public T get(int index) {
+        return getNode(index).data;
+    }
+
+    @Override
+    public T set(int index, T element) {
+        Node<T> node = getNode(index);
+        node.data = element;
+        return element;
+    }
+
+    @Override
+    public void add(int index, T element) {
+        Node<T> node = this.head;
+        for (int i = 0; i <= index; i++) {
+            node = node.next;
+        }
+        Node<T> pre = node.pre;
+        Node<T> newNode = new Node<>(element);
+        pre.next = newNode;
+        newNode.pre = pre;
+        newNode.next = node;
+        node.pre = newNode;
+
+        this.size++;
+    }
+
+    @Override
+    public T remove(int index) {
+        Node<T> node = getNode(index);
+        Node<T> pre = node.pre;
+        Node<T> next = node.next;
+        pre.next = next;
+        if (next != null) {
+            next.pre = pre;
+        }
+
+        this.size--;
+        return node.data;
+    }
+
+    @Override
+    public int indexOf(T o) {
+        Node node = this.head;
+        int index = 0;
+        while (node.next != null) {
+            node = node.next;
+            if (Objects.equals(node.data, o)) {
+                return index;
+            }
+            index++;
+        }
+        return -1;
+    }
+
+    @Override
+    public KIterator<T> iterator() {
+        throw new IllegalStateException("方法未实现");
+    }
+
+    private Node<T> getNode(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        Node<T> node = this.head;
+        for (int i = 0; i <= index; i++) {
+            node = node.next;
+        }
+        return node;
+    }
+
+    private static class Node<T> {
+        T data;
+        Node<T> pre;
+        Node<T> next;
+
+        Node(T data) {
+            this.data = data;
+        }
+    }
+}
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/list/KList.java b/group20/1107837739/1107837739Learning/src/org/korben/list/KList.java
new file mode 100644
index 0000000000..e5d33b984b
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/list/KList.java
@@ -0,0 +1,35 @@
+package org.korben.list;
+
+/**
+ * Korben's List
+ *
+ * Created by Korben on 18/02/2017.
+ */
+public interface KList<T> {
+
+    int size();
+
+    boolean isEmpty();
+
+    boolean contains(Object o);
+
+    Object[] toArray();
+
+    boolean add(T o);
+
+    boolean remove(T o);
+
+    void clear();
+
+    T get(int index);
+
+    T set(int index, T element);
+
+    void add(int index, T element);
+
+    T remove(int index);
+
+    int indexOf(T o);
+
+    KIterator<T> iterator();
+}
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/list/KListIteratorTest.java b/group20/1107837739/1107837739Learning/src/org/korben/list/KListIteratorTest.java
new file mode 100644
index 0000000000..994538732f
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/list/KListIteratorTest.java
@@ -0,0 +1,36 @@
+package org.korben.list;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Iterator测试
+ *
+ * Created by Korben on 24/02/2017.
+ */
+public class KListIteratorTest {
+
+    private KList<Integer> list;
+
+    @Before
+    public void init() {
+        this.list = new KArrayList<>();
+
+        for (int i = 0; i < 5; i++) {
+            list.add(i);
+        }
+    }
+
+    @Test
+    public void testIterator() {
+        KIterator<Integer> iterator = list.iterator();
+        Assert.assertTrue(iterator.hasNext());
+        int count = 0;
+        while (iterator.hasNext()) {
+            int value = iterator.next();
+            Assert.assertEquals(count, value);
+            count++;
+        }
+    }
+}
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/list/KListTest.java b/group20/1107837739/1107837739Learning/src/org/korben/list/KListTest.java
new file mode 100644
index 0000000000..ed3055b74e
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/list/KListTest.java
@@ -0,0 +1,142 @@
+package org.korben.list;
+
+import java.util.Objects;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * KList测试
+ *
+ * Created by Korben on 18/02/2017.
+ */
+public class KListTest {
+
+    private KList<Integer> list;
+
+    private int initTestSize;
+
+    @Before
+    public void init() {
+        // 测试KArrayList
+        //list = new KArrayList<>();
+
+        // 测试KLinkedList
+        list = new KLinkedList<>();
+
+        initTestSize = 5;
+
+        for (int i = 0; i < initTestSize; i++) {
+            list.add(i);
+        }
+    }
+
+    @Test
+    public void size() throws Exception {
+        Assert.assertEquals(initTestSize, list.size());
+    }
+
+    @Test
+    public void isEmpty() throws Exception {
+        Assert.assertFalse(list.isEmpty());
+
+        KList<String> list = new KArrayList<>();
+        Assert.assertTrue(list.isEmpty());
+    }
+
+    @Test
+    public void contains() throws Exception {
+        Assert.assertTrue(list.contains(1));
+        Assert.assertFalse(list.contains(5));
+    }
+
+    @Test
+    public void toArray() throws Exception {
+        //Object[] array = list.toArray();
+        //Assert.assertEquals(initTestSize, array.length);
+        //for (int i = 0; i < array.length; i++) {
+        //    Assert.assertEquals(i, array[i]);
+        //}
+    }
+
+    @Test
+    public void add() throws Exception {
+        Assert.assertTrue(list.add(6));
+        Assert.assertTrue(list.contains(6));
+        Assert.assertEquals(initTestSize + 1, list.size());
+    }
+
+    @Test
+    public void remove() throws Exception {
+        Assert.assertEquals(0, list.remove(0).intValue());
+        Assert.assertEquals(initTestSize - 1, list.size());
+        Assert.assertFalse(list.contains(0));
+    }
+
+    @Test
+    public void clear() throws Exception {
+        list.clear();
+        Assert.assertTrue(list.isEmpty());
+        Assert.assertTrue(list.size() == 0);
+    }
+
+    @Test
+    public void get() throws Exception {
+        for (int i = 0; i < initTestSize; i++) {
+            Assert.assertTrue(Objects.equals(i, list.get(i)));
+        }
+    }
+
+    @Test
+    public void set() throws Exception {
+        for (int i = 0; i < initTestSize; i++) {
+            list.set(i, initTestSize);
+            Assert.assertEquals(initTestSize, list.get(i).intValue());
+        }
+    }
+
+    @Test
+    public void addByIndex() throws Exception {
+        // test add by first index
+        list.add(0, 6);
+        Assert.assertEquals(initTestSize + 1, list.size());
+        Assert.assertEquals(6, list.get(0).intValue());
+        for (int i = 0; i < initTestSize; i++) {
+            Assert.assertEquals(i, list.get(i + 1).intValue());
+        }
+
+        // test add by last index
+        init();
+        list.add(initTestSize - 1, 6);
+        Assert.assertEquals(initTestSize + 1, list.size());
+        Assert.assertEquals(initTestSize - 1, list.get(initTestSize).intValue());
+        Assert.assertEquals(6, list.get(initTestSize - 1).intValue());
+        for (int i = 0; i < initTestSize - 1; i++) {
+            Assert.assertEquals(i, list.get(i).intValue());
+        }
+
+        // test add by middle index
+        init();
+        list.add(3, 90);
+        Assert.assertEquals(initTestSize + 1, list.size());
+        Assert.assertEquals(list.get(0).intValue(), 0);
+        Assert.assertEquals(list.get(1).intValue(), 1);
+        Assert.assertEquals(list.get(2).intValue(), 2);
+        Assert.assertEquals(list.get(3).intValue(), 90);
+        Assert.assertEquals(list.get(4).intValue(), 3);
+        Assert.assertEquals(list.get(5).intValue(), 4);
+    }
+
+    @Test
+    public void removeByObject() throws Exception {
+        Assert.assertTrue(list.remove(new Integer(3)));
+        Assert.assertEquals(initTestSize - 1, list.size());
+    }
+
+    @Test
+    public void indexOf() throws Exception {
+        for (int i = 0; i < initTestSize; i++) {
+            Assert.assertEquals(i, list.indexOf(i));
+        }
+    }
+}
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/queue/KArrayQueue.java b/group20/1107837739/1107837739Learning/src/org/korben/queue/KArrayQueue.java
new file mode 100644
index 0000000000..3e975058f4
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/queue/KArrayQueue.java
@@ -0,0 +1,111 @@
+package org.korben.queue;
+
+import java.util.NoSuchElementException;
+
+/**
+ * Created by Korben on 18/02/2017.
+ */
+public class KArrayQueue<T> implements KQueue<T> {
+
+    private int size;
+    private Object[] dataArray = {};
+    private int front = 0;
+    private int end = -1;
+
+    public KArrayQueue() {
+
+    }
+
+    @Override
+    public boolean add(T t) {
+        ensureCapacity(size + 1);
+        dataArray[end + 1] = t;
+        end++;
+        size++;
+        return true;
+    }
+
+    @Override
+    public boolean offer(T t) {
+        ensureCapacity(size + 1);
+        dataArray[end + 1] = t;
+        end++;
+        size++;
+        return true;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T remove() {
+        if (end == -1) {
+            throw new NoSuchElementException();
+        }
+        T value = (T) dataArray[front];
+        dataArray[front] = null;
+        size--;
+        front++;
+        if (front == dataArray.length) {
+            front = 0;
+        }
+        if (size == 0) {
+            end = -1;
+        }
+
+        return value;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T poll() {
+        if (end == -1) {
+            return null;
+        }
+        T value = (T) dataArray[front];
+        dataArray[front] = null;
+        size--;
+        front++;
+        if (front == dataArray.length) {
+            front = 0;
+        }
+
+        return value;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T element() {
+        if (end == -1) {
+            throw new NoSuchElementException();
+        }
+        return (T) dataArray[front];
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T peek() {
+        if (end == -1) {
+            return null;
+        }
+        return (T) dataArray[front];
+    }
+
+    private void ensureCapacity(int minSize) {
+        if (end == -1) {
+            dataArray = new Object[8];
+        } else if (minSize >= dataArray.length) {
+            int newLength = dataArray.length * 2;
+            Object[] newDataArray = new Object[newLength];
+            if (front != 0) {
+                System.arraycopy(dataArray, front,
+                        newDataArray, newLength - dataArray.length + front,
+                        dataArray.length - 1 - front);
+
+                front += newLength - dataArray.length;
+            } else {
+                System.arraycopy(dataArray, front, newDataArray, front, size);
+            }
+
+            dataArray = newDataArray;
+        }
+    }
+}
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/queue/KQueue.java b/group20/1107837739/1107837739Learning/src/org/korben/queue/KQueue.java
new file mode 100644
index 0000000000..14763efd99
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/queue/KQueue.java
@@ -0,0 +1,20 @@
+package org.korben.queue;
+
+/**
+ * Korben's Queue Interface
+ *
+ * Created by Korben on 18/02/2017.
+ */
+public interface KQueue<T> {
+    boolean add(T t);
+
+    boolean offer(T t);
+
+    T remove();
+
+    T poll();
+
+    T element();
+
+    T peek();
+}
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/queue/KQueueTest.java b/group20/1107837739/1107837739Learning/src/org/korben/queue/KQueueTest.java
new file mode 100644
index 0000000000..3d9557748f
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/queue/KQueueTest.java
@@ -0,0 +1,78 @@
+package org.korben.queue;
+
+import java.util.NoSuchElementException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * KQueue Test
+ *
+ * Created by Korben on 19/02/2017.
+ */
+public class KQueueTest {
+    private KQueue<Integer> queue;
+
+    @Before
+    public void init() {
+        queue = new KArrayQueue<>();
+    }
+
+    @Test
+    public void add() throws Exception {
+        for (int i = 0; i < 5; i++) {
+            queue.add(i);
+        }
+    }
+
+    @Test
+    public void offer() throws Exception {
+        for (int i = 0; i < 100; i++) {
+            queue.offer(i);
+        }
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void remove() throws Exception {
+        for (int i = 0; i < 9; i++) {
+            queue.add(i);
+        }
+        for (int i = 0; i < 9; i++) {
+            Assert.assertEquals(i, queue.remove().intValue());
+        }
+        queue.remove();
+    }
+
+    @Test
+    public void poll() throws Exception {
+        for (int i = 0; i < 5; i++) {
+            queue.add(i);
+        }
+        for (int i = 0; i < 5; i++) {
+            Assert.assertEquals(i, queue.poll().intValue());
+        }
+        Assert.assertNull(queue.poll());
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void element() throws Exception {
+        for (int i = 0; i < 5; i++) {
+            queue.add(i);
+            Assert.assertEquals(queue.element().intValue(), 0);
+        }
+        init();
+
+        queue.element();
+    }
+
+    @Test
+    public void peek() throws Exception {
+        for (int i = 0; i < 5; i++) {
+            queue.add(i);
+            Assert.assertEquals(queue.peek().intValue(), 0);
+        }
+        init();
+
+        Assert.assertNull(queue.peek());
+    }
+}
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/stack/KStack.java b/group20/1107837739/1107837739Learning/src/org/korben/stack/KStack.java
new file mode 100644
index 0000000000..8dc39e4efd
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/stack/KStack.java
@@ -0,0 +1,72 @@
+package org.korben.stack;
+
+import java.util.EmptyStackException;
+import java.util.Objects;
+
+/**
+ * Korben's Stack
+ *
+ * Created by Korben on 18/02/2017.
+ */
+public class KStack<T> {
+
+    private int size;
+    private Object[] dataArray = {};
+
+    public KStack() {
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public T push(T item) {
+        ensureCapacity(size + 1);
+        this.dataArray[size] = item;
+        this.size++;
+        return item;
+    }
+
+    @SuppressWarnings("unchecked")
+    public T pop() {
+        if (size == 0) {
+            throw new EmptyStackException();
+        }
+
+        T data = (T) this.dataArray[size - 1];
+        this.dataArray[size - 1] = null;
+        this.size--;
+        return data;
+    }
+
+    @SuppressWarnings("unchecked")
+    public T peek() {
+        if (size == 0) {
+            throw new EmptyStackException();
+        }
+        return (T) dataArray[size - 1];
+    }
+
+    public boolean empty() {
+        return size == 0;
+    }
+
+    public synchronized int search(Object o) {
+        for (int i = 0; i < size; i++) {
+            if (Objects.equals(o, dataArray[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private void ensureCapacity(int minCapacity) {
+        if (minCapacity > dataArray.length) {
+            int newCapacity = Math.max(minCapacity, dataArray.length * 2);
+            Object[] newDataArray = new Object[newCapacity];
+            System.arraycopy(dataArray, 0, newDataArray, 0, dataArray.length);
+
+            this.dataArray = newDataArray;
+        }
+    }
+}
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/stack/KStackTest.java b/group20/1107837739/1107837739Learning/src/org/korben/stack/KStackTest.java
new file mode 100644
index 0000000000..e3f173eb3f
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/stack/KStackTest.java
@@ -0,0 +1,71 @@
+package org.korben.stack;
+
+import java.util.EmptyStackException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * KStack测试
+ *
+ * Created by Korben on 18/02/2017.
+ */
+public class KStackTest {
+    private KStack<Integer> stack;
+    private int initTestSize;
+
+    @Before
+    public void init() {
+        stack = new KStack<>();
+        initTestSize = 5;
+
+        for (int i = 0; i < initTestSize; i++) {
+            stack.push(i);
+        }
+    }
+
+    @Test
+    public void size() throws Exception {
+        Assert.assertEquals(initTestSize, stack.size());
+    }
+
+    @Test
+    public void push() throws Exception {
+        stack.push(9);
+    }
+
+    @Test(expected = EmptyStackException.class)
+    public void pop() throws Exception {
+        for (int i = 0; i < initTestSize; i++) {
+            Integer value = stack.pop();
+            Assert.assertEquals(value.intValue(), initTestSize - 1 - i);
+        }
+
+        stack.pop();
+    }
+
+    @Test(expected = EmptyStackException.class)
+    public void peek() throws Exception {
+        Assert.assertEquals(initTestSize - 1, stack.peek().intValue());
+        for (int i = 0; i < initTestSize; i++) {
+            stack.pop();
+        }
+        stack.peek();
+    }
+
+    @Test
+    public void empty() throws Exception {
+        Assert.assertFalse(stack.empty());
+        for (int i = 0; i < initTestSize; i++) {
+            stack.pop();
+        }
+        Assert.assertTrue(stack.empty());
+    }
+
+    @Test
+    public void search() throws Exception {
+        for (int i = 0; i < initTestSize; i++) {
+            Assert.assertEquals(i, stack.search(i));
+        }
+    }
+}
\ No newline at end of file
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/tree/BinaryTreeNode.java b/group20/1107837739/1107837739Learning/src/org/korben/tree/BinaryTreeNode.java
new file mode 100644
index 0000000000..30c613edd0
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/tree/BinaryTreeNode.java
@@ -0,0 +1,127 @@
+package org.korben.tree;
+
+/**
+ * Korben's BinaryTreeNode
+ *
+ * Created by Korben on 21/02/2017.
+ */
+public class BinaryTreeNode<T extends Comparable> {
+
+    private T data;
+    private BinaryTreeNode left;
+    private BinaryTreeNode right;
+    private int size;
+
+    public T getData() {
+        return data;
+    }
+
+    public void setData(T 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;
+    }
+
+    @SuppressWarnings("unchecked")
+    public BinaryTreeNode insert(T data) {
+        if (this.data == null) {
+            this.data = data;
+            return this;
+        }
+        int compareResult = this.data.compareTo(data);
+        if (compareResult > 0) {
+            if (this.left == null) {
+                this.left = new BinaryTreeNode();
+                this.left.data = data;
+                return this.left;
+            } else {
+                return this.left.insert(data);
+            }
+        } else if (compareResult < 0) {
+            if (this.right == null) {
+                this.right = new BinaryTreeNode();
+                this.right.data = data;
+                return this.right;
+            } else {
+                return this.right.insert(data);
+            }
+        } else {
+            return this;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public BinaryTreeNode delete(T data) {
+        BinaryTreeNode treeNode = search(data);
+        if (treeNode == null) {
+            return null;
+        }
+        int compareResult = this.data.compareTo(data);
+        if (compareResult > 0) {
+            return this.left.delete(data);
+        } else if (compareResult < 0) {
+            return this.right.delete(data);
+        } else {
+            if (treeNode.right == null) {
+                if (this.left == null) {
+                    this.data = null;
+                } else {
+                    this.left = this;
+                }
+            } else {
+                this.data = (T) this.right.findMin().data;
+
+                this.right.delete(this.data);
+            }
+        }
+
+        return this;
+    }
+
+    private BinaryTreeNode findMin() {
+        if (this.data == null) {
+            return null;
+        }
+        if (this.left == null) {
+            return this;
+        }
+        return this.left.findMin();
+    }
+
+    @SuppressWarnings("unchecked")
+    public BinaryTreeNode search(T data) {
+        if (this.data == null) {
+            return null;
+        }
+        int compareResult = this.data.compareTo(data);
+        if (compareResult > 0) {
+            if (this.left == null) {
+                return null;
+            } else {
+                return this.left.search(data);
+            }
+        } else if (compareResult < 0) {
+            if (this.right == null) {
+                return null;
+            } else {
+                return this.right.search(data);
+            }
+        } else {
+            return this;
+        }
+    }
+}
\ No newline at end of file
diff --git a/group20/1107837739/1107837739Learning/src/org/korben/tree/BinaryTreeNodeTest.java b/group20/1107837739/1107837739Learning/src/org/korben/tree/BinaryTreeNodeTest.java
new file mode 100644
index 0000000000..a6fb4ed4e9
--- /dev/null
+++ b/group20/1107837739/1107837739Learning/src/org/korben/tree/BinaryTreeNodeTest.java
@@ -0,0 +1,59 @@
+package org.korben.tree;
+
+import org.junit.Assert;
+
+/**
+ * Korben's BinaryTreeNode Test
+ *
+ * Created by Korben on 21/02/2017.
+ */
+public class BinaryTreeNodeTest {
+
+    private BinaryTreeNode<Integer> treeNode;
+
+    @org.junit.Before
+    public void setUp() throws Exception {
+        treeNode = new BinaryTreeNode<>();
+        treeNode.insert(5);
+        treeNode.insert(3);
+        treeNode.insert(7);
+        treeNode.insert(1);
+        treeNode.insert(4);
+        treeNode.insert(2);
+        treeNode.insert(8);
+        treeNode.insert(6);
+    }
+
+    @org.junit.Test
+    public void insert() {
+        Assert.assertEquals(treeNode.getData().intValue(), 5);
+        Assert.assertEquals(treeNode.getLeft().getData(), 3);
+        Assert.assertEquals(treeNode.getRight().getData(), 7);
+        Assert.assertEquals(treeNode.getLeft().getLeft().getData(), 1);
+        Assert.assertEquals(treeNode.getLeft().getRight().getData(), 4);
+        Assert.assertEquals(treeNode.getLeft().getLeft().getRight().getData(), 2);
+        Assert.assertEquals(treeNode.getRight().getRight().getData(), 8);
+        Assert.assertEquals(treeNode.getRight().getLeft().getData(), 6);
+    }
+
+    @org.junit.Test
+    public void delete() throws Exception {
+        treeNode.delete(3);
+        for (int i = 1; i < 9; i++) {
+            if (i != 3) {
+                Assert.assertNotNull(treeNode.search(i));
+            } else {
+                Assert.assertNull(treeNode.search(i));
+            }
+        }
+    }
+
+    @org.junit.Test
+    public void search() throws Exception {
+        for (int i = 1; i < 9; i++) {
+            Assert.assertNotNull(treeNode.search(i));
+        }
+        Assert.assertNull(treeNode.search(0));
+        Assert.assertNull(treeNode.search(9));
+    }
+}
\ No newline at end of file
diff --git a/group20/1107837739/korben.md b/group20/1107837739/korben.md
new file mode 100644
index 0000000000..983f6f47b6
--- /dev/null
+++ b/group20/1107837739/korben.md
@@ -0,0 +1,7 @@
+## Korben's Blog Here
+
+--------
+
+| Blog Title | Date|
+| ---------- | -----------|
+| [初窥计算机程序的运行](http://korben-chy.github.io/2017/02/26/%E5%88%9D%E7%AA%A5%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A8%8B%E5%BA%8F%E7%9A%84%E8%BF%90%E8%A1%8C/) | 2017/02/26 |
diff --git a/group20/286166752/.gitignore b/group20/286166752/.gitignore
new file mode 100644
index 0000000000..d120d1749d
--- /dev/null
+++ b/group20/286166752/.gitignore
@@ -0,0 +1,4 @@
+.idea/
+286166752.iml
+out/
+
diff --git a/group20/286166752/src/wiki/liven/code/dataStructures/ArrayList.java b/group20/286166752/src/wiki/liven/code/dataStructures/ArrayList.java
new file mode 100644
index 0000000000..68444b87a9
--- /dev/null
+++ b/group20/286166752/src/wiki/liven/code/dataStructures/ArrayList.java
@@ -0,0 +1,86 @@
+package wiki.liven.code.dataStructures;
+
+/**
+ * Created by leven on 2017/2/21.
+ */
+public class ArrayList implements List{
+
+    /**
+     * 列表中元素的个数
+     */
+    private int size = 0;
+    private int maxSize = 100;
+    /**
+     * 初始数组
+     */
+    private Object[] elementData = new Object[maxSize];
+
+    /**
+     * 在指定的位置i插入元素O
+     * 插入元素,判断当前列表中元素的个数,
+     * 当size==100,则需要扩张数组
+     * 当size<100,则使用初始数组完成插入操作
+     * 插入操作:
+     *  从最后一个元素开始,往后移动一位,直到到index为止.
+     * @param index
+     * @param o
+     */
+    @Override
+    public void add(int index, Object o) {
+        if (size>=maxSize){
+            Object[] targt = new Object[++maxSize];
+            System.arraycopy(elementData,0,targt,0,maxSize);
+            for (int j = targt.length;j>=index;j--){
+                targt[j-1] = targt[j-2];
+            }
+            targt[index] = o;
+            size++;
+        }else if(size<maxSize){
+            for (int j = elementData.length;j>=index;j--){
+                elementData[j-1] = elementData[j-2];
+            }
+            elementData[index] = o;
+            size++;
+        }
+    }
+
+    /**
+     * 追加元素
+     * @param o
+     */
+    @Override
+    public void add(Object o) {
+        if (size>=maxSize){
+            Object[] targt = new Object[++maxSize];
+            System.arraycopy(elementData,0,targt,0,maxSize);
+            targt[maxSize-1] = o;
+            size++;
+        }else if(size<maxSize){
+            elementData[size-1] = o;
+            size++;
+        }
+    }
+
+    @Override
+    public Object get(int index) {
+        return elementData[index];
+    }
+
+    @Override
+    public Object remove(int index) {
+        Object temp = elementData[index];
+        for (int i = index;i>size-1;i++){
+            elementData[i] = elementData[i+1];
+        }
+        return temp;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+
+
+
+}
diff --git a/group20/286166752/src/wiki/liven/code/dataStructures/LinkedList.java b/group20/286166752/src/wiki/liven/code/dataStructures/LinkedList.java
new file mode 100644
index 0000000000..b2cc5f8668
--- /dev/null
+++ b/group20/286166752/src/wiki/liven/code/dataStructures/LinkedList.java
@@ -0,0 +1,40 @@
+package wiki.liven.code.dataStructures;
+
+/**
+ * Created by leven on 2017/2/21.
+ */
+public class LinkedList implements List{
+
+    private Node head;
+
+    private static class Node{
+        Object data;
+        Node next;
+    }
+
+
+    @Override
+    public void add(int index, Object o) {
+        
+    }
+
+    @Override
+    public void add(Object o) {
+
+    }
+
+    @Override
+    public Object get(int index) {
+        return null;
+    }
+
+    @Override
+    public Object remove(int index) {
+        return null;
+    }
+
+    @Override
+    public int size() {
+        return 0;
+    }
+}
diff --git a/group20/286166752/src/wiki/liven/code/dataStructures/List.java b/group20/286166752/src/wiki/liven/code/dataStructures/List.java
new file mode 100644
index 0000000000..2d1840ef0f
--- /dev/null
+++ b/group20/286166752/src/wiki/liven/code/dataStructures/List.java
@@ -0,0 +1,14 @@
+package wiki.liven.code.dataStructures;
+
+/**
+ * Created by leven on 2017/2/21.
+ */
+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/group20/286166752/src/wiki/liven/code/dataStructures/Queue.java b/group20/286166752/src/wiki/liven/code/dataStructures/Queue.java
new file mode 100644
index 0000000000..b8c8430daa
--- /dev/null
+++ b/group20/286166752/src/wiki/liven/code/dataStructures/Queue.java
@@ -0,0 +1,7 @@
+package wiki.liven.code.dataStructures;
+
+/**
+ * Created by leven on 2017/2/21.
+ */
+public class Queue {
+}
diff --git a/group20/286166752/src/wiki/liven/code/dataStructures/Stack.java b/group20/286166752/src/wiki/liven/code/dataStructures/Stack.java
new file mode 100644
index 0000000000..59cb18c416
--- /dev/null
+++ b/group20/286166752/src/wiki/liven/code/dataStructures/Stack.java
@@ -0,0 +1,7 @@
+package wiki.liven.code.dataStructures;
+
+/**
+ * Created by leven on 2017/2/21.
+ */
+public class Stack {
+}
diff --git a/group20/286166752/src/wiki/liven/code/test/SomeDemos.java b/group20/286166752/src/wiki/liven/code/test/SomeDemos.java
new file mode 100644
index 0000000000..90a74edc35
--- /dev/null
+++ b/group20/286166752/src/wiki/liven/code/test/SomeDemos.java
@@ -0,0 +1,15 @@
+package wiki.liven.code.test;
+
+/**
+ * Created by leven on 2017/2/21.
+ */
+public class SomeDemos {
+
+    public static void main(String[] args){
+        int[] a = new int[10];
+        a[0] = 4;
+        System.out.println(a.length);
+
+    }
+
+}
diff --git a/group20/331798361/assignment1/src/com/coding/basic/ArrayList.java b/group20/331798361/assignment1/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..0d960ee3d8
--- /dev/null
+++ b/group20/331798361/assignment1/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,122 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+public class ArrayList implements List {
+
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[100];
+	
+	public void add(Object o){
+		int n = elementData.length;
+		int i = 0;
+		while (elementData[i] != null) {
+			i++;
+		}
+		if (i < n) {
+			elementData[i] = o;
+		} else {
+			Object[] temp = Arrays.copyOf(elementData, n + 1);
+			temp[n] = o;
+			elementData = temp;
+		}
+		size++;
+	}
+	public void add(int index, Object o){
+		int n = elementData.length;
+		int i = 0;
+		while (elementData[i] != null) {
+			i++;
+		}
+		if (index < 0 || index > i) {
+			System.out.println(index + " is invalid index!");
+			return;
+		}
+		if (i < n) {
+			for (int j = i; j > index; j--) {
+				elementData[j] = elementData[j - 1];
+			}
+			elementData[index] = o;
+		} else {
+			Object[] temp = Arrays.copyOf(elementData, n + 1);
+			for (int j = i; j > index; j--) {
+				temp[j] = temp[j - 1];
+			}
+			temp[index] = o;
+			elementData = temp;
+		}
+		size++;
+	}
+	
+	public Object get(int index){
+		int i = 0;
+		while (elementData[i] != null) {
+			i++;
+		}
+		if (index < 0 || index >= i) {
+			System.out.println(index + " is invalid index!");
+			return null;
+		} else {
+			return elementData[index];
+		}
+	}
+	
+	public Object remove(int index){
+		int i = 0;
+		while (elementData[i] != null) {
+			i++;
+		}
+		if (index < 0 || index >= i) {
+			System.out.println(index + " is invalid index!");
+			return null;
+		}
+		Object result = elementData[index];
+		for (int j = index; j < i; j++) {
+			elementData[j] = elementData[j + 1];
+		}
+		size--;
+		return result;
+	}
+	
+	public int size(){
+		return size;
+	}
+
+	public String toString() {
+		int i = 0;
+		while (elementData[i] != null) {
+			i++;
+		}
+		String result = "";
+		for (int j = 0; j < i - 1; j++) {
+			result += elementData[j].toString() + ", ";
+		}
+		result += elementData[size - 1].toString();
+		return result;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+
+	public static void main(String args[]){
+		ArrayList list1 = new ArrayList();
+		list1.add("a");
+		list1.add("b");
+		list1.add("c");
+		System.out.println(list1.toString());
+		list1.add(5, "d");
+		list1.add(1, "d");
+		System.out.println(list1.toString());
+		list1.add(4, "e");
+		System.out.println(list1.toString());
+		list1.get(5);
+		System.out.println(list1.get(0));
+		list1.remove(2);
+		System.out.println(list1.toString());
+		System.out.println(list1.size());
+	}
+	
+}
diff --git a/group20/331798361/assignment1/src/com/coding/basic/BinaryTreeNode.java b/group20/331798361/assignment1/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..266eff3d56
--- /dev/null
+++ b/group20/331798361/assignment1/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,32 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git a/group20/331798361/assignment1/src/com/coding/basic/Iterator.java b/group20/331798361/assignment1/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..dbe8b9afb2
--- /dev/null
+++ b/group20/331798361/assignment1/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/group20/331798361/assignment1/src/com/coding/basic/LinkedList.java b/group20/331798361/assignment1/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..e029beaeb4
--- /dev/null
+++ b/group20/331798361/assignment1/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,148 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	private int size;
+	
+	public void add(Object o){
+		if (head.data == null) {
+			head.data = o;
+			head.next = null;
+			size++;
+			return;
+		}
+		Node node = new Node(o);
+		Node curr = head;
+		while (curr.next != null) {
+			curr = curr.next;
+		}
+		curr.next = node;
+		size++;
+	}
+	public void add(int index , Object o){
+
+		if (index < 0 || index > size) {
+			System.out.println(index + " is invalid index!");
+			return;
+		}
+		if (head.data == null) {
+			if (index == 0) {
+				head.data = o;
+				head.next = null;
+				size++;
+				return;
+			} else {
+				System.out.println("invalid index!");
+				return;
+			}
+		}
+		Node node = new Node(o);
+		Node curr = head;
+		for (int i = 0; i < index - 1; i++) {
+			curr = curr.next;
+		}
+		Node temp = curr.next;
+		curr.next = node;
+		node.next = temp;
+		size++;
+	}
+	public Object get(int index){
+		if (index < 0 || index > size) {
+			System.out.println(index + " is invalid index!");
+			return null;
+		}
+		Node result = head;
+		for (int i = 0; i < index; i++) {
+			result = result.next;
+		}
+		return result;
+	}
+	public Object remove(int index){
+		if (index < 0 || index > size) {
+			System.out.println(index + " is invalid index!");
+			return null;
+		}
+		Node curr = head;
+		for (int i = 0; i < index - 1; i++) {
+			curr = curr.next;
+		}
+		Node result = curr.next;
+		curr.next = curr.next.next;
+		size--;
+		return result;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		if (head.data == null) {
+			head.data = o;
+			head.next = null;
+			size++;
+			return;
+		}
+		Node temp = head;
+		head = new Node(o);
+		head.next = temp;
+		size++;
+	}
+
+	public void addLast(Object o){
+		if (head.data == null) {
+			head.data = o;
+			head.next = null;
+			size++;
+			return;
+		}
+		Node node = new Node(o);
+		Node curr = head;
+		while (curr.next != null) {
+			curr = curr.next;
+		}
+		curr.next = node;
+		size++;
+	}
+
+	public Object removeFirst(){
+		if (head.data == null) {
+			return null;
+		}
+		Node result = head;
+		head = head.next;
+		size--;
+		return result;
+	}
+
+	public Object removeLast(){
+		if (head.data == null) {
+			return null;
+		}
+		Node curr = head;
+		for (int i = 0; i < size - 1; i++) {
+			curr = curr.next;
+		}
+		Node result = curr.next;
+		curr.next = null;
+		size--;
+		return result;
+	}
+
+	public Iterator iterator(){
+		return null;
+	}
+	
+	
+	private static class Node{
+		Object data;
+		Node next;
+
+		Node(Object o) {
+			data = o;
+			next = null;
+		}
+		
+	}
+}
diff --git a/group20/331798361/assignment1/src/com/coding/basic/List.java b/group20/331798361/assignment1/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..396b1f6416
--- /dev/null
+++ b/group20/331798361/assignment1/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/group20/331798361/assignment1/src/com/coding/basic/Queue.java b/group20/331798361/assignment1/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..c4991a07f5
--- /dev/null
+++ b/group20/331798361/assignment1/src/com/coding/basic/Queue.java
@@ -0,0 +1,30 @@
+package com.coding.basic;
+
+
+public class Queue {
+	private LinkedList list = new LinkedList();
+
+	public void enQueue(Object o){
+		list.add(o);
+	}
+	
+	public Object deQueue(){
+		int length = list.size();
+		if (length == 0) {
+			return null;
+		}
+		return list.removeFirst();
+	}
+	
+	public boolean isEmpty(){
+		if (list.size() == 0) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	
+	public int size(){
+		return list.size();
+	}
+}
diff --git a/group20/331798361/assignment1/src/com/coding/basic/Stack.java b/group20/331798361/assignment1/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..0a48545cea
--- /dev/null
+++ b/group20/331798361/assignment1/src/com/coding/basic/Stack.java
@@ -0,0 +1,37 @@
+package com.coding.basic;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o) {
+		elementData.add(o);
+	}
+	
+	public Object pop(){
+		int length = elementData.size();
+		if (length == 0) {
+			return null;
+		}
+		return elementData.remove(length - 1);
+	}
+	
+	public Object peek(){
+		int length = elementData.size();
+		if (length == 0) {
+			return null;
+		}
+		return elementData.get(length - 1);
+	}
+
+	public boolean isEmpty(){
+		if (elementData.size() != 0) {
+			return false;
+		} else {
+			return true;
+		}
+	}
+
+	public int size(){
+		return elementData.size();
+	}
+}
diff --git a/group20/404130810/src/com/basic/datastructure/ArrayList.java b/group20/404130810/src/com/basic/datastructure/ArrayList.java
new file mode 100644
index 0000000000..86c001b2c1
--- /dev/null
+++ b/group20/404130810/src/com/basic/datastructure/ArrayList.java
@@ -0,0 +1,110 @@
+package com.basic.datastructure;
+
+public class ArrayList implements List {
+
+	private Object[] elementData;
+	private int size;
+
+	private int enableCapacity;
+
+	public ArrayList() {
+		this.enableCapacity = 10;
+		this.elementData = new Object[enableCapacity];
+	}
+
+	@Override
+	public void add(Object o) {
+		growIfNeeded();
+		elementData[size] = o;
+		this.size++;
+	}
+
+	@Override
+	public void add(int index, Object o) {
+		rangeCheckForAdd(index);
+		growIfNeeded();
+
+		Object[] tmpObjects = new Object[elementData.length];
+		System.arraycopy(elementData, 0, tmpObjects, 0, index);
+		tmpObjects[index] = o;
+		System.arraycopy(elementData, index, tmpObjects, index + 1, elementData.length - index - 1);
+
+		elementData = tmpObjects;
+
+		this.size++;
+	}
+
+	@Override
+	public Object get(int index) {
+		if (index > size) {
+			throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+		}
+		return elementData[index];
+	}
+
+	@Override
+	public Object remove(int index) {
+		Object removedObj = this.get(index);
+		rangeCheck(index);
+		Object[] tmpObjects = new Object[elementData.length];
+
+		System.arraycopy(elementData, 0, tmpObjects, 0, index);
+		System.arraycopy(elementData, index + 1, tmpObjects, index, elementData.length - index - 1);
+
+		elementData = tmpObjects;
+
+		return removedObj;
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+
+	@Override
+	public String toString() {
+		for (int i = 0; i < elementData.length; i++) {
+			System.out.print(elementData[i] + ",");
+		}
+		return "";
+	}
+
+	private void rangeCheck(int paramInt) {
+		if ((paramInt < 0) || (paramInt >= size)) {
+			throw new IndexOutOfBoundsException(outOfBoundsMsg(paramInt));
+		}
+	}
+
+	private void rangeCheckForAdd(int paramInt) {
+		if ((paramInt < 0) || (paramInt > size)) {
+			throw new IndexOutOfBoundsException(outOfBoundsMsg(paramInt));
+		}
+	}
+
+	private String outOfBoundsMsg(int paramInt) {
+		return "Index: " + paramInt + ", Size: " + size;
+	}
+
+	private Object[] growIfNeeded() {
+		if (enableCapacity <= this.size) {
+			enableCapacity = enableCapacity * 2;
+			Object[] largerElementData = new Object[enableCapacity];
+			System.arraycopy(elementData, 0, largerElementData, 0, elementData.length);
+			elementData = largerElementData;
+		}
+		return elementData;
+	}
+
+	public static void main(String[] args) {
+		ArrayList list = new ArrayList();
+		for (int i = 0; i <= 11; i++) {
+			list.add(String.valueOf(i));
+		}
+		System.out.println(list.get(11));
+		//list.add(10,"test");
+		//list.get(10);
+		//list.remove(10);
+		//System.out.println(list);
+	}
+
+}
diff --git a/group20/404130810/src/com/basic/datastructure/LinkedList.java b/group20/404130810/src/com/basic/datastructure/LinkedList.java
new file mode 100644
index 0000000000..43ba7ddd59
--- /dev/null
+++ b/group20/404130810/src/com/basic/datastructure/LinkedList.java
@@ -0,0 +1,176 @@
+package com.basic.datastructure;
+
+public class LinkedList implements List {
+	private Node first;
+	private Node last;
+
+	private int size;
+
+	public void add(Object item) {
+		addLast(item);
+	}
+
+	public void add(int index, Object item) {
+		checkRange(index);
+		if (index == 0) {
+			addFirst(item);
+		} else if (index == size) {
+			addLast(item);
+		} else {
+			Node tmpNode = new Node(item);
+			Node preNode = get(index - 1);
+			Node nextNode = get(index + 1);
+			preNode.next = tmpNode;
+			tmpNode.next = nextNode;
+			size ++;
+		}
+	}
+
+	public Node get(int index) {
+		checkRange(index);
+		if(size > 0){
+			int loopTimes = 0;
+			Node p = first;
+			while(index  > loopTimes){
+				p = p.next;
+				loopTimes ++;
+			}
+			return p;
+		}
+
+		return null;
+	}
+
+	public Object remove(int index) {
+		checkRange(index);
+		Node tmpNode = null;
+		if(index == 0){
+			removeFirst();
+		}else if(index == size -1){
+			removeLast();
+		}else{
+			tmpNode = get(index);
+			Node preNode = get(index-1);
+			Node nextNode = get(index + 1);
+			preNode.next = nextNode;
+			size --;
+		}
+		
+		return tmpNode;
+	}
+
+	public int size() {
+		return size;
+	}
+
+	public void addFirst(Object item) {
+		if (size == 0) {
+			first = new Node(item);
+			last = first;
+		} else {
+			Node tmpNode = new Node(item);
+			tmpNode.next = first;
+			first = tmpNode;
+		}
+		size++;
+	}
+
+	public void addLast(Object item) {
+		if (size == 0) {
+			first = new Node(item);
+			last = first;
+		} else {
+			last.next = new Node(item);
+			last = last.next;
+		}
+		size++;
+	}
+
+	public Object removeFirst() {
+		Node tmpNode = first;
+		if(tmpNode == null){
+			last = null;
+		}else if(size == 2){
+			first = last;
+			last = null;
+			size --;
+		}else{
+			first = first.next;
+			size--;
+		}
+		return tmpNode;
+	}
+
+	public Object removeLast() {
+		Node tmpNode = null;
+		if(size == 1){
+			this.removeFirst();
+		}else if(size >0){
+			int index = size - 1;
+			tmpNode = last;
+			get(index - 1).next = null;
+			last = get(index - 1);
+			size --;
+		}
+		return tmpNode;
+	}
+
+	private void checkRange(int index) {
+		if (index > size || index < 0) {
+			throw new IndexOutOfBoundsException("Index: " + index + "Size: " + size);
+		}
+	}
+
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		Node p = first;
+		while (p != null) {
+			sb.append(p.item + "\n");
+			p = p.next;
+		}
+		return sb.toString();
+	}
+
+	private static class Node {
+		private Object item;
+		private Node next;
+		Node(Object item) {
+			this.item = item;
+		}
+	}
+
+	public static void main(String[] args) {
+		
+		/*Test add
+		LinkedList list = new LinkedList();
+		for (int i = 0; i <= 5; i++) {
+			list.add(i);
+		} 
+		list.add(3, "test");
+		System.out.println(list);
+		*/
+		
+		/*Test remove
+		list.remove(3);
+		System.out.println(list);
+		*/
+		
+		/*Test removeLast and removeFirst
+		System.out.println(list);
+		list.removeLast();
+		System.out.println(list);
+		list.removeLast();
+		System.out.println(list);
+		list.removeLast();
+		System.out.println(list);
+		*/
+		
+		/*Test from Java API
+		java.util.LinkedList<String> linkedList = new java.util.LinkedList<String>();
+		linkedList.add("test");
+		linkedList.removeFirst();
+		System.out.println(linkedList);
+		*/
+		
+	}
+}
diff --git a/group20/404130810/src/com/basic/datastructure/List.java b/group20/404130810/src/com/basic/datastructure/List.java
new file mode 100644
index 0000000000..13fc25acfd
--- /dev/null
+++ b/group20/404130810/src/com/basic/datastructure/List.java
@@ -0,0 +1,10 @@
+package com.basic.datastructure;
+
+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/group20/404130810/src/com/basic/datastructure/Queue.java b/group20/404130810/src/com/basic/datastructure/Queue.java
new file mode 100644
index 0000000000..f83d937e5c
--- /dev/null
+++ b/group20/404130810/src/com/basic/datastructure/Queue.java
@@ -0,0 +1,33 @@
+package com.basic.datastructure;
+
+public class Queue {
+	LinkedList list = new LinkedList();
+	private int size;
+	
+	public void enQueue(Object o){
+		list.add(o);
+		size ++;
+	}
+	
+	public Object deQueue(){
+		size --;
+		return list.removeLast();
+	}
+	
+	public boolean isEmpty(){
+		return list.size() == 0;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public static void main(String[] args) {
+		Queue queue = new Queue();
+		for (int i = 0; i < 10; i++) {
+			queue.enQueue(i);
+		}
+		queue.deQueue();
+		System.out.println("Finished");
+	}
+}
diff --git a/group20/404130810/src/com/basic/datastructure/Stack.java b/group20/404130810/src/com/basic/datastructure/Stack.java
new file mode 100644
index 0000000000..7a58fd49e6
--- /dev/null
+++ b/group20/404130810/src/com/basic/datastructure/Stack.java
@@ -0,0 +1,41 @@
+package com.basic.datastructure;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	private int size;
+	
+	public void push(Object o){		
+		elementData.add(o);
+		size++;
+	}
+	public Object pop(){
+		size --;
+		return elementData.remove(elementData.size() - 1);
+	}
+	
+	/**
+	 * Looks at the object at the top of this stack without removing it from the stack.
+	 * @return Object
+	 */
+	public Object peek(){
+		return elementData.get(elementData.size() - 1);
+	}
+	public boolean isEmpty(){
+		return size == 0;
+	}
+	public int size(){
+		return size;
+	}
+	
+	public static void main(String[] args) {
+		Stack stack = new Stack();
+		for (int i = 0; i < 10; i++) {
+			stack.push(i);
+		}
+		System.out.println(stack.peek());
+		
+		stack.pop();
+		System.out.println("Finished");
+	}
+
+}
diff --git a/group20/404130810/src/com/basic/practice/PolymorphicInJava.java b/group20/404130810/src/com/basic/practice/PolymorphicInJava.java
new file mode 100644
index 0000000000..6bf9996da3
--- /dev/null
+++ b/group20/404130810/src/com/basic/practice/PolymorphicInJava.java
@@ -0,0 +1,41 @@
+package com.basic.practice;
+
+/**
+ * 
+ * @author Wu Alvin
+ * Java Polymorphic Only represent in method level
+ *
+ */
+
+class Fruit{
+	String name = "Fruit";
+	public void print(int i){
+		System.out.println("Fruit" + i);
+	}
+}
+
+
+class Apple extends Fruit{
+	String name = "Apple";
+	public void print(int i){
+		System.out.println("Apple" + i);
+	}
+}
+
+
+public class PolymorphicInJava {
+	
+	public static void main(String[] args) {
+		Apple apple = new Apple();
+		apple.print(100);
+		//Apple100
+		System.out.println(apple.name);
+		//Apple
+		Fruit fruit = apple;
+		fruit.print(100);
+		//Apple100
+		System.out.println(fruit.name);
+		//Fruit
+	}
+
+}
diff --git a/group20/404130810/src/com/basic/practice/ValuePassInJava.java b/group20/404130810/src/com/basic/practice/ValuePassInJava.java
new file mode 100644
index 0000000000..6187b5e0fc
--- /dev/null
+++ b/group20/404130810/src/com/basic/practice/ValuePassInJava.java
@@ -0,0 +1,44 @@
+package com.basic.practice;
+
+public class ValuePassInJava {
+
+	/*
+	 * Pass the Simple value, etc int String...
+	 * Change will NOT happened
+	 * 
+	*/ 
+	public static void main(String[] args) {
+		String s = new String("123");
+		int i = 1;
+		changeVal(i);
+		System.out.println(i);
+		
+	}
+	
+	private static void changeVal(int i){
+		i = 2;
+	}
+	
+	/*
+	 * Pass whole OBJECT, but change the Member variable
+	 * Change will happened
+	 */
+	
+	/*
+	public static void main(String[] args) {
+		Person p = new Person();
+		p.age = 10;
+		changeAge(p);
+		System.out.println(p.age);
+	}
+	
+	private static void changeAge(Person p){
+		p.age = 20;
+	}
+	*/
+	
+}
+
+class Person{
+	int age;
+}
diff --git a/group20/423184723/src/com/coding/basic/ArrayList.java b/group20/423184723/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..1f185736f9
--- /dev/null
+++ b/group20/423184723/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,32 @@
+package com.coding.basic;
+
+public class ArrayList implements List {
+	
+	private int size = 0;
+	
+	private Object[] elementData = new Object[100];
+	
+	public void add(Object o){
+		
+	}
+	public void add(int index, Object o){
+		
+	}
+	
+	public Object get(int index){
+		return null;
+	}
+	
+	public Object remove(int index){
+		return null;
+	}
+	
+	public int size(){
+		return -1;
+	}
+	
+	public Iterator iterator(){
+		return null;
+	}
+	
+}
diff --git a/group20/423184723/src/com/coding/basic/BinaryTreeNode.java b/group20/423184723/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..d7ac820192
--- /dev/null
+++ b/group20/423184723/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,32 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git a/group20/423184723/src/com/coding/basic/Iterator.java b/group20/423184723/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..06ef6311b2
--- /dev/null
+++ b/group20/423184723/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/group20/423184723/src/com/coding/basic/LinkedList.java b/group20/423184723/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..e2c4e5e795
--- /dev/null
+++ b/group20/423184723/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,46 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	
+	public void add(Object o){
+		
+	}
+	public void add(int index , Object o){
+		
+	}
+	public Object get(int index){
+		return null;
+	}
+	public Object remove(int index){
+		return null;
+	}
+	
+	public int size(){
+		return -1;
+	}
+	
+	public void addFirst(Object o){
+		
+	}
+	public void addLast(Object o){
+		
+	}
+	public Object removeFirst(){
+		return null;
+	}
+	public Object removeLast(){
+		return null;
+	}
+	public Iterator iterator(){
+		return null;
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		
+	}
+}
diff --git a/group20/423184723/src/com/coding/basic/List.java b/group20/423184723/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ b/group20/423184723/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/group20/423184723/src/com/coding/basic/Queue.java b/group20/423184723/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..36e516e266
--- /dev/null
+++ b/group20/423184723/src/com/coding/basic/Queue.java
@@ -0,0 +1,19 @@
+package com.coding.basic;
+
+public class Queue {
+	
+	public void enQueue(Object o){		
+	}
+	
+	public Object deQueue(){
+		return null;
+	}
+	
+	public boolean isEmpty(){
+		return false;
+	}
+	
+	public int size(){
+		return -1;
+	}
+}
diff --git a/group20/423184723/src/com/coding/basic/Stack.java b/group20/423184723/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..a5a04de76d
--- /dev/null
+++ b/group20/423184723/src/com/coding/basic/Stack.java
@@ -0,0 +1,22 @@
+package com.coding.basic;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){		
+	}
+	
+	public Object pop(){
+		return null;
+	}
+	
+	public Object peek(){
+		return null;
+	}
+	public boolean isEmpty(){
+		return false;
+	}
+	public int size(){
+		return -1;
+	}
+}
diff --git a/group20/452472201/.gitignore b/group20/452472201/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group20/452472201/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group20/452472201/src/com/coding/basic/ArrayList.java b/group20/452472201/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..1af26ce934
--- /dev/null
+++ b/group20/452472201/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,98 @@
+package com.coding.basic;
+
+public class ArrayList implements List {
+
+	private  int size=0;
+
+	private  Object[] elementData =new Object[10];
+
+
+	//数组扩容
+	private void  ensureCapacityInternal(){
+		if(size==elementData.length){
+			Object[] newArray = new Object[size*2];
+			System.arraycopy(elementData, 0, newArray, 0, elementData.length);
+			elementData=newArray;
+		}
+	}
+
+	public void add(Object o){
+		ensureCapacityInternal();
+		elementData[size]=o;
+		size++;
+	}
+
+	public void add(int index, Object o){
+		ensureCapacityInternal();
+		if(index<0){
+			try {
+				throw new Exception();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+
+		System.arraycopy(elementData, index, elementData, index+1,size-index );
+        elementData[index]=o;
+        size++;
+	}
+
+	public Object get(int index){
+		if(index<0||index>=size){
+			try {
+				throw new Exception();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+		return elementData[index];
+	}
+
+	public Object remove(int index){
+		if(index>=size){
+			try {
+				throw new Exception();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}else{
+
+			int numMoved=size-index-1;
+			if(numMoved>0){
+				System.arraycopy(elementData, index+1, elementData, index, numMoved);
+			}
+
+			elementData[size--] = null;			
+		}
+		return index;
+
+	}
+
+
+	public int size(){
+		return size;
+	}
+
+
+	private class Iter implements Iterator {
+		//计数器 
+		private int coursor=-1;
+		//判断是否存在下一个
+		public boolean hasNext(){
+			return coursor+1<size;
+		}
+		//获取下一个
+		public String next(){
+			coursor++;
+			return (String) elementData[coursor];
+		}
+	}
+		public Iterator iterator(){
+
+			return new Iter();
+
+		}
+}
+
+
+
diff --git a/group20/452472201/src/com/coding/basic/BinaryTreeNode.java b/group20/452472201/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..d7ac820192
--- /dev/null
+++ b/group20/452472201/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,32 @@
+package com.coding.basic;
+
+public class BinaryTreeNode {
+	
+	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){
+		return  null;
+	}
+	
+}
diff --git a/group20/452472201/src/com/coding/basic/Iterator.java b/group20/452472201/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..9c56ce26a3
--- /dev/null
+++ b/group20/452472201/src/com/coding/basic/Iterator.java
@@ -0,0 +1,9 @@
+package com.coding.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
+
+ 
\ No newline at end of file
diff --git a/group20/452472201/src/com/coding/basic/LinkedList.java b/group20/452472201/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..e2c4e5e795
--- /dev/null
+++ b/group20/452472201/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,46 @@
+package com.coding.basic;
+
+public class LinkedList implements List {
+	
+	private Node head;
+	
+	public void add(Object o){
+		
+	}
+	public void add(int index , Object o){
+		
+	}
+	public Object get(int index){
+		return null;
+	}
+	public Object remove(int index){
+		return null;
+	}
+	
+	public int size(){
+		return -1;
+	}
+	
+	public void addFirst(Object o){
+		
+	}
+	public void addLast(Object o){
+		
+	}
+	public Object removeFirst(){
+		return null;
+	}
+	public Object removeLast(){
+		return null;
+	}
+	public Iterator iterator(){
+		return null;
+	}
+	
+	
+	private static  class Node{
+		Object data;
+		Node next;
+		
+	}
+}
diff --git a/group20/452472201/src/com/coding/basic/List.java b/group20/452472201/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..10d13b5832
--- /dev/null
+++ b/group20/452472201/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/group20/452472201/src/com/coding/basic/Queue.java b/group20/452472201/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..36e516e266
--- /dev/null
+++ b/group20/452472201/src/com/coding/basic/Queue.java
@@ -0,0 +1,19 @@
+package com.coding.basic;
+
+public class Queue {
+	
+	public void enQueue(Object o){		
+	}
+	
+	public Object deQueue(){
+		return null;
+	}
+	
+	public boolean isEmpty(){
+		return false;
+	}
+	
+	public int size(){
+		return -1;
+	}
+}
diff --git a/group20/452472201/src/com/coding/basic/Stack.java b/group20/452472201/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..a5a04de76d
--- /dev/null
+++ b/group20/452472201/src/com/coding/basic/Stack.java
@@ -0,0 +1,22 @@
+package com.coding.basic;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){		
+	}
+	
+	public Object pop(){
+		return null;
+	}
+	
+	public Object peek(){
+		return null;
+	}
+	public boolean isEmpty(){
+		return false;
+	}
+	public int size(){
+		return -1;
+	}
+}
diff --git a/group20/592146505/data _structure/src/cn/wsc/util/ArrayList.java b/group20/592146505/data _structure/src/cn/wsc/util/ArrayList.java
new file mode 100644
index 0000000000..94bb1f3217
--- /dev/null
+++ b/group20/592146505/data _structure/src/cn/wsc/util/ArrayList.java	
@@ -0,0 +1,233 @@
+package cn.wsc.util;
+
+import java.util.Arrays;
+import java.util.ConcurrentModificationException;
+import java.util.NoSuchElementException;
+
+/**
+ * ArrayList类
+ * 
+ * @author c_malina007
+ * @param <E>
+ */
+public class ArrayList<E> implements List<E> {
+
+	/** 元素个数 */
+	private int size;
+
+	/** 默认容量 */
+	private static final int DEFAULT_CAPACITY = 10;
+
+	/** 默认最大容量 */
+	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
+
+	/** 默认数组 */
+	private static final Object[] EMPTY_ELEMENTDATA = {};
+
+	/** 用于存放元素 */
+	private Object[] elementData;
+
+	/**
+	 * 无参构造将使用默认数组
+	 */
+	public ArrayList() {
+		elementData = EMPTY_ELEMENTDATA;
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return size == 0;
+	}
+
+	// @Override
+	// public boolean contains(Object o) {
+	// // TODO Auto-generated method stub
+	// return false;
+	// }
+
+	@Override
+	public Iterator<E> iterator() {
+		return new Itr();
+	}
+
+	private class Itr implements Iterator<E> {
+		int cursor; // 当前索引
+		int lastRet = -1;//
+
+		@Override
+		public boolean hasNext() {
+			return cursor != size;
+		}
+
+		@SuppressWarnings("unchecked")
+		@Override
+		public E next() {
+			if (cursor > size) {
+				throw new NoSuchElementException();
+			}
+			Object[] elementData = ArrayList.this.elementData;
+			if (cursor >= elementData.length) {
+				throw new ConcurrentModificationException();
+			}
+			return (E) elementData[lastRet = cursor++];
+		}
+
+		@Override
+		public void remove() {
+			if (lastRet < 0)
+				throw new IllegalStateException();
+			try {
+				ArrayList.this.remove(lastRet);
+				cursor = lastRet;
+				lastRet = -1;
+				size--;
+			} catch (IndexOutOfBoundsException ex) {
+				throw new ConcurrentModificationException();
+			}
+		}
+
+	}
+
+	// @Override
+	// public Object[] toArray() {
+	// // TODO Auto-generated method stub
+	// return null;
+	// }
+	//
+	// @Override
+	// public <T> T[] toArray(T[] a) {
+	// // TODO Auto-generated method stub
+	// return null;
+	// }
+
+	@Override
+	public boolean add(E element) {
+		// 保证数组长度正确
+		ensureCapacityInternal(size + 1);
+		// 使用后缀自操作符
+		elementData[size++] = element;
+		return true;
+	}
+
+	@Override
+	public boolean add(int index, E element) {
+		rangeCheckForAdd(index);// 进行添加操作的索引范围检查
+		// 保证数组长度正确
+		ensureCapacityInternal(size + 1);
+		// 源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到
+		// destPos+length-1 位置
+		System.arraycopy(elementData, index, elementData, index + 1, size - index);
+		elementData[index] = element;
+		size++;
+		return true;
+	}
+
+	private void ensureCapacityInternal(int minCapacity) {
+		if (elementData == EMPTY_ELEMENTDATA)
+			minCapacity = Math.max(minCapacity, DEFAULT_CAPACITY);
+		// 传入最小容量大于当前数组长度，则扩容
+		if (minCapacity > elementData.length)
+			grow(minCapacity);
+	}
+
+	/**
+	 * 扩容
+	 * 
+	 * @param minCapacity
+	 */
+	private void grow(int minCapacity) {
+		int oldCapacity = elementData.length;// 获取原数组长度
+		// 计算新容量
+		int newCapacity = oldCapacity + (oldCapacity >> 1);// 原容量+(原容量/2)，使用位移符提高运行速度
+		newCapacity = newCapacity < minCapacity ? minCapacity : newCapacity;
+		if (newCapacity > MAX_ARRAY_SIZE)
+			newCapacity = hugeCapacity(newCapacity);
+		// 将原数组数据复制到一个长度为newCapacity的新数组中
+		elementData = Arrays.copyOf(elementData, newCapacity);
+	}
+
+	/**
+	 * 传入容量是否大于最大容量常量，如大于最大容量，则返回int类型所能表示的最大值 ArrayList最大容量为int类型所能表示的最大值
+	 * 
+	 * @param minCapacity
+	 * @return
+	 */
+	private int hugeCapacity(int minCapacity) {
+		if (minCapacity < 0) {
+			throw new OutOfMemoryError("The index cannot be negative");
+		}
+		return minCapacity > MAX_ARRAY_SIZE ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public E get(int index) {
+		rangeCheck(index);// 进行索引的范围检查
+		return (E) elementData[index];
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public E set(int index, E element) {
+		rangeCheck(index);// 进行索引的范围检查
+		// 取到指定索引元素，将新元素置入该索引位，并返回原元素
+		E oldValue = (E) elementData[index];
+		elementData[index] = element;
+		return oldValue;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public E remove(int index) {
+		rangeCheck(index);// 进行索引的范围检查
+		// 获取指定索引处元素
+		E rmValue = (E) elementData[index];
+		// 源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到
+		// destPos+length-1 位置
+		System.arraycopy(elementData, index + 1, elementData, index, size - (index - 1));
+		size--;
+		return rmValue;
+	}
+
+	// @Override
+	// public int indexOf(Object o) {
+	// // TODO Auto-generated method stub
+	// return 0;
+	// }
+
+	/**
+	 * 添加时的索引范围检查
+	 * 
+	 * @param index
+	 */
+	private void rangeCheckForAdd(int index) {
+		if (index > this.size || index < 0)// 添加可以往末位插入，所以这里索引等于元素个数也可以
+			throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+	}
+
+	/**
+	 * 索引范围检查
+	 * 
+	 * @param index
+	 */
+	private void rangeCheck(int index) {
+		if (index < 0 || index >= this.size)
+			throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+	}
+
+	/**
+	 * 以字符串形式返回索引和元素个数信息
+	 * 
+	 * @param index
+	 * @return
+	 */
+	private String outOfBoundsMsg(int index) {
+		return "Index: " + index + ", Size: " + this.size;
+	}
+
+}
diff --git a/group20/592146505/data _structure/src/cn/wsc/util/LinkedList.java b/group20/592146505/data _structure/src/cn/wsc/util/LinkedList.java
new file mode 100644
index 0000000000..ccb9ff2783
--- /dev/null
+++ b/group20/592146505/data _structure/src/cn/wsc/util/LinkedList.java	
@@ -0,0 +1,284 @@
+package cn.wsc.util;
+
+import java.util.ConcurrentModificationException;
+import java.util.NoSuchElementException;
+
+/**
+ * LinkedList类
+ *
+ * @author Administrator
+ * @date 2017年2月25日上午10:52:41
+ * @version v1.0
+ *
+ * @param <E>
+ */
+public class LinkedList<E> implements List<E> {
+
+	private int size;
+	Node<E> first; // 链表的头节点
+	Node<E> last; // 链表的尾节点
+
+	private static class Node<E> {
+		E item; // 存储数据
+		Node<E> prev; // 上一个节点
+		Node<E> next; // 下一个节点
+
+		Node(Node<E> prev, E element, Node<E> next) {
+			this.item = element;
+			this.next = next;
+			this.prev = prev;
+		}
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return size == 0;
+	}
+
+	@Override
+	public Iterator<E> iterator() {
+		return new Itr();
+	}
+
+	private class Itr implements Iterator<E> {
+		int cursor; // 当前索引
+		int lastRet = -1;// 上一次索引
+
+		@Override
+		public boolean hasNext() {
+			return cursor != size;
+		}
+
+		@Override
+		public E next() {
+			if (cursor > size) {
+				throw new NoSuchElementException();
+			}
+			return get(lastRet = cursor++);
+		}
+
+		@Override
+		public void remove() {
+			if (lastRet < 0)
+				throw new IllegalStateException();
+			try {
+				LinkedList.this.remove(lastRet);
+				cursor = lastRet;
+				lastRet = -1;
+				size--;
+			} catch (IndexOutOfBoundsException ex) {
+				throw new ConcurrentModificationException();
+			}
+		}
+
+	}
+
+	@Override
+	public boolean add(E e) {
+		linkLast(e);
+		return true;
+	}
+
+	@Override
+	public boolean add(int index, E element) {
+		checkPositionIndex(index);// 位置范围检查
+		// 如果索引等于元素个数，则直接插入尾部
+		if (index == size) {
+			linkLast(element);
+		} else {
+			linkBefore(element, node(index));
+		}
+		return true;
+	}
+
+	@Override
+	public E get(int index) {
+		return node(index).item;
+	}
+
+	/**
+	 * 维护头节点
+	 * 
+	 * @param e
+	 */
+	void linkFirst(E e) {
+		Node<E> f = first;
+		// 创建新节点，将原头节点作为新节点的下一个节点
+		Node<E> newNode = new Node<E>(null, e, f);
+		// 将新节点设置为头节点
+		first = newNode;
+		// 如原头节点为null，则尾节点也为newNode
+		if (f == null) {
+			last = newNode;
+		} else {// 否则将新节点作为原头节点的上一个节点
+			f.prev = newNode;
+		}
+		size++;
+
+	}
+
+	/**
+	 * 维护尾节点
+	 * 
+	 * @param e
+	 */
+	void linkLast(E e) {
+		Node<E> l = last;
+		// 创建新节点，将尾节点作为新节点的上一个节点
+		Node<E> newNode = new Node<E>(l, e, null);
+		// 将新节点设置为尾节点
+		last = newNode;
+		// 如原尾节点为null，则头节点也为newNode
+		if (l == null) {
+			first = newNode;
+		} else {// 否则将新节点作为原尾节点的下一个节点
+			l.next = newNode;
+		}
+		size++;
+	}
+
+	/**
+	 * 在指定节点前插入新节点
+	 * 
+	 * @param e
+	 * @param node
+	 */
+	void linkBefore(E e, Node<E> node) {
+		// 获取node的上一个节点，并创建新节点，将pred做为新节点的上一个节点，将node作为新节点的下一个节点
+		final Node<E> pred = node.prev;
+		final Node<E> newNode = new Node<>(pred, e, node);
+		// 将node的上一个节点指向newNode
+		node.prev = newNode;
+		// 如prev为null，则说明node为first，那么将新节点设为first
+		if (pred == null) {
+			first = newNode;
+		} else {// 否则，将新节点设为pred的下一个节点
+			pred.next = newNode;
+		}
+		size++;
+	}
+
+	/**
+	 * 获取节点
+	 * 
+	 * @param index
+	 * @return
+	 */
+	Node<E> node(int index) {
+		// 索引小于长度的2分之一则从前向后遍历，否则从后向前遍历，减少遍历次数
+		if (index < (size >> 1)) {
+			Node<E> x = first;
+			for (int i = 0; i < index; i++)
+				x = x.next;
+			return x;
+		} else {
+			Node<E> x = last;
+			for (int i = size - 1; i > index; i--)
+				x = x.prev;
+			return x;
+		}
+	}
+
+	/**
+	 * 获取头节点
+	 * 
+	 * @return
+	 */
+	public E getFirst() {
+		Node<E> f = first;
+		if (f == null)
+			throw new NoSuchElementException();
+		return f.item;
+	}
+
+	/**
+	 * 获取尾节点
+	 * 
+	 * @return
+	 */
+	public E getLast() {
+		Node<E> l = last;
+		if (l == null)
+			throw new NoSuchElementException();
+		return l.item;
+	}
+
+	@Override
+	public E set(int index, E e) {
+		checkElementIndex(index);// 索引范围检查
+		// 获取索引处节点，填入新值，返回原值
+		Node<E> x = node(index);
+		E oldVal = x.item;
+		x.item = e;
+		return oldVal;
+	}
+
+	@Override
+	public E remove(int index) {
+		checkElementIndex(index);// 索引范围检查
+		return unlink(node(index));
+	}
+
+	/**
+	 * 删除节点
+	 * 
+	 * @param x
+	 * @return
+	 */
+	E unlink(Node<E> x) {
+		// 获取此节点的上一个节点和下一个节点
+		E element = x.item;
+		Node<E> prev = x.prev;
+		Node<E> next = x.next;
+		// 如prev节点为null，则说明x节点为first，那么将next节点设为first
+		if (prev == null) {
+			first = next;
+		} else {// 否则，将prev节点的下一个节点设为next
+			prev.next = next;
+		}
+		// 如next节点为null，则说明x节点为last，那么将prev节点设为last
+		if (next == null) {
+			last = prev;
+		} else {// 否则，将next节点的上一个节点设为prev
+			next.prev = prev;
+		}
+		x.item = null;
+		size--;
+		return element;
+	}
+
+	/**
+	 * 位置范围检查 >0 && <=size
+	 * 
+	 * @param index
+	 */
+	private void checkPositionIndex(int index) {
+		if (index > this.size || index < 0)// 添加可以往末位插入，所以这里索引等于元素个数也可以
+			throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+	}
+
+	/**
+	 * 索引范围检查 >0 && <size
+	 * 
+	 * @param index
+	 */
+	private void checkElementIndex(int index) {
+		if (index < 0 || index >= this.size)
+			throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+	}
+
+	/**
+	 * 以字符串形式返回索引和元素个数信息
+	 * 
+	 * @param index
+	 * @return
+	 */
+	private String outOfBoundsMsg(int index) {
+		return "Index: " + index + ", Size: " + this.size;
+	}
+}
diff --git a/group20/592146505/data _structure/src/cn/wsc/util/List.java b/group20/592146505/data _structure/src/cn/wsc/util/List.java
new file mode 100644
index 0000000000..9b61278fc7
--- /dev/null
+++ b/group20/592146505/data _structure/src/cn/wsc/util/List.java	
@@ -0,0 +1,105 @@
+package cn.wsc.util;
+
+/**
+ * List接口
+ *
+ * @author Administrator
+ * @date 2017年2月20日下午9:15:32
+ * @version v1.0
+ *
+ * @param <T>
+ */
+public interface List<E> {
+
+	/**
+	 * 获取集合元素个数
+	 * 
+	 * @return
+	 */
+	int size();
+
+	/**
+	 * 集合是否为空
+	 * 
+	 * @return
+	 */
+	boolean isEmpty();
+
+	// /**
+	// * 是否包含指定元素
+	// * @param o
+	// * @return
+	// */
+	// boolean contains(Object o);
+
+	/**
+	 * 获取当前集合迭代器对象
+	 * 
+	 * @return
+	 */
+	Iterator<E> iterator();
+	//
+	// /**
+	// * 返回集合数组对象
+	// *
+	// * @return
+	// */
+	// Object[] toArray();
+	//
+	// /**
+	// * 将集合元素复制到新数组中
+	// * @param a
+	// * @return
+	// */
+	// <T> T[] toArray(T[] a);
+
+	/**
+	 * 在集合末尾追加元素
+	 * 
+	 * @param e
+	 * @return
+	 */
+	boolean add(E e);
+
+	/**
+	 * 将元素添加至指定指定索引处
+	 * 
+	 * @param index
+	 * @param e
+	 * @return
+	 */
+	boolean add(int index, E e);
+
+	/**
+	 * 获取指定索引处元素
+	 * 
+	 * @param index
+	 * @return
+	 */
+	E get(int index);
+
+	/**
+	 * 替换指定索引处元素为新元素，并返回被替换元素，
+	 * 
+	 * @param index
+	 * @param e
+	 * @return
+	 */
+	E set(int index, E e);
+
+	/**
+	 * 删除并返回指定指定索引处元素
+	 * 
+	 * @param index
+	 * @return
+	 */
+	E remove(int index);
+
+	// /**
+	// * 返回该对象在集合中的下标，不存在返回-1
+	// * @param o
+	// * @return
+	// */
+	// int indexOf(Object o);
+
+}
\ No newline at end of file
diff --git a/group20/592146505/data _structure/src/cn/wsc/utils/Stack.java b/group20/592146505/data _structure/src/cn/wsc/utils/Stack.java
new file mode 100644
index 0000000000..3f156461e8
--- /dev/null
+++ b/group20/592146505/data _structure/src/cn/wsc/utils/Stack.java	
@@ -0,0 +1,22 @@
+package cn.wsc.utils;
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+	
+	public void push(Object o){		
+	}
+	
+	public Object pop(){
+		return null;
+	}
+	
+	public Object peek(){
+		return null;
+	}
+	public boolean isEmpty(){
+		return false;
+	}
+	public int size(){
+		return -1;
+	}
+}
diff --git "a/group20/755659358/blogs/\350\256\241\347\256\227\346\234\272\351\203\250\344\273\266\347\220\206\350\247\243.txt" "b/group20/755659358/blogs/\350\256\241\347\256\227\346\234\272\351\203\250\344\273\266\347\220\206\350\247\243.txt"
new file mode 100644
index 0000000000..155001683a
--- /dev/null
+++ "b/group20/755659358/blogs/\350\256\241\347\256\227\346\234\272\351\203\250\344\273\266\347\220\206\350\247\243.txt"
@@ -0,0 +1,2 @@
+               对计算机硬件的理解
+   计算机中cpu是核心部件，cpu是主要的计算部件，所有的逻辑运算和算术运算都是由cpu来玩成的。但cpu只管运算，怎么运算，何时运算，运算什么这些cpu都是不管的，这些其实就是一个个的指令，指令用来表示所有运算的信息，包括做什么运算，运算什么，运算结果如何处置等。这些指令都是存在内存当中的，cpu按照一定的顺序从内存当中读取指令，执行指令做运算，然后按照相应的指令输出结果。这就是一个简单的程序运行过程。内存空间是有限的，另外，内存上的指令也不能持久化的保存，断电之后就没有了。所以需要一个硬件保存大的二进制资源以及持久化的保存指令，所以就有了硬盘。所以计算机先从硬盘中读取指令和资源到内存当中来，然后cpu再从内存当中读取指令和资源，做运算，运算完之后再按照指令将输出保存在内存中或者硬盘中，程序执行完毕。
diff --git a/group20/755659358/liuxincourse_datastructure/src/liuxincourse/ArrayList.java b/group20/755659358/liuxincourse_datastructure/src/liuxincourse/ArrayList.java
new file mode 100644
index 0000000000..8a4434041f
--- /dev/null
+++ b/group20/755659358/liuxincourse_datastructure/src/liuxincourse/ArrayList.java
@@ -0,0 +1,56 @@
+package liuxincourse;
+
+import java.util.Arrays;
+
+
+public class ArrayList implements List{
+	
+	private int size=0;
+	
+	private Object [] elementDataObjects = new Object[3];
+	
+	public void add (Object o){
+		if (size>=elementDataObjects.length) {
+			elementDataObjects=Arrays.copyOf(elementDataObjects, elementDataObjects.length+50);
+		}
+		elementDataObjects[size]=o;
+		size++;
+	}
+	
+	public void add (int index ,Object o){
+		if (index>=size||index<0) {
+			throw new IndexOutOfBoundsException();
+		}
+		if (size>=elementDataObjects.length) {
+			elementDataObjects=Arrays.copyOf(elementDataObjects, elementDataObjects.length+50);
+		}
+		System.arraycopy(elementDataObjects, index, elementDataObjects, index+1, size-index);
+		elementDataObjects[index]=o;
+		size++;
+	}
+
+	public Object get (int index){
+		if (index>=size||index<0) {
+			throw new IndexOutOfBoundsException();
+		}
+		return elementDataObjects[index];
+	}
+	
+	public Object remove(int index){
+		if (index>=size||index<0) {
+			throw new IndexOutOfBoundsException();
+		}
+		Object rem=elementDataObjects[index];
+		System.arraycopy(elementDataObjects, index+1, elementDataObjects, index, size-index-1);
+		size--;
+		return rem;
+	}
+
+	public int size(){
+		return size;
+	}
+	
+//	public Iterator iterator(){
+//		
+//	}
+}
diff --git a/group20/755659358/liuxincourse_datastructure/src/liuxincourse/LinkedList.java b/group20/755659358/liuxincourse_datastructure/src/liuxincourse/LinkedList.java
new file mode 100644
index 0000000000..36e46e6412
--- /dev/null
+++ b/group20/755659358/liuxincourse_datastructure/src/liuxincourse/LinkedList.java
@@ -0,0 +1,120 @@
+package liuxincourse;
+
+
+public class LinkedList implements List{
+	
+	private Node head;
+	
+	private int size=0;
+	
+	
+	public void add(Object o){
+		if (size==0) {
+			head=new Node();
+			head.data=o;
+			size++;
+			return;
+		}
+		Node last=head;
+		for (int i = 0; i < size-1; i++) {
+			last=last.next;
+		}
+		Node added=new Node();
+		last.next=added;
+		added.data=o;
+		size++;
+	}
+	
+	public void add(int index,Object o){
+		if (index<0||index>size) {
+			throw new IndexOutOfBoundsException();
+		}
+		Node pre=getNode(index-1);
+		Node next=getNode(index);
+		Node addedNode=new Node();
+		addedNode.data=o;
+		pre.next=addedNode;
+		addedNode.next=next;
+		size++;
+	}
+	
+	private Node getNode(int index){
+		Node node=head;
+		
+		for (int i = 0; i < index; i++) {
+			node=node.next;
+		}
+		
+		return node;
+	}
+	
+	public Object get(int index){
+		if (index<0||index>size-1) {
+			throw new IndexOutOfBoundsException();
+		}
+		if (index==0&&head==null) {
+			return null;
+		}
+		return getNode(index).data;
+
+	}
+	
+	public Object remove(int index) {
+		if (index<0||index>size-1) {
+			throw new IndexOutOfBoundsException();
+		}
+		Node pre=getNode(index-1);
+		Node next=getNode(index+1);
+		pre.next=next;
+		return getNode(index);
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public void addFirst(Object o){
+		if (head==null) {
+			head=new Node();
+			head.data=o;
+			size++;
+			return;
+		}
+		Node addNode=new Node();
+		addNode.data=o;
+		addNode.next=head;
+		head=addNode;
+		size++;
+	}
+	
+	public void addLast(Object o){
+		Node preLast=getNode(size-1);
+		Node addNode=new Node();
+		addNode.data=o;
+		preLast.next=addNode;
+		size++;
+	}
+	
+	public Object removeFirst(){
+		Node preHead=head;
+		head=head.next;
+		size--;
+		return preHead.data;
+	}
+	
+	public Object removeLast(){
+		Node preLast=getNode(size-1);
+		Node last=getNode(size-2);
+		last.next=null;
+		size--;
+		return preLast.data;
+	}
+	
+	private static class Node{
+		
+			Object data;
+			Node next;
+			
+	}
+
+}
diff --git a/group20/755659358/liuxincourse_datastructure/src/liuxincourse/List.java b/group20/755659358/liuxincourse_datastructure/src/liuxincourse/List.java
new file mode 100644
index 0000000000..c4eaa0a02c
--- /dev/null
+++ b/group20/755659358/liuxincourse_datastructure/src/liuxincourse/List.java
@@ -0,0 +1,10 @@
+package liuxincourse;
+
+public interface List {
+	
+		void add(Object o);
+		void add(int index,Object o);
+		Object get(int index);
+		Object remove(int index);
+		int size();
+}
diff --git a/group20/755659358/liuxincourse_datastructure/src/liuxincourse/Queue.java b/group20/755659358/liuxincourse_datastructure/src/liuxincourse/Queue.java
new file mode 100644
index 0000000000..bbe11c043d
--- /dev/null
+++ b/group20/755659358/liuxincourse_datastructure/src/liuxincourse/Queue.java
@@ -0,0 +1,25 @@
+package liuxincourse;
+
+public class Queue {
+	
+	LinkedList list=new LinkedList();
+	
+	public void enQueue(Object o){
+		list.add(o);
+	}
+	
+	public Object deQueue(){
+	
+		return list.removeFirst();
+	}
+	
+	public boolean isEmpty() {
+		
+		return size()==0?true:false;
+	}
+	
+	public int size(){
+		return list.size();
+	}
+
+}
diff --git a/group20/755659358/liuxincourse_datastructure/src/liuxincourse/Stack.java b/group20/755659358/liuxincourse_datastructure/src/liuxincourse/Stack.java
new file mode 100644
index 0000000000..552d8c9f9e
--- /dev/null
+++ b/group20/755659358/liuxincourse_datastructure/src/liuxincourse/Stack.java
@@ -0,0 +1,27 @@
+package liuxincourse;
+
+public class Stack {
+
+	private LinkedList elementData=new LinkedList();
+	
+	public void push (Object o){
+		elementData.addFirst(o);
+	}
+	
+	public Object pop() {
+		return elementData.removeFirst();
+	}
+	
+	public Object peek(){
+		return elementData.get(0);
+	}
+	
+	public boolean isEmpty(){
+		return size()==0?true:false;
+	}
+	
+	public int size() {
+		return elementData.size();
+	}
+
+}
diff --git a/group20/755659358/liuxincourse_datastructure/test/liuxincourse/ArrayListTest.java b/group20/755659358/liuxincourse_datastructure/test/liuxincourse/ArrayListTest.java
new file mode 100644
index 0000000000..8b8d82b3b1
--- /dev/null
+++ b/group20/755659358/liuxincourse_datastructure/test/liuxincourse/ArrayListTest.java
@@ -0,0 +1,53 @@
+package liuxincourse;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class ArrayListTest {
+
+	
+	@Test
+	public void testAdd(){
+		ArrayList list=new ArrayList();
+		list.add(12);
+		list.add(2);
+		list.add(8);
+		assertEquals(8, list.get(2));
+	}
+	
+	@Test
+	public void testAddIndex(){
+		ArrayList list=new ArrayList();
+		list.add(12);
+		list.add(2);
+		list.add(8);
+		list.add(1,33);
+		list.add(6);
+		list.add(7);
+		assertEquals(8, list.get(3));
+	}
+	
+	@Test
+	public void testRemove(){
+		ArrayList list=new ArrayList();
+		list.add(12);
+		list.add(2);
+		list.add(8);
+		list.add(1,33);
+		list.remove(1);
+		assertEquals(2, list.get(1));
+	}
+	
+	@Test
+	public void testSize(){
+		ArrayList list=new ArrayList();
+		list.add(12);
+		list.add(2);
+		list.add(8);
+		list.add(9);
+		list.add(77);
+		assertEquals(5, list.size());
+	}
+
+}
diff --git a/group20/755659358/liuxincourse_datastructure/test/liuxincourse/LinkedListTest.java b/group20/755659358/liuxincourse_datastructure/test/liuxincourse/LinkedListTest.java
new file mode 100644
index 0000000000..69857b0e29
--- /dev/null
+++ b/group20/755659358/liuxincourse_datastructure/test/liuxincourse/LinkedListTest.java
@@ -0,0 +1,69 @@
+package liuxincourse;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class LinkedListTest {
+	
+	@Test
+	public void testAdd() {
+		LinkedList list=new LinkedList();
+		list.add(33);
+		list.add(44);
+		list.add(55);
+		list.add(88);
+		assertEquals(88, list.get(3));
+	}
+	
+	@Test
+	public void testAddIndex() {
+		LinkedList list=new LinkedList();
+		list.add(33);
+		list.add(44);
+		list.add(55);
+		list.add(1, 88);
+		assertEquals(55, list.get(3));
+	}
+	
+	@Test
+	public void testAddFirst() {
+		LinkedList list=new LinkedList();
+		list.add(33);
+		list.add(44);
+		list.add(55);
+		list.addFirst(88);
+		assertEquals(88, list.get(0));
+	}
+
+	@Test
+	public void testAddLast() {
+		LinkedList list=new LinkedList();
+		list.add(33);
+		list.add(44);
+		list.add(55);
+		list.addFirst(88);
+		list.addLast(00);
+		assertEquals(00, list.get(list.size()-1));
+	}
+	
+	@Test
+	public void testRemoveFirst() {
+		LinkedList list=new LinkedList();
+		list.add(33);
+		list.add(44);
+		list.add(55);
+		list.addFirst(88);
+		assertEquals(88, list.removeFirst());
+	}
+	
+	@Test
+	public void testRemoveLast() {
+		LinkedList list=new LinkedList();
+		list.add(33);
+		list.add(44);
+		list.add(55);
+		list.addFirst(88);
+		assertEquals(55, list.removeLast());
+	}
+}
diff --git a/group20/755659358/liuxincourse_datastructure/test/liuxincourse/QueueTest.java b/group20/755659358/liuxincourse_datastructure/test/liuxincourse/QueueTest.java
new file mode 100644
index 0000000000..613df89fc3
--- /dev/null
+++ b/group20/755659358/liuxincourse_datastructure/test/liuxincourse/QueueTest.java
@@ -0,0 +1,27 @@
+package liuxincourse;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class QueueTest {
+
+	@Test
+	public void testEnqueue() {
+		Queue queue=new Queue();
+		queue.enQueue(11);
+		queue.enQueue(22);
+		assertEquals(11, queue.deQueue());
+	}
+	
+	@Test
+	public void testIsempty() {
+		Queue queue=new Queue();
+		queue.enQueue(11);
+		queue.enQueue(22);
+		queue.deQueue();
+		queue.deQueue();
+		assertEquals(true, queue.isEmpty());
+	}
+
+}
diff --git a/group20/755659358/liuxincourse_datastructure/test/liuxincourse/StackTest.java b/group20/755659358/liuxincourse_datastructure/test/liuxincourse/StackTest.java
new file mode 100644
index 0000000000..9f1175ffea
--- /dev/null
+++ b/group20/755659358/liuxincourse_datastructure/test/liuxincourse/StackTest.java
@@ -0,0 +1,26 @@
+package liuxincourse;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class StackTest {
+
+	@Test
+	public void testPush() {
+		Stack stack=new Stack();
+		stack.push(22);
+		stack.push(33);
+		assertEquals(33, stack.pop());
+	}
+	
+	@Test
+	public void testIsempty() {
+		Stack stack=new Stack();
+		stack.push(22);
+		stack.push(33);
+		stack.pop();
+		assertEquals(false, stack.isEmpty());
+	}
+
+}
diff --git a/group20/755659358/liuxincourse_datastructure/test/liuxincourse/SuiteTest.java b/group20/755659358/liuxincourse_datastructure/test/liuxincourse/SuiteTest.java
new file mode 100644
index 0000000000..5c12e657b6
--- /dev/null
+++ b/group20/755659358/liuxincourse_datastructure/test/liuxincourse/SuiteTest.java
@@ -0,0 +1,14 @@
+package liuxincourse;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({ArrayListTest.class,LinkedListTest.class,QueueTest.class,StackTest.class})
+public class SuiteTest {
+
+}
diff --git "a/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyArrayList.java" "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyArrayList.java"
new file mode 100644
index 0000000000..de63307566
--- /dev/null
+++ "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyArrayList.java"
@@ -0,0 +1,136 @@
+package BasicData;
+
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+/**
+ * ʵ�ֻ��������ݽṹ����ArrayList
+ * 
+ * @author Ralf
+ * 
+ * @param <T>
+ */
+public class MyArrayList<T> implements MyList<T> {
+
+	private static final int DEFAULT_CAPACITY = 10;
+	private static int msize;
+	private T[] elements;
+
+	public MyArrayList() {
+		msize = 0;
+		ensureCapacity(DEFAULT_CAPACITY);
+	}
+
+	@SuppressWarnings("unchecked")
+	private void ensureCapacity(int newCapacity) {
+		// TODO Auto-generated method stub
+		if (msize > newCapacity) {
+			return;
+		}
+		T[] oldElements = elements;
+		elements = (T[]) new Object[newCapacity];
+		for (int i = 0; i < size(); i++) {
+			elements[i] = oldElements[i];
+		}
+
+	}
+	public void trimSize(){
+		if (msize < elements.length) {
+			ensureCapacity(msize);
+		}
+	}
+
+	@Override
+	public boolean add(T t) {
+		// TODO Auto-generated method stub
+
+		if (elements.length == size()) {
+			ensureCapacity(2 * size() + 1);
+		}
+		elements[msize++] = t;
+		return true;
+	}
+
+	@Override
+	public void add(int index, T t) {
+
+		if (msize == elements.length) {
+			ensureCapacity(2 * msize + 1);
+		}
+		for (int i = size(); i >= index; i--) {
+			elements[i + 1] = elements[i];
+		}
+		elements[index] = t;
+		msize++;
+	}
+
+	@Override
+	public int size() {
+		// TODO Auto-generated method stub
+		return msize;
+	}
+
+	@Override
+	public T remove(int index) {
+		// TODO Auto-generated method stub
+		if (index < 0 || index > size()) {
+			throw new ArrayIndexOutOfBoundsException();
+		}
+		T old = elements[index];
+		for (int i = index; i < msize; i++) {
+			elements[i] = elements[i + 1];
+		}
+		elements[msize--] = null;
+		return old;
+
+	}
+
+	@Override
+	public boolean set(int index, T t) {
+		// TODO Auto-generated method stub
+		if (index < 0 || index > size()) {
+			throw new ArrayIndexOutOfBoundsException();
+		}
+		elements[index] = t;
+		return true;
+	}
+
+	@Override
+	public T get(int index) {
+		// TODO Auto-generated method stub
+		if (index < 0 || index > msize) {
+			throw new ArrayIndexOutOfBoundsException();
+		}
+		return elements[index];
+	}
+
+	@Override
+	public String toString() {
+		return Arrays.toString(elements);
+	}
+
+	public MyIterator<T> iterator() {
+		return new MyArrayListIterator();
+	}
+
+	private class MyArrayListIterator implements MyIterator<T> {
+
+		private int current = 0;// ��������ָ��
+
+		public boolean hasNext() {
+			// TODO Auto-generated method stub
+
+			return current < size();
+		}
+
+		public T Next() {
+			// TODO Auto-generated method stub
+			if (!hasNext()) {
+				throw new NoSuchElementException();
+			}
+			return elements[current++];
+		}
+
+	}
+
+}
diff --git "a/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyIterator.java" "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyIterator.java"
new file mode 100644
index 0000000000..42bf1d4fa1
--- /dev/null
+++ "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyIterator.java"
@@ -0,0 +1,7 @@
+package BasicData;
+
+public interface MyIterator<T> {
+
+	public abstract boolean hasNext();
+	public abstract T Next();
+}
diff --git "a/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyList.java" "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyList.java"
new file mode 100644
index 0000000000..2b2ba5057a
--- /dev/null
+++ "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyList.java"
@@ -0,0 +1,16 @@
+package BasicData;
+
+/**
+ * �����Լ���List�ӿ�
+ * @author Ralf
+ *
+ */
+public interface MyList<T> {
+
+	public abstract boolean add(T t);
+	public abstract void add(int index, T t);
+	public abstract int size();
+	public abstract T remove(int index);
+	public abstract boolean set(int index, T t);
+	public abstract T get(int index);
+}
diff --git "a/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyQueue.java" "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyQueue.java"
new file mode 100644
index 0000000000..772b93f879
--- /dev/null
+++ "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyQueue.java"
@@ -0,0 +1,79 @@
+package BasicData;
+
+/**
+ * ʵ�ֻ������ݽṹQueue(����)
+ * 
+ * @author Administrator
+ * 
+ */
+public class MyQueue<T> {
+
+	private int head;
+	private int tail;
+	private T[] elements;
+	private static final int DEFAUL_SIZE = 10;
+	private int numOfelements;
+
+	public MyQueue() {
+		head = 0;
+		tail = 0;
+		numOfelements = 0;
+		setCapacity(DEFAUL_SIZE);
+	}
+
+	public MyQueue(int capacity) {
+		head = 0;
+		tail = 0;
+		numOfelements = 0;
+		setCapacity(capacity);
+
+	}
+
+	@SuppressWarnings("unchecked")
+	private void setCapacity(int capacity) {
+		elements = (T[]) new Object[capacity];
+	}
+
+	public boolean enQueue(T t) {
+
+		if (numOfelements == elements.length) {
+			return false;
+		} else {
+			elements[tail] = t;
+			numOfelements++;
+			if (tail == elements.length)
+				tail = 0;
+			else
+				tail++;
+			return true;
+		}
+
+	}
+
+	public T deQueue() {
+		if (head == tail) {
+			return null;
+		} else {
+			T t = elements[head];
+			numOfelements--;
+			elements[head] = null;
+			if (head == elements.length)
+				head = 0;
+			else {
+				head++;
+			}
+			return t;
+		}
+
+	}
+
+	public boolean isEmpty() {
+		return numOfelements == 0;
+	}
+
+	public int size() {
+		int msize = head - tail;
+		return msize > 0 ? msize : -msize;
+	}
+
+}
diff --git "a/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyStack.java" "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyStack.java"
new file mode 100644
index 0000000000..fb12e0dd23
--- /dev/null
+++ "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyStack.java"
@@ -0,0 +1,44 @@
+package BasicData;
+
+import java.util.LinkedList;
+import java.util.NoSuchElementException;
+
+/**
+ * ʵ�ֻ������ݽṹջ
+ * 
+ * @author Ralf
+ * 
+ */
+public class MyStack<T> {
+
+	private LinkedList<T> linkedList;
+
+	public MyStack() {
+		if (null == linkedList) {
+			linkedList = new LinkedList<T>();
+		}
+	}
+
+	public void push(T t) {
+		linkedList.addFirst(t);
+	}
+
+	public T pop() {
+		if (size() == 0) {
+			throw new NoSuchElementException();
+		}
+		return linkedList.removeFirst();
+	}
+
+	public T peek() {
+		return (size() == 0) ? null : linkedList.getFirst();
+	}
+
+	public int size() {
+		return linkedList.size();
+	}
+
+	public boolean isEmpty(){
+		return linkedList.isEmpty();
+	}
+}
diff --git "a/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyTreeNode.java" "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyTreeNode.java"
new file mode 100644
index 0000000000..6ca5cecb15
--- /dev/null
+++ "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/MyTreeNode.java"
@@ -0,0 +1,99 @@
+package BasicData;
+
+//insert ����������
+public class MyTreeNode<T extends Comparable<T>> {
+
+	private T data;
+	private MyTreeNode<T> left = null;
+	private MyTreeNode<T> right = null;
+	private MyTreeNode<T> root = null;
+	private MyTreeNode<T> cureeTreeNode = null;
+	
+	public T getData() {
+		return data;
+	}
+	public void setData(T data) {
+		this.data = data;
+	}
+	public MyTreeNode<T> getLeft() {
+		return left;
+	}
+	public void setLeft(MyTreeNode<T> left) {
+		this.left = left;
+	}
+	public MyTreeNode<T> getRight() {
+		return right;
+	}
+	public void setRight(MyTreeNode<T> right) {
+		this.right = right;
+	}
+	@Override
+	public String toString() {
+		StringBuilder string = new StringBuilder();
+		string.append("[");
+		if (cureeTreeNode == null) {
+			string.append("]");
+			return string.toString();
+		} else {
+			string.append(cureeTreeNode.toString()).append("]");
+			return string.toString();
+		}
+	}
+	
+	public MyTreeNode<T> insert(T o){
+		MyTreeNode<T> newNode = new MyTreeNode<T>();
+		MyTreeNode<T> current = null;
+		newNode.setData(o);
+		if (root == null) {
+			root = newNode;
+			cureeTreeNode = newNode;//����
+			return newNode;
+		}
+		else {
+			Digui(o, root);
+			current = cureeTreeNode;
+			if (current.getData().compareTo(o) == -1) {
+				current.right = newNode;
+			} else {
+				current.left = newNode;
+			}
+			cureeTreeNode = newNode; //����
+			return newNode;
+		}		
+		
+	}
+	
+	public void Digui(T o,MyTreeNode<T> parentnode){
+		cureeTreeNode = parentnode;
+		if (parentnode.left!= null) {
+			if (parentnode.getData().compareTo(o) == -1) {
+				parentnode = parentnode.right;
+				Digui(o, parentnode);
+			} 		
+			else
+			return;
+		}
+		if (parentnode.right != null) {
+			if (parentnode.getData().compareTo(o) == 1) {
+				parentnode = parentnode.left;
+				Digui(o, parentnode);
+			} 		
+			else
+			return;
+		}
+	}
+	
+	public void preOrder(MyTreeNode<T> root) {  
+        visit(root);  
+        if(root.getLeft() != null) {  
+            preOrder(root.getLeft());  
+        }  
+        if(root.getRight() != null) {  
+            preOrder(root.getRight());  
+        } 
+	}
+	
+	public void visit(MyTreeNode<T> btree) {  
+        System.out.print(btree.getData() + "\t");  
+    }  
+}
diff --git "a/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/SingleLinkedList.java" "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/SingleLinkedList.java"
new file mode 100644
index 0000000000..a9e72ed4fa
--- /dev/null
+++ "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/SingleLinkedList.java"
@@ -0,0 +1,212 @@
+package BasicData;
+
+import java.util.NoSuchElementException;
+
+import javax.lang.model.element.Element;
+
+public class SingleLinkedList<T> implements MyList<T> {
+
+	private int msize;// ��¼Ԫ�صĸ���
+	Note<T> head;// ָ���һ��Ԫ��
+	Note<T> last;// ָ�����һ��Ԫ��
+
+	private static class Note<T> {
+		private T item = null;
+		Note<T> next = null;
+
+		public Note(T t) {
+			this.item = t;
+		}
+	}
+
+	public SingleLinkedList() {
+
+	}
+
+	@Override
+	public boolean add(T t) {
+		// TODO Auto-generated method stub
+		final Note<T> l = last;
+		final Note<T> newNote = new Note<T>(t);
+		last = newNote;
+		if (l == null) {
+			head = newNote;// ֻ������һ��nullԪ��
+		} else {
+			l.next = last;
+		}
+		msize++;
+		return true;
+	}
+
+	@Override
+	public void add(int index, T t) {
+		// TODO Auto-generated method stub
+		if (index < 0 || index > msize) {
+			throw new IndexOutOfBoundsException();
+		}
+		if (index == 0) {
+			addFirst(t);
+		}
+		if (index == msize) {
+			add(t);
+		}
+		Note<T> current = head;
+		for (int i = 0; i < index - 1; i++) {
+			current = current.next;
+		}
+		final Note<T> newNote = new Note<T>(t);
+		newNote.next = current.next;
+		current.next = newNote;
+		msize++;
+
+	}
+
+	public boolean addFirst(T t) {
+		final Note<T> newNote = new Note<T>(t);
+		newNote.next = head;
+		head = newNote;
+		msize++;
+		return true;
+	}
+
+	public boolean addLast(T t) {
+		final Note<T> newNote = new Note<T>(t);
+		newNote.next = null;
+		last.next = newNote;
+		last = newNote;
+		msize++;
+		return true;
+	}
+
+	public T removeLast() throws Exception {
+		if (head == null) {
+			throw new Exception("LinkedList is Empty!");
+		}
+		Note<T> current = head;
+		if (head.next == null) {
+			head = null;
+			last = null;
+		} else {
+			while (current.next != null) {
+				if (current.next == last) {
+					last = current;
+					last.next = null;
+					break;
+				}
+				current = current.next;
+			}
+
+		}
+		msize--;
+		return current.item;
+
+	}
+
+	public T removeFirst() throws Exception {
+		if (head == null) {
+			throw new Exception("LinkedList is Empty!");
+		}
+		Note<T> element = head;
+		head = head.next;
+		msize--;
+		return element.item;
+	}
+
+	@Override
+	public int size() {
+		// TODO Auto-generated method stub
+		return msize;
+	}
+
+	@Override
+	public T remove(int index) {
+		// TODO Auto-generated method stub
+		if (index < 0 || index > msize) {
+			throw new IndexOutOfBoundsException();
+		}
+		Note<T> element;
+		if (index == 0) {
+			element = head;
+			head = head.next;
+			msize--;
+			return element.item;
+		}
+		Note<T> current = head;
+		for (int i = 0; i < index - 1; i++) {
+			current = current.next;
+		}
+		element = current.next;
+		if (index == msize) {
+			current.next = null;
+			last = current;
+		} else {
+			current.next = current.next.next;
+		}
+
+		msize--;
+		return element.item;
+	}
+
+	@Override
+	public boolean set(int index, T t) {
+		// TODO Auto-generated method stub
+		if (index < 0 || index > msize) {
+			throw new IndexOutOfBoundsException();
+		}
+		Note<T> current = head;
+		for (int i = 0; i < index; i++) {
+			current = head.next;
+		}
+		current.item = t;
+		return true;
+	}
+
+	@Override
+	public T get(int index) {
+		// TODO Auto-generated method stub
+		if (index < 0 || index > msize) {
+			throw new IndexOutOfBoundsException();
+		}
+		Note<T> current = head;
+		for (int i = 0; i < index; i++) {
+			current = current.next;
+		}
+		return current.item;
+	}
+
+	public MyIterator<T> iterator() {
+		return new MyLinkedListIterator();
+	}
+
+	private class MyLinkedListIterator implements MyIterator<T> {
+
+		private int current = 0;
+		private Note<T> nextNote = head;
+
+		@Override
+		public boolean hasNext() {
+			// TODO Auto-generated method stub
+			return current < msize;
+		}
+
+		@Override
+		public T Next() {
+			// TODO Auto-generated method stub
+			if (!hasNext()) {
+				throw new NoSuchElementException();
+			} else {
+				current++;
+				Note<T> eleNote = nextNote;
+				if (last == nextNote) {
+					nextNote = null;
+				} else {
+					nextNote = nextNote.next;
+				}
+				return eleNote.item;
+
+			}
+
+		}
+	}
+
+}
diff --git "a/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/\346\226\207\347\253\240\345\234\260\345\235\200" "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/\346\226\207\347\253\240\345\234\260\345\235\200"
new file mode 100644
index 0000000000..2ebe35c33a
--- /dev/null
+++ "b/group20/925290009/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232/\346\226\207\347\253\240\345\234\260\345\235\200"
@@ -0,0 +1 @@
+[文章链接](http://blog.csdn.net/u011371324/article/details/57146892)
diff --git a/liuxin/.classpath b/liuxin/.classpath
index fceb4801b5..b387714202 100644
--- a/liuxin/.classpath
+++ b/liuxin/.classpath
@@ -1,6 +1,7 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/liuxin/src/com/coderising/array/ArrayUtil.java b/liuxin/src/com/coderising/array/ArrayUtil.java
new file mode 100644
index 0000000000..78845d06d0
--- /dev/null
+++ b/liuxin/src/com/coderising/array/ArrayUtil.java
@@ -0,0 +1,96 @@
+package com.coderising.array;
+
+public class ArrayUtil {
+	
+	/**
+	 * 给定一个整形数组a , 对该数组的值进行置换
+		例如： a = [7, 9 , 30, 3]  ,   置换后为 [3, 30, 9,7]
+		如果     a = [7, 9, 30, 3, 4] , 置换后为 [4,3, 30 , 9,7]
+	 * @param origin
+	 * @return
+	 */
+	public void reverseArray(int[] origin){
+		
+	}
+	
+	/**
+	 * 现在有如下的一个数组：   int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}   
+	 * 要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：   
+	 * {1,3,4,5,6,6,5,4,7,6,7,5}  
+	 * @param oldArray
+	 * @return
+	 */
+	
+	public int[] removeZero(int[] oldArray){
+		return null;
+	}
+	
+	/**
+	 * 给定两个已经排序好的整形数组， a1和a2 ,  创建一个新的数组a3, 使得a3 包含a1和a2 的所有元素， 并且仍然是有序的
+	 * 例如 a1 = [3, 5, 7,8]   a2 = [4, 5, 6,7]    则 a3 为[3,4,5,6,7,8]    , 注意： 已经消除了重复
+	 * @param array1
+	 * @param array2
+	 * @return
+	 */
+	
+	public int[] merge(int[] array1, int[] array2){
+		return  null;
+	}
+	/**
+	 * 把一个已经存满数据的数组 oldArray的容量进行扩展， 扩展后的新数据大小为oldArray.length + size
+	 * 注意，老数组的元素在新数组中需要保持
+	 * 例如 oldArray = [2,3,6] , size = 3,则返回的新数组为
+	 * [2,3,6,0,0,0]
+	 * @param oldArray
+	 * @param size
+	 * @return
+	 */
+	public int[] grow(int [] oldArray,  int size){
+		return null;
+	}
+	
+	/**
+	 * 斐波那契数列为：1，1，2，3，5，8，13，21......  ，给定一个最大值， 返回小于该值的数列
+	 * 例如， max = 15 , 则返回的数组应该为 [1，1，2，3，5，8，13]
+	 * max = 1, 则返回空数组 []
+	 * @param max
+	 * @return
+	 */
+	public int[] fibonacci(int max){
+		return null;
+	}
+	
+	/**
+	 * 返回小于给定最大值max的所有素数数组
+	 * 例如max = 23, 返回的数组为[2,3,5,7,11,13,17,19]
+	 * @param max
+	 * @return
+	 */
+	public int[] getPrimes(int max){
+		return null;
+	}
+	
+	/**
+	 * 所谓“完数”， 是指这个数恰好等于它的因子之和，例如6=1+2+3
+	 * 给定一个最大值max， 返回一个数组， 数组中是小于max 的所有完数
+	 * @param max
+	 * @return
+	 */
+	public int[] getPerfectNumbers(int max){
+		return null;
+	}
+	
+	/**
+	 * 用seperator 把数组 array给连接起来
+	 * 例如array= [3,8,9], seperator = "-"
+	 * 则返回值为"3-8-9"
+	 * @param array
+	 * @param s
+	 * @return
+	 */
+	public String join(int[] array, String seperator){
+		return null;
+	}
+	
+
+}
diff --git a/liuxin/src/com/coderising/litestruts/LoginAction.java b/liuxin/src/com/coderising/litestruts/LoginAction.java
new file mode 100644
index 0000000000..1005f35a29
--- /dev/null
+++ b/liuxin/src/com/coderising/litestruts/LoginAction.java
@@ -0,0 +1,39 @@
+package com.coderising.litestruts;
+
+/**
+ * 这是一个用来展示登录的业务类， 其中的用户名和密码都是硬编码的。
+ * @author liuxin
+ *
+ */
+public class LoginAction{
+    private String name ;
+    private String password;
+    private String message;
+
+    public String getName() {
+        return name;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public String execute(){
+            if("test".equals(name) && "1234".equals(password)){
+                this.message = "login successful";
+                return "success";
+            }
+            this.message = "login failed,please check your user/pwd";
+            return "fail";
+    }
+
+    public void setName(String name){
+        this.name = name;
+    }
+    public void setPassword(String password){
+        this.password = password;
+    }
+    public String getMessage(){
+        return this.message;
+    }
+}
diff --git a/liuxin/src/com/coderising/litestruts/Struts.java b/liuxin/src/com/coderising/litestruts/Struts.java
new file mode 100644
index 0000000000..44cc35bf01
--- /dev/null
+++ b/liuxin/src/com/coderising/litestruts/Struts.java
@@ -0,0 +1,34 @@
+package com.coderising.litestruts;
+
+import java.util.Map;
+
+
+
+public class Struts {
+
+    public static View runAction(String actionName, Map<String,String> parameters) {
+
+        /*
+         
+		0. 读取配置文件struts.xml
+ 		
+ 		1. 根据actionName找到相对应的class ， 例如LoginAction,   通过反射实例化（创建对象）
+		据parameters中的数据，调用对象的setter方法， 例如parameters中的数据是 
+		("name"="test" ,  "password"="1234") ,     	
+		那就应该调用 setName和setPassword方法
+		
+		2. 通过反射调用对象的exectue 方法， 并获得返回值，例如"success"
+		
+		3. 通过反射找到对象的所有getter方法（例如 getMessage）,  
+		通过反射来调用， 把值和属性形成一个HashMap , 例如 {"message":  "登录成功"} ,  
+		放到View对象的parameters
+		
+		4. 根据struts.xml中的 <result> 配置,以及execute的返回值，  确定哪一个jsp，  
+		放到View对象的jsp字段中。
+        
+        */
+    	
+    	return null;
+    }    
+
+}
diff --git a/liuxin/src/com/coderising/litestruts/StrutsTest.java b/liuxin/src/com/coderising/litestruts/StrutsTest.java
new file mode 100644
index 0000000000..a44c1878ac
--- /dev/null
+++ b/liuxin/src/com/coderising/litestruts/StrutsTest.java
@@ -0,0 +1,43 @@
+package com.coderising.litestruts;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+
+
+
+
+public class StrutsTest {
+
+	@Test
+	public void testLoginActionSuccess() {
+		
+		String actionName = "login";
+        
+		Map<String,String> params = new HashMap<String,String>();
+        params.put("name","test");
+        params.put("password","1234");
+        
+        
+        View view  = Struts.runAction(actionName,params);        
+        
+        Assert.assertEquals("/jsp/homepage.jsp", view.getJsp());
+        Assert.assertEquals("login successful", view.getParameters().get("message"));
+	}
+
+	@Test
+	public void testLoginActionFailed() {
+		String actionName = "login";
+		Map<String,String> params = new HashMap<String,String>();
+        params.put("name","test");
+        params.put("password","123456"); //密码和预设的不一致
+        
+        View view  = Struts.runAction(actionName,params);        
+        
+        Assert.assertEquals("/jsp/showLogin.jsp", view.getJsp());
+        Assert.assertEquals("login failed,please check your user/pwd", view.getParameters().get("message"));
+	}
+}
diff --git a/liuxin/src/com/coderising/litestruts/View.java b/liuxin/src/com/coderising/litestruts/View.java
new file mode 100644
index 0000000000..0194c681f6
--- /dev/null
+++ b/liuxin/src/com/coderising/litestruts/View.java
@@ -0,0 +1,23 @@
+package com.coderising.litestruts;
+
+import java.util.Map;
+
+public class View {
+	private String jsp;
+	private Map parameters;
+	
+	public String getJsp() {
+		return jsp;
+	}
+	public View setJsp(String jsp) {
+		this.jsp = jsp;
+		return this;
+	}
+	public Map getParameters() {
+		return parameters;
+	}
+	public View setParameters(Map parameters) {
+		this.parameters = parameters;
+		return this;
+	}
+}
diff --git a/liuxin/src/com/coderising/litestruts/struts.xml b/liuxin/src/com/coderising/litestruts/struts.xml
new file mode 100644
index 0000000000..99063bcb0c
--- /dev/null
+++ b/liuxin/src/com/coderising/litestruts/struts.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<struts>
+    <action name="login" class="com.coderising.action.LoginAction">
+        <result name="success">/jsp/homepage.jsp</result>
+        <result name="fail">/jsp/showLogin.jsp</result>
+    </action>
+    <action name="logout" class="com.coderising.action.LogoutAction">
+    	<result = "success">/jsp/welcome.jsp</result>
+    	<result = "error">/jsp/error.jsp</result>
+    </action>
+</struts>
\ No newline at end of file
