diff --git a/group22/910725683/RemoteSystemsTempFiles/.project b/group22/910725683/RemoteSystemsTempFiles/.project
new file mode 100644
index 0000000000..5447a64fa9
--- /dev/null
+++ b/group22/910725683/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/group22/910725683/week01/.classpath b/group22/910725683/week01/.classpath
new file mode 100644
index 0000000000..1b83178c00
--- /dev/null
+++ b/group22/910725683/week01/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="test"/>
+	<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/group22/910725683/week01/.gitignore b/group22/910725683/week01/.gitignore
new file mode 100644
index 0000000000..6a59c3a991
--- /dev/null
+++ b/group22/910725683/week01/.gitignore
@@ -0,0 +1,4 @@
+/bin/
+/.settings/
+.classpatch
+.prject
\ No newline at end of file
diff --git a/group22/910725683/week01/.project b/group22/910725683/week01/.project
new file mode 100644
index 0000000000..3b3c4fa7ee
--- /dev/null
+++ b/group22/910725683/week01/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>week01</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/group22/910725683/week01/src/com/coding/basic/ArrayList.java b/group22/910725683/week01/src/com/coding/basic/ArrayList.java
new file mode 100644
index 0000000000..acc0e9f8f4
--- /dev/null
+++ b/group22/910725683/week01/src/com/coding/basic/ArrayList.java
@@ -0,0 +1,98 @@
+package com.coding.basic;
+import java.util.Arrays;
+
+public class ArrayList implements List {
+	
+	//数组初始容量//
+	private final int DEFAULT_CAPICITY=7;
+	
+	//数组元素个数//
+	private int size = 0;
+	
+	private Object[] elementData = new Object[DEFAULT_CAPICITY];
+	
+	public void add(Object o){
+		ensureCapcity(size+1);
+		elementData[size++]=o;
+	}
+	public void add(int index, Object o){
+		//index要连续的增加//
+		checkIndex(index);
+		ensureCapcity(size+1);
+		/* index及后面的元素左移一位,即从index开始移动，注意index从0开始，
+		 * 即还要+1，则长度为size-((index)+1)+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 temp=elementData[index];
+		/* index后面的元素左移一位,即从index+1开始移动，注意index从0开始，
+		 * 即还要+1，则长度为size-((index+1)+1)+1
+		 */
+		System.arraycopy(elementData, index+1, elementData, index, size-index-1);
+		size--;
+		return temp;
+	}
+	
+	public int size(){
+		return size;
+	}
+	
+	public Iterator iterator(){
+		return new Iterator();
+	}
+	
+	private class Iterator{
+		private int index=0;
+		public boolean hasNext(){
+			return index<size;
+		}
+		public Object next(){
+			checkIndex(index);
+			return elementData[index++];
+		}
+	}
+	
+	//判断请求的下标是否越界并提示//
+	private void checkIndex(int index){
+		if (index<0 || index >=size){
+			throw new IndexOutOfBoundsException("get " + index+" in "+size);
+		}		
+	}
+	
+	//判断是否需要扩容并完成扩容//
+	private void ensureCapcity(int size){
+		int oldLength=elementData.length;
+		if (size>=oldLength){
+			//util.ArrayList中的公式，源代码使用的右移1，即除2//
+			int newLength=oldLength/2+oldLength;
+			if (newLength<size){
+				newLength=size;
+			}
+			//Arrays.copyOf返回新的指定长度的数组//
+			elementData=Arrays.copyOf(elementData, newLength);
+		}
+	}
+
+	@Override
+	public String toString(){
+		//方便检查重写了toString//
+		StringBuilder sb = new StringBuilder("[");
+		for (int i=0 ;i<size-1;i++){
+			sb.append(elementData[i]+",");
+		}
+		sb.append(elementData[size-1]);
+		sb.append("]");
+		return sb.toString();
+	}
+	
+}
\ No newline at end of file
diff --git a/group22/910725683/week01/src/com/coding/basic/BinaryTreeNode.java b/group22/910725683/week01/src/com/coding/basic/BinaryTreeNode.java
new file mode 100644
index 0000000000..367ae32ef9
--- /dev/null
+++ b/group22/910725683/week01/src/com/coding/basic/BinaryTreeNode.java
@@ -0,0 +1,110 @@
+package com.coding.basic;
+
+/**
+ * 实际上是一个二叉搜索树BinarySearchTree
+ */
+public class BinaryTreeNode {
+	
+	//根节点this//
+	private Object data;
+	private BinaryTreeNode left;
+	private BinaryTreeNode right;
+	
+	public BinaryTreeNode () {}
+	
+	public BinaryTreeNode(Object o) {
+		this.data=o;
+		this.left=null;
+		this.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 preOrder(BinaryTreeNode node) {
+		if (node.data!=null) {
+			System.out.print(node.data + " ");
+			if (node.left!=null) {
+				preOrder(node.left);
+			}
+			if (node.right!=null) {
+				preOrder(node.right);
+			}
+		}
+	}
+	
+	//中序遍历，左根右//
+	public void inOrder(BinaryTreeNode node) {
+		if (node.data!=null) {
+			if (node.left!=null) {
+				inOrder(node.left);
+			}
+			System.out.print(node.data + " ");
+			if (node.right!=null) {
+				inOrder(node.right);
+			}
+		}
+	}
+	
+	//后序遍历，左右根//
+	public void postOrder(BinaryTreeNode node) {
+		if (node.data!=null) {
+			if (node.left!=null) {
+				postOrder(node.left);
+			}
+			if (node.right!=null) {
+				postOrder (node.right);
+			}
+			System.out.print(node.data + " ");
+		}
+	}
+	
+	public BinaryTreeNode insert(Object o){
+		//先看看根节点是不是空的//
+		if (this.data==null){
+			this.data=o;
+			return this;
+		}else{
+			//小的去左边，大的去右边//
+			if ((int) o < (int) this.data){
+				/*若左边是空的那就是你了，链上一个新的节点
+				 *若左边不是空的则继续往下找空的
+				 */
+				if (this.left==null){
+					this.left = new BinaryTreeNode(o);
+					return this.left;
+				}else{
+					
+					return this.left.insert(o);
+				}
+			}else{
+				/*若右边是空的那就是你了，链上一个新的节点
+				 *若右边不是空的则继续往下找空的
+				 */
+				if (this.right==null){
+					this.right = new BinaryTreeNode(o);
+					return this.right;
+				}else{
+					return this.right.insert(o);
+				}				
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/group22/910725683/week01/src/com/coding/basic/Iterator.java b/group22/910725683/week01/src/com/coding/basic/Iterator.java
new file mode 100644
index 0000000000..7c02cc6e51
--- /dev/null
+++ b/group22/910725683/week01/src/com/coding/basic/Iterator.java
@@ -0,0 +1,7 @@
+package com.coding.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}
\ No newline at end of file
diff --git a/group22/910725683/week01/src/com/coding/basic/LinkedList.java b/group22/910725683/week01/src/com/coding/basic/LinkedList.java
new file mode 100644
index 0000000000..1de78b3970
--- /dev/null
+++ b/group22/910725683/week01/src/com/coding/basic/LinkedList.java
@@ -0,0 +1,327 @@
+package com.coding.basic;
+
+
+public class LinkedList implements List {
+	
+	//链表头//
+	private Node head;
+	
+	//链表尾，为了方便加上的//
+	private Node tail;
+	
+	//链表长度，为了方便加上的//
+	private int size=0;
+	
+	private static class Node{
+		Object data;
+		Node next=null;
+	}
+	
+	public void add(Object o){
+		/*如果是空的则从头开始增加，因为要标记链表头，链表尾额外的标记下
+		 *如果不是空的则从尾巴开始增加，因为要标记链表尾
+		 */
+		if (head==null){
+			addFirst(o);
+			tail=head;
+		}else{
+			addLast(o);
+		}
+	}
+	
+	public void add(int index , Object o){
+		//头尾单独增加，方便维护标记//
+		if (index==0){
+			addFirst(o);
+			return;
+		}
+		if (index==size){
+			addLast(o);
+			return;
+		}
+		checkIndex(index);
+		Node current = getNode(index-1);
+		Node node = new Node();
+		node.data=o;
+		node.next=current.next;
+		current.next=node;
+		size++;
+	}
+	
+	//按照下标获取节点，方便跟下标有关的增查删改//
+	private Node getNode(int index){
+		checkIndex(index);
+		Node current = head;
+		for (int i=0;i<index;i++){
+			current=current.next;
+		}
+		return current;
+	}
+	
+	public Object get(int index){
+		return getNode(index).data;
+	}
+	
+	public Object remove(int index){
+		//头尾单独处理，方便维护标记//
+		if (index==0){
+			return removeFirst();
+		}
+		if (index==size-1){
+			return removeLast();			
+		}
+		checkIndex(index);
+		Node current = getNode(index-1);
+		Node temp = current.next;
+		current.next=temp.next;
+		size--;
+		return temp.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;
+		tail.next=node;
+		tail=node;//标记链表尾//
+		size++;		
+	}
+	public Object removeFirst(){
+		Node current = head;
+		head=current.next;//标记链表头//
+		current.next=null;//切断关联//
+		size--;
+		return current.data;
+	}
+	
+	public Object removeLast(){
+		Node current=getNode(size-2);
+		Node temp = current.next;
+		current.next=null;//切断关联//
+		tail=current;//标记链表尾//
+		size--;
+		return temp.data;
+	}
+	
+	public Iterator iterator(){
+		return new Iterator();
+	}
+	
+	private class Iterator{
+		Node current=head;
+		public boolean hasNext(){
+			return current!=null;
+		}
+		public Object next(){
+			if (current==null){
+				throw new IndexOutOfBoundsException("no node");
+			}
+			Node temp =current;
+			current=current.next;
+			return temp.data;
+		}
+	}
+
+	/**
+	 * 把该链表逆置
+	 * 例如链表为 3->7->10 , 逆置后变为  10->7->3
+	 */
+	public void reverse(){
+		/*两个指针，开始的时候指向头跟头后面的一个(前指针、后指针)
+		 *循环：每次向后移动步长1，至后指针移到链表尾，size-1个节点需要移动(size-1)-1次
+		 *先保留前指针的值temp，即当前逆序链表的头，然后再移动前、后指针
+		 *移动后，将前指针的节点连接到逆序链表的头，开始下一次移动
+		 *循环结束后，注意到实际重连的只有旧链表的第二个节点到倒数第个节点，需要单独处理旧链表的头尾节点
+		 *旧链表的尾节点需要链接到逆序链表的头，旧链表的头节点的指针置空，不然会1<->2
+		 *维护头尾标记
+		 */
+		Node current=head;
+		Node currentAfter=current.next;
+		Node temp;
+		for (int i=0;i<size-2;i++){
+			temp=current;
+			current=currentAfter;
+			currentAfter=currentAfter.next;
+			current.next=temp;
+		}
+		currentAfter.next=current;
+		tail=head;
+		tail.next=null;
+		head=currentAfter;
+	}
+	
+	/**
+	 * 删除一个单链表的前半部分
+	 * 例如：list = 2->5->7->8 , 删除以后的值为 7->8
+	 * 如果list = 2->5->7->8->10 ,删除以后的值为7,8,10
+	 */
+	public  void removeFirstHalf(){
+		//int截断，不会有小数//
+		int removeLength = size / 2;
+		for (int i=1;i<=removeLength;i++){
+			removeFirst();
+		}
+	}
+	
+	/**
+	 * 从第i个元素开始， 删除length 个元素 ， 注意i从0开始
+	 * @param i
+	 * @param length
+	 */
+	public  void remove(int i, int length){
+		checkIndex(i);
+		length=length+i-1;
+		if (i+length-1>size){
+			length=size-i;
+		}
+		//从后往前删除，防止越界//
+		for (int k=length;k>=i;k--){
+			remove(k);
+		}
+	}
+	/**
+	 * 假定当前链表和list均包含已升序排列的整数
+	 * 从当前链表中取出那些list所指定的元素
+	 * 例如当前链表 = 11->101->201->301->401->501->601->701
+	 * listB = 1->3->4->6
+	 * 返回的结果应该是[101,301,401,601]  
+	 * @param list
+	 */
+	public int[] getElements(LinkedList list){
+		int indexLength=list.size();
+		int[] result=new int[indexLength];
+		for (int i=0;i<indexLength;i++){
+			int index=(int)list.get(i);
+			if (index>size){
+				result[i]=0;
+			}else{
+				result[i]=(int)list.get(index);
+			}
+		}
+		return result;
+	}
+	
+	/**
+	 * 已知链表中的元素以值递增有序排列，并以单链表作存储结构。
+	 * 从当前链表中中删除在list中出现的元素 
+	 * @param list
+	 */
+	//注意到递增，在外层循环list的时候，保留内层循环的被比较链表的节点的下标并递增即可//
+	public void subtract(LinkedList list){
+		int startIndex=0;
+		Iterator iter=list.iterator();
+		while(iter.hasNext()){
+			int src =(int) iter.next();
+			while(startIndex<size){
+				if (src==(int) get(startIndex)){
+					remove(startIndex);
+					break;
+				}
+				else{
+					startIndex++;
+				}
+			}
+		}
+	}
+	
+	/**
+	 * 已知当前链表中的元素以值递增有序排列，并以单链表作存储结构。
+	 * 删除表中所有值相同的多余元素（使得操作后的线性表中所有元素的值均不相同）
+	 */
+	//注意到递增，保留不需要删除的节点的下标并递增即可//
+	public  void removeDuplicateValues(){
+		int startIndex=1;
+		int scr=(int)head.data;
+		while(startIndex<size){
+			if (scr==(int) get(startIndex)){
+				remove(startIndex);
+			}else{
+				scr=(int) get(startIndex);
+				startIndex++;
+			}
+		}
+	}
+	
+	/**
+	 * 已知链表中的元素以值递增有序排列，并以单链表作存储结构。
+	 * 试写一高效的算法，删除表中所有值大于min且小于max的元素（若表中存在这样的元素）
+	 * @param min
+	 * @param max
+	 */
+	//这个，想用二分法但是是单链表，没想到高效的算法（网上说是B树，然而不会。。。），一个一个比较的//
+	public  void removeRange(int min, int max){
+		Node current=head;
+		Node temp=head;
+		boolean isHeadNoed=true;
+		while(current!=null){
+			if ((int)current.data<min || (int)current.data>max){
+				if (isHeadNoed){
+					current=current.next;
+					removeFirst();
+				}else{
+					temp.next=current.next;
+					current=current.next;
+					size--;
+				}
+			}else{
+				temp=current;
+				current=current.next;
+				isHeadNoed=false;
+			}
+			
+		}
+	}
+	
+	/**
+	 * 假设当前链表和参数list指定的链表均以元素依值递增有序排列（同一表中的元素值各不相同）
+	 * 现要求生成新链表C，其元素为当前链表和list中元素的交集，且表C中的元素有依值递增有序排列
+	 * @param list
+	 */
+	//注意到递增，保留内循环下标位置递增即可//
+	public LinkedList intersection( LinkedList list){
+		LinkedList result = new LinkedList();
+		int startIndex = 0;
+		for (Iterator iter = list.iterator();iter.hasNext();){
+			int src = (int) iter.next();
+			while (startIndex<size){
+				Object tar = get(startIndex);
+				if (src == (int) tar){
+					result.add(tar);
+					break;
+				}else{
+					startIndex++;
+				}
+			}
+		}
+		return result;
+	}
+	
+	private void checkIndex(int index){
+		if (index<0 || index >=size){
+			throw new IndexOutOfBoundsException("get " + index+" in "+size);
+		}
+	}
+	
+	public String toString(){
+		StringBuilder sb = new StringBuilder();
+		Node current = head;
+		for (int i=0;i<size;i++){
+			sb.append(current.data);
+			if (current.next!=null){
+				sb.append("->");
+			}
+			current=current.next;
+		}
+		return sb.toString();
+	}
+}
\ No newline at end of file
diff --git a/group22/910725683/week01/src/com/coding/basic/List.java b/group22/910725683/week01/src/com/coding/basic/List.java
new file mode 100644
index 0000000000..29caa79f69
--- /dev/null
+++ b/group22/910725683/week01/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/group22/910725683/week01/src/com/coding/basic/Queue.java b/group22/910725683/week01/src/com/coding/basic/Queue.java
new file mode 100644
index 0000000000..6e1b288ebc
--- /dev/null
+++ b/group22/910725683/week01/src/com/coding/basic/Queue.java
@@ -0,0 +1,26 @@
+package com.coding.basic;
+
+public class Queue {
+	
+	private LinkedList queue = new LinkedList();
+	
+	public void enQueue(Object o){
+		queue.add(o);
+	}
+	
+	public Object deQueue(){
+		return queue.removeFirst();
+	}
+	
+	public boolean isEmpty(){
+		return queue.size()==0;
+	}
+	
+	public int size(){
+		return queue.size();
+	}
+	
+	public String toString() {
+		return queue.toString();
+ 	}
+}
\ No newline at end of file
diff --git a/group22/910725683/week01/src/com/coding/basic/Stack.java b/group22/910725683/week01/src/com/coding/basic/Stack.java
new file mode 100644
index 0000000000..a8d071b707
--- /dev/null
+++ b/group22/910725683/week01/src/com/coding/basic/Stack.java
@@ -0,0 +1,27 @@
+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();
+	}
+	public String toString() {
+		return elementData.toString();
+	}
+}
\ No newline at end of file
diff --git a/group22/910725683/week01/test/com/coding/basic/ArrayListTest.java b/group22/910725683/week01/test/com/coding/basic/ArrayListTest.java
new file mode 100644
index 0000000000..e0940e8acb
--- /dev/null
+++ b/group22/910725683/week01/test/com/coding/basic/ArrayListTest.java
@@ -0,0 +1,53 @@
+package com.coding.basic;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class ArrayListTest {
+
+	ArrayList al = new ArrayList();
+
+	@Test
+	public void testAddObject() {
+		for (int i=1;i<=5;i++){
+			al.add(i);
+		}
+	}
+
+	@Test
+	public void testAddIntObject() {
+		testAddObject();
+		al.add(3, 12);
+		System.out.println("inser index 3 value 12 : "+al.toString());
+	}
+
+	@Test
+	public void testGet() {
+		testAddObject();
+		System.out.println("get index 4 : "+al.get(4));
+	}
+
+	@Test
+	public void testRemove() {
+		testAddObject();
+		System.out.println("remove index 3 : "+al.remove(3));
+	}
+
+	@Test
+	public void testSize() {
+		testAddObject();
+		System.out.println("get size : "+al.size());
+	}
+
+	@Test
+	public void testIterator() {
+		fail("Not yet implemented");
+	}
+
+	@Test
+	public void testToString() {
+		fail("Not yet implemented");
+	}
+
+}
diff --git a/group22/910725683/week01/test/com/coding/basic/BinaryTreeNodeTest.java b/group22/910725683/week01/test/com/coding/basic/BinaryTreeNodeTest.java
new file mode 100644
index 0000000000..b32b779091
--- /dev/null
+++ b/group22/910725683/week01/test/com/coding/basic/BinaryTreeNodeTest.java
@@ -0,0 +1,47 @@
+package com.coding.basic;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.coding.basic.BinaryTreeNode;
+
+public class BinaryTreeNodeTest {
+	
+	BinaryTreeNode btn = new BinaryTreeNode();
+	
+	@Test
+	public void testPreOrder() {
+		testInsert();
+		System.out.print("preOrde : ");
+		btn.preOrder(btn);
+		System.out.println("");
+	}
+
+	@Test
+	public void testInOrder() {
+		testInsert();
+		System.out.print("inOrder : ");
+		btn.inOrder(btn);
+		System.out.println("");
+	}
+
+	@Test
+	public void testPostOrder() {
+		testInsert();
+		System.out.print("postOrder : ");
+		btn.postOrder(btn);
+		System.out.println("");
+	}
+
+	@Test
+	public void testInsert() {
+		btn.insert(45);
+		btn.insert(24);
+		btn.insert(53);
+		btn.insert(12);
+		btn.insert(37);
+		btn.insert(93);
+	}
+
+}
diff --git a/group22/910725683/week01/test/com/coding/basic/LinkedListTest.java b/group22/910725683/week01/test/com/coding/basic/LinkedListTest.java
new file mode 100644
index 0000000000..2d22e2e92d
--- /dev/null
+++ b/group22/910725683/week01/test/com/coding/basic/LinkedListTest.java
@@ -0,0 +1,137 @@
+package com.coding.basic;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.coding.basic.LinkedList;
+
+public class LinkedListTest {
+	LinkedList ll =new LinkedList();
+	@Test
+	public void testAddObject() {
+		for (int i=0;i<9;i++){
+			ll.add(i);
+		}
+	}
+
+	@Test
+	public void testAddIntObject() {
+		testAddObject();
+		ll.add(4, 22);
+		ll.add(0, 23);
+		System.out.println("add int : " + ll.toString());
+	}
+
+	@Test
+	public void testGet() {
+		testAddObject();
+		System.out.println("get index 3 : "+ll.get(3));
+	}
+
+	@Test
+	public void testRemoveInt() {
+		testAddObject();
+		System.out.println("remove index 5 : "+ll.get(5));
+	}
+
+	@Test
+	public void testSize() {
+		testAddObject();
+		System.out.println("get size : "+ll.size());
+	}
+
+	@Test
+	public void testAddFirst() {
+		testAddObject();
+		ll.addFirst(12);
+		System.out.println("add first : "+ll.toString());
+	}
+
+	@Test
+	public void testAddLast() {
+		testAddObject();
+		ll.addLast(23);
+		System.out.println("add first : "+ll.toString());
+	}
+
+	@Test
+	public void testRemoveFirst() {
+		testAddObject();
+		ll.removeFirst();
+		System.out.println("remove first : "+ll.toString());
+	}
+
+	@Test
+	public void testRemoveLast() {
+		testAddObject();
+		ll.removeLast();
+		System.out.println("remove last : "+ll.toString());
+	}
+
+	@Test
+	public void testReverse() {
+		testAddObject();
+		ll.reverse();
+		System.out.println("reverse : "+ll.toString());
+	}
+
+	@Test
+	public void testRemoveFirstHalf() {
+		testAddObject();
+		ll.removeFirstHalf();
+		System.out.println("remove first half : "+ll.toString());
+	}
+
+	@Test
+	public void testRemoveIntInt() {
+		testAddObject();
+		ll.remove(2, 4);
+		System.out.println("remove index 2 length 4 : "+ll.toString());
+	}
+
+	@Test
+	public void testGetElements() {
+		testAddObject();
+		System.out.println("get index 2 : "+ll.get(2));
+	}
+
+	@Test
+	public void testSubtract() {
+		testAddObject();
+		LinkedList test1 =new LinkedList();
+		for (int i=2;i<5;i++){
+			test1.add(i);
+		}		
+		ll.subtract(test1);
+		System.out.println("subtract "+test1.toString()+" : "+ll.toString());
+	}
+
+	@Test
+	public void testRemoveDuplicateValues() {
+		testAddObject();
+		for (int i=6;i>2;i--){
+			ll.add(i,i);
+		}		
+		ll.removeDuplicateValues();
+		System.out.println("remove dupl : "+ll.toString());
+	}
+
+	@Test
+	public void testRemoveRange() {
+		testAddObject();
+		ll.removeRange(3, 6);
+		System.out.println("remove range[3,6] : "+ll.toString());
+	}
+
+	@Test
+	public void testIntersection() {
+		testAddObject();
+		LinkedList test2 =new LinkedList();
+		for (int i=4;i<14;i=i+2){
+			test2.add(i);
+		}		
+		System.out.println("intersection "+test2.toString()+" : "+ll.intersection(test2));
+	}
+
+}
diff --git a/group22/910725683/week01/test/com/coding/basic/QueueTest.java b/group22/910725683/week01/test/com/coding/basic/QueueTest.java
new file mode 100644
index 0000000000..18cba75d07
--- /dev/null
+++ b/group22/910725683/week01/test/com/coding/basic/QueueTest.java
@@ -0,0 +1,40 @@
+package com.coding.basic;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.coding.basic.Queue;
+
+public class QueueTest {
+	Queue queue = new Queue();
+
+	@Test
+	public void testEnQueue() {
+		for (int i=0;i<10;i++){
+			queue.enQueue(i);
+		}
+	}
+
+	@Test
+	public void testDeQueue() {
+		testEnQueue();
+		for (int i=0;i<3;i++){
+			System.out.println("deQueue : " + queue.deQueue());
+		}
+	}
+
+	@Test
+	public void testIsEmpty() {
+		System.out.println("is empty(true) : "+queue.isEmpty());
+		testEnQueue();
+		System.out.println("is empty(false) : "+queue.isEmpty());
+	}
+
+	@Test
+	public void testSize() {
+		testEnQueue();
+		System.out.println("size : "+queue.size());
+	}
+
+}
diff --git a/group22/910725683/week01/test/com/coding/basic/StackTest.java b/group22/910725683/week01/test/com/coding/basic/StackTest.java
new file mode 100644
index 0000000000..0c8095d79c
--- /dev/null
+++ b/group22/910725683/week01/test/com/coding/basic/StackTest.java
@@ -0,0 +1,48 @@
+package com.coding.basic;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.coding.basic.Stack;
+
+public class StackTest {
+	Stack stack = new Stack();
+
+	@Test
+	public void testPush() {
+		for (int i = 0; i < 10; i++) {
+			stack.push(i);
+		}
+	}
+
+	@Test
+	public void testPop() {
+		testPush();
+		for (int i = 0; i < 3; i++) {
+			System.out.println("pop : "+stack.pop());			
+		}
+	}
+
+	@Test
+	public void testPeek() {
+		testPush();
+		for (int i = 0; i < 3; i++) {
+			System.out.println("peek : "+stack.peek());		
+		}
+	}
+
+	@Test
+	public void testIsEmpty() {
+		System.out.println("is empty(true) : "+stack.isEmpty());
+		testPush();
+		System.out.println("is empty(false) : "+stack.isEmpty());
+	}
+
+	@Test
+	public void testSize() {
+		testPush();
+		System.out.println("size : "+stack.size());
+	}
+
+}