diff --git a/group10/875867419/.classpath b/group10/875867419/.classpath
new file mode 100644
index 0000000000..d171cd4c12
--- /dev/null
+++ b/group10/875867419/.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/group10/875867419/.gitignore b/group10/875867419/.gitignore
new file mode 100644
index 0000000000..ae3c172604
--- /dev/null
+++ b/group10/875867419/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/group10/875867419/.project b/group10/875867419/.project
new file mode 100644
index 0000000000..b6d8ce6204
--- /dev/null
+++ b/group10/875867419/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>coding2017</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/group10/875867419/src/com/work/week01/MyArrayList.java b/group10/875867419/src/com/work/week01/MyArrayList.java
new file mode 100644
index 0000000000..d005800d39
--- /dev/null
+++ b/group10/875867419/src/com/work/week01/MyArrayList.java
@@ -0,0 +1,203 @@
+package com.work.week01;
+
+import java.io.Serializable;
+import java.util.Arrays;
+
+/**
+ * ʵ��List<E>�ӿڣ�������ķ�ʽʵ���Լ���ArrayList
+ * @author denghuaijun
+ *
+ * @param <E>
+ */
+public class MyArrayList<E> implements MyList<E>,Serializable {
+
+	private static final long serialVersionUID = 4145346362382387995L;
+	
+	/**
+	 * ����<MyArrayList>Ĭ�ϴ�С
+	 */
+	private static final int DEFAULT_CAPACITY = 10; 
+	
+	/**
+	 * ����<MyArrayList>Ĭ�Ͽ�����
+	 */
+	private static final Object[] EMPTY_ELEMENTDATA = {};
+	
+	transient Object[] elementData;
+	
+	/**
+	 * <MyArrayList>��С
+	 */
+	private int size;
+	
+	public MyArrayList(){
+		this.elementData = EMPTY_ELEMENTDATA;
+	}
+	
+	public MyArrayList(int capacity){
+		if(capacity > 0){
+			this.elementData = new Object[capacity];
+		}else if(capacity == 0){
+			this.elementData = EMPTY_ELEMENTDATA;
+		}else{
+			throw new IllegalArgumentException("�Ƿ�����");
+		}
+	}
+	
+	private void ensureCapacity(int minCapacity){
+		if(this.elementData == EMPTY_ELEMENTDATA){
+			minCapacity = Math.max(minCapacity, DEFAULT_CAPACITY);
+		}
+		if(minCapacity > elementData.length){//����λ�ô����������鳤��
+			grow(minCapacity);
+		}
+	}
+	
+	private void grow(int minCapacity){
+		int oldCapacity = elementData.length;	
+		int newCapacity = oldCapacity + (oldCapacity >> 1);
+		if(newCapacity < minCapacity){
+			newCapacity = minCapacity;
+		}
+		elementData = Arrays.copyOf(elementData, newCapacity);
+	}
+
+	@Override
+	public boolean add(E element) {
+		ensureCapacity(size + 1);
+		elementData[size++] = element;
+		return true;
+	}
+
+	@Override
+	public void add(int index, E element) {
+		//ȷ��index�Ƿ�Խ��
+		checkAddRange(index);
+		//ȷ�����鳤���Ƿ��㹻
+		ensureCapacity(size + 1);
+		System.arraycopy(elementData, index, elementData, index + 1, size - index);
+		elementData[index] = element;
+		size++;
+	}
+	
+	private void checkAddRange(int index){
+		if(index < 0 || index > size){//index == size ������������Ԫ��
+			throw new IndexOutOfBoundsException("����Խ��");
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public E get(int index) {
+		checkRange(index);
+		return (E) elementData[index];
+	}
+	
+	private void checkRange(int index){
+		if(index < 0 || index >= size){
+			throw new IndexOutOfBoundsException("����Խ��");
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public E remove(int index) {
+		checkRange(index);
+		E element = (E) elementData[index];
+		int numMoved = size - index - 1;
+		if(numMoved > 0){
+			System.arraycopy(elementData, index + 1, elementData, index, numMoved);
+		}
+		elementData[size--] = null;
+		return element;
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return size == 0;
+	}
+
+	public int indexOf(Object o) {
+		if(o == null){
+			for(int i=0;i<size;i++){
+				if(elementData[i] == null){
+					return i;
+				}
+			}
+		}else{
+			for(int i=0;i<size;i++){
+				if(o.equals(elementData[i])){
+					return i;
+				}
+			}
+		}
+		return -1;
+	}
+
+	public int lastIndexOf(Object o) {
+		if(o == null){
+			for(int i=size-1;i>=0;i--){
+				if(elementData[i] == null){
+					return i;
+				}
+			}
+		}else{
+			for(int i=size-1;i>=0;i--){
+				if(o.equals(elementData[i])){
+					return i;
+				}
+			}
+		}
+		return -1;
+	}
+
+	@Override
+	public MyIterator<E> iterator() {
+		return new MyIter();
+	}
+	
+	private class MyIter implements MyIterator<E>{
+		
+		int flag = -1;
+		
+		public MyIter(){
+			flag = size;	//���鳤��	
+		}
+
+		@Override
+		public boolean hasNext() {
+			return flag > 0;
+		}
+
+		@SuppressWarnings("unchecked")
+		@Override
+		public E next() {
+			if(!hasNext()){
+				throw new IndexOutOfBoundsException("����ֵ�������鷶Χ");
+			}
+			return (E) elementData[size-(flag--)];
+		}
+		
+	}
+	public static void main(String[] args) {
+		MyArrayList<String> array = new MyArrayList<String>();
+		array.add("1");
+		array.add("2");
+		array.add("3");
+		array.add("4");
+		array.remove(2);
+		array.add(2, "1");
+		System.out.println("size="+array.size());
+		System.out.println("indexOf(3)="+array.indexOf("3"));
+		System.out.println("lastIndexOf(1)="+array.lastIndexOf("1"));
+		MyIterator<String> itr = array.iterator();
+		while(itr.hasNext()){
+			System.out.println(itr.next());
+		}
+	}
+}
diff --git a/group10/875867419/src/com/work/week01/MyBinaryTree.java b/group10/875867419/src/com/work/week01/MyBinaryTree.java
new file mode 100644
index 0000000000..8c6f057648
--- /dev/null
+++ b/group10/875867419/src/com/work/week01/MyBinaryTree.java
@@ -0,0 +1,82 @@
+package com.work.week01;
+
+public class MyBinaryTree<E> {
+
+	private MyBinaryTreeNode<E> parent;
+	
+	public MyBinaryTree(){
+		this.parent = new MyBinaryTreeNode<E>(null, null, null);
+	}
+	
+	public void insertNode(E element){
+		MyBinaryTreeNode<E> node = new MyBinaryTreeNode<E>(element, null, null);
+		if(parent.element == null){
+			parent = node;
+			return;
+		}
+		insertNode(parent, node);
+	}
+	
+	private void insertNode(MyBinaryTreeNode<E> parentNode, MyBinaryTreeNode<E> newNode){
+		if(parentNode.compareTo(newNode) <= 0){//
+			if(parentNode.right == null){
+				parentNode.right = newNode;
+			}else{
+				insertNode(parentNode.right, newNode);
+			}
+		}else{
+			if(parentNode.left == null){
+				parentNode.left = newNode;
+			}else{
+				insertNode(parentNode.left, newNode);
+			}
+		}
+	}
+
+	private void printNode(MyBinaryTreeNode<E> node, int count){
+		if(node.left != null){
+			printNode(node.left, count++);
+		}
+		if(node.right != null){
+			printNode(node.right, count++);
+		}
+		for(int i=0;i<count;i++){
+			System.out.println();
+		}
+		System.out.print(node.element);
+	}
+	
+	public void printTree(){
+		printNode(this.parent, 0);
+	}
+	
+	private class MyBinaryTreeNode<T> implements Comparable<MyBinaryTreeNode<T>> {
+
+		private T element;
+		private MyBinaryTreeNode<T> left;
+		private MyBinaryTreeNode<T> right;
+		
+		public MyBinaryTreeNode(T element, MyBinaryTreeNode<T> left, MyBinaryTreeNode<T> right){
+			this.element = element;
+			this.left = left;
+			this.right = right;
+		}
+		
+		@Override
+		public int compareTo(MyBinaryTreeNode<T> o) {
+			Integer src = (Integer) this.element;
+			Integer dest = (Integer) o.element;
+			return src.compareTo(dest);
+		}
+	}
+	
+	public static void main(String[] args) {
+		MyBinaryTree<Integer> tree = new MyBinaryTree<Integer>();
+		tree.insertNode(5);
+		tree.insertNode(7);
+		tree.insertNode(3);
+		tree.insertNode(9);
+		tree.insertNode(4);
+		tree.printTree();
+	}
+}
diff --git a/group10/875867419/src/com/work/week01/MyIterator.java b/group10/875867419/src/com/work/week01/MyIterator.java
new file mode 100644
index 0000000000..78abc20f23
--- /dev/null
+++ b/group10/875867419/src/com/work/week01/MyIterator.java
@@ -0,0 +1,6 @@
+package com.work.week01;
+
+public interface MyIterator<E> {
+	boolean hasNext();
+	E next();
+}
diff --git a/group10/875867419/src/com/work/week01/MyLinkedList.java b/group10/875867419/src/com/work/week01/MyLinkedList.java
new file mode 100644
index 0000000000..675323a249
--- /dev/null
+++ b/group10/875867419/src/com/work/week01/MyLinkedList.java
@@ -0,0 +1,169 @@
+package com.work.week01;
+
+import java.io.Serializable;
+
+
+public class MyLinkedList<E> implements MyList<E>, Serializable{
+
+	private static final long serialVersionUID = 8700137302944494769L;
+	
+	transient int size = 0;
+	
+	transient MyNode<E> head;
+	transient MyNode<E> last;
+	
+	public MyLinkedList(){
+		head = new MyNode<E>(null, null);
+		last = new MyNode<E>(null, null);
+	}
+
+	@Override
+	public boolean add(E element) {
+		if(head.element == null){
+			head = new MyNode<E>(element, null);
+			last = head;
+		}else{
+			MyNode<E> node = new MyNode<E>(element, null);
+			last.next = node;
+			last = node;
+		}
+		size++;
+		return true;
+	}
+
+	@Override
+	public void add(int index, E element) {
+		if(index < 0 || index -size > 0){
+			throw new IndexOutOfBoundsException("������������");
+		}
+		if(index == 0){
+			MyNode<E> node = new MyNode<E>(element, null);
+			node.next = head;
+			head = node;
+		}else{
+			MyNode<E> leftNode = getIndexNode(index-1);
+			MyNode<E> node = new MyNode<E>(element, null);
+			node.next = leftNode.next;
+			leftNode.next = node;
+		}
+		size++;
+	}
+	
+	private MyNode<E> getIndexNode(int index){
+		MyNode<E> node = head;
+		for(int i=0; i<index; i++){
+			node = node.next;
+		}
+		return node;
+	}
+
+	@Override
+	public E get(int index) {
+		if(index < 0 || index - size >= 0){
+			throw new IndexOutOfBoundsException("������������");
+		}
+		MyNode<E> node = getIndexNode(index);
+		return node.element;
+	}
+
+	@Override
+	public E remove(int index) {
+		if(index < 0 || index >= size){
+			throw new IndexOutOfBoundsException("������������");
+		}
+		if(index == 0){//�Ƴ�ͷ���
+			MyNode<E> node = head;
+			head = head.next;
+			node.next = null;
+			size--;
+			return node.element;
+		}else{
+			MyNode<E> leftNode = getIndexNode(index-1);
+			MyNode<E> node = leftNode.next;		//���Ƴ��Ľڵ�
+			leftNode.next = node.next;
+			node.next = null;
+			size--;
+			return node.element;
+		}
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return size == 0;
+	}
+	
+	public void addFirst(E element){
+		add(0, element);
+	}
+	
+	public void addLast(E element){
+		add(size, element);
+	}
+	
+	public void removeFirst(){
+		remove(0);
+	}
+	
+	public void removeLast(){
+		remove(size-1);
+	}
+
+	private static class MyNode<E>{
+        E element;
+        MyNode<E> next;
+
+        MyNode(E element, MyNode<E> next) {
+            this.element = element;
+            this.next = next;
+        }
+
+    }
+
+	@Override
+	public MyIterator<E> iterator() {
+		return new MyIter();
+	}
+	
+	private class MyIter implements MyIterator<E>{
+		
+		int flag = 0;
+		
+		public MyIter(){
+			flag = size;
+		}
+
+		@Override
+		public boolean hasNext() {
+			return flag > 0;
+		}
+
+		@Override
+		public E next() {
+			if(!hasNext()){
+				throw new IndexOutOfBoundsException("����ֵ����������Χ");
+			}
+			return get(size-(flag--));
+		}
+	}
+	
+	public static void main(String[] args) {
+		MyLinkedList<String> link = new MyLinkedList<String>();
+		link.add("1");
+		link.add("2");
+		link.add("3");
+		link.add("4");
+		link.add(3, "1");
+		link.removeFirst();
+		System.out.println("size="+link.size());
+		MyIterator<String> itr = link.iterator();
+		while(itr.hasNext()){
+			System.out.println(itr.next());
+		}
+		link.remove(4);
+	}
+}
diff --git a/group10/875867419/src/com/work/week01/MyList.java b/group10/875867419/src/com/work/week01/MyList.java
new file mode 100644
index 0000000000..f7cc918888
--- /dev/null
+++ b/group10/875867419/src/com/work/week01/MyList.java
@@ -0,0 +1,11 @@
+package com.work.week01;
+
+public interface MyList<E>{
+	boolean add(E element);
+	void add(int index, E element);
+	E get(int index);
+	E remove(int index);
+	int size();
+	boolean isEmpty();
+	MyIterator<E> iterator();
+}
diff --git a/group10/875867419/src/com/work/week01/MyQueue.java b/group10/875867419/src/com/work/week01/MyQueue.java
new file mode 100644
index 0000000000..97bca5399a
--- /dev/null
+++ b/group10/875867419/src/com/work/week01/MyQueue.java
@@ -0,0 +1,38 @@
+package com.work.week01;
+
+public class MyQueue<E> {
+	private MyArrayList<E> elementData;
+	
+	public MyQueue(){
+		elementData = new MyArrayList<E>();
+	}
+	
+	public void enQueue(E element){//���
+		elementData.add(element);
+	}
+	
+	public E deQuene(){//����		�Ƚ��ȳ�
+		return elementData.remove(0);
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+	
+	public boolean isEmpty(){
+		return elementData.isEmpty();
+	}
+	
+	public static void main(String[] args) {
+		MyQueue<String> queue = new MyQueue<String>();
+		queue.enQueue("1");
+		queue.enQueue("2");
+		queue.enQueue("3");
+		queue.enQueue("4");
+		queue.enQueue("5");
+		System.out.println("size="+queue.size());
+		while(!queue.isEmpty()){
+			System.out.println(queue.deQuene());
+		}
+	}
+}
diff --git a/group10/875867419/src/com/work/week01/MyStack.java b/group10/875867419/src/com/work/week01/MyStack.java
new file mode 100644
index 0000000000..f82bbe04c1
--- /dev/null
+++ b/group10/875867419/src/com/work/week01/MyStack.java
@@ -0,0 +1,43 @@
+package com.work.week01;
+
+public class MyStack<E> {
+	private MyArrayList<E> elementData;
+	
+	public MyStack(){
+		elementData = new MyArrayList<>();
+	}
+	
+	public void push(E element){
+		elementData.add(element);
+	}
+	
+	public E pop(){		//�Ƴ�ջ��Ԫ��	����ȳ�
+		return elementData.remove(elementData.size() - 1);
+	}
+	
+	public E peek(){	//��ȡջ��Ԫ��
+		return elementData.get(elementData.size() - 1);
+	}
+	
+	public int size(){
+		return elementData.size();
+	}
+	
+	public boolean isEmpty(){
+		return elementData.isEmpty();
+	}
+	
+	public static void main(String[] args) {
+		MyStack<String> stack = new MyStack<String>();
+		stack.push("1");
+		stack.push("2");
+		stack.push("3");
+		stack.push("4");
+		stack.push("5");
+		System.out.println("size="+stack.size());
+		System.out.println("peekջ��Ԫ��="+stack.peek());
+		while(!stack.isEmpty()){
+			System.out.println("popջ��Ԫ��"+stack.pop());
+		}
+	}
+}
diff --git "a/group10/875867419/src/com/work/week01/\345\215\232\346\226\207\344\275\234\344\270\232\345\234\260\345\235\200.txt" "b/group10/875867419/src/com/work/week01/\345\215\232\346\226\207\344\275\234\344\270\232\345\234\260\345\235\200.txt"
new file mode 100644
index 0000000000..5c63425fba
--- /dev/null
+++ "b/group10/875867419/src/com/work/week01/\345\215\232\346\226\207\344\275\234\344\270\232\345\234\260\345\235\200.txt"
@@ -0,0 +1 @@
+������ҵ��ַ��https://my.oschina.net/u/3080511/blog/846172
\ No newline at end of file