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;
+    }
+}