截至2017-02-26 23:08:45 ，10组提交的作业

group05/1377699408/.gitignore

@@ -0,0 +1,4 @@
+/bin
+.classpath
+.project
+.settings/

group05/1377699408/作业/20170226/src/list/ArrayList.java

@@ -0,0 +1,54 @@
+package list;
+
+import java.util.Arrays;
+
+public class ArrayList<E> {
+	private transient static int INITIAL_SIZE = 10;
+	private transient int arrayLength;
+	private transient int size;
+	private transient E[] array;
+	public ArrayList(){
+		array = (E[]) new Object[INITIAL_SIZE];
+		arrayLength = INITIAL_SIZE;
+	}
+	public ArrayList(int size){
+		if(size<=0){
+			throw new IllegalArgumentException("参数不可以小于0");
+		}
+		array = (E[])new Object[size];
+		arrayLength = array.length;
+		ensureCapacity(size);
+		this.size = size;
+	}
+	public int size(){
+		return size;
+	}
+	public void add(E e){
+		ensureCapacity(size+1);
+		array[size] = e;
+		size++;
+	}
+	public E get(int index){
+		if(index<0 || index > size){
+			throw new IllegalArgumentException("索引越界");
+		}
+		return array[index];
+
+	}
+	public E set(int index, E e){
+		if(index<0 || index>size){
+			throw new IllegalArgumentException("索引越界");
+		}
+		E result = array[index];
+		array[index] = e;
+		return result;
+	}
+	private void ensureCapacity(int size){
+		E[] oldArray = array;
+		int oldSize = arrayLength;
+		while(size>arrayLength){
+			arrayLength = arrayLength + (arrayLength >> 1);
+			array = Arrays.copyOf(oldArray, arrayLength);
+		}
+	}
+}

group05/1377699408/作业/20170226/src/test/ArrayListTest.java

@@ -0,0 +1,59 @@
+package test;
+
+import junit.framework.TestCase;
+import list.ArrayList;
+
+public class ArrayListTest extends TestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+	}
+
+	public void testArrayList() {
+		ArrayList<Integer> a = new ArrayList<Integer>();
+		assertEquals(a.size(), 0);
+	}
+
+	public void testArrayListInt() {
+		ArrayList<Integer> a = new ArrayList<Integer>(9);
+		assertEquals(a.size(), 9);
+	}
+
+	public void testSize() {
+		ArrayList<Integer> a = new ArrayList<Integer>(9);
+		assertEquals(a.size(), 9);
+		ArrayList<Integer> a2 = new ArrayList<Integer>(100);
+		assertEquals(a2.size(), 100);
+	}
+
+	public void testAdd() {
+		ArrayList<Integer> a = new ArrayList<Integer>();
+		for (int i = 0; i < 1000; i++) {
+			a.add(5);
+			assertEquals(a.size(), i+1);
+			assertEquals(a.get(i), new Integer(5));
+		}
+	}
+
+	public void testGet() {
+		ArrayList<Integer> a = new ArrayList<Integer>();
+		a.add(6);
+		assertEquals(a.get(0), new Integer(6));
+
+	}
+
+	public void testSet() {
+		ArrayList<Integer> a = new ArrayList<Integer>();
+		for (int i = 0; i < 100; i++) {
+			a.add(56);
+		}
+		a.set(5, 66);
+		assertEquals(a.get(5), new Integer(66));
+		assertEquals(a.get(7), new Integer(56));
+	}
+
+}

group10/1363044717/第一次作业(数据结构)/ArrayList.java

@@ -0,0 +1,119 @@
+package com.coding.basic;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+public class ArrayList<E> implements List<E> {
+
+	private int size = 0;
+
+	private Object[] elementData;
+
+	//默认容量
+	private static final int DEFAULT_CAPACITY = 10;
+
+	public ArrayList(int capacity){
+		if(capacity >= 0){
+			elementData = new Object[capacity];
+		}else {
+			throw new IllegalArgumentException("Illegal Capacity: " +
+					capacity);
+		}
+
+	}
+	public ArrayList(){
+		this(DEFAULT_CAPACITY);
+	}
+
+	/**
+	 * 保证集合容量
+	 * @param minCapacity
+	 */
+	private void ensureCapacity(int minCapacity){
+		int oldCapacity = elementData.length;
+		if(minCapacity > oldCapacity){
+			//扩容
+			int newCapacity = oldCapacity + (oldCapacity >> 1) + 1;
+			if(minCapacity - newCapacity > 0){
+				newCapacity = minCapacity;
+			}
+			elementData = Arrays.copyOf(elementData, newCapacity);
+		}
+	}
+	private void checkIndexRange(int index)
+	{
+		if(index >= size || index < 0)
+		{
+			throw new IndexOutOfBoundsException("Index out of bounds, index : " + index);
+		}
+	}
+	public void add(E o){
+		ensureCapacity(size+1);
+		elementData[size++] = o;
+	}
+	public void add(int index, E o){
+		checkIndexRange(index);//检查下标
+		ensureCapacity(size+1);//保证数组容量
+		System.arraycopy(elementData,index,elementData,index + 1,size-index);//数组复制,把index后的元素全部向后移一位
+		elementData[index] = o;//插入元素值
+		size++;//元素size加一
+	}
+
+	@Override
+	public E get(int index) {
+		checkIndexRange(index);//检查下标
+		return (E)elementData[index];
+	}
+
+	@Override
+	public E remove(int index) {
+		E e = this.get(index);
+		int numMoved = size - index - 1;
+		if(numMoved > 0)
+		{
+			System.arraycopy(elementData, index+1, elementData, index, numMoved);//数组复制,把index后的元素全部向前移一位
+		}
+		elementData[--size] = null;//最后一位赋值为null，size-1
+		return e;
+	}
+
+
+	public int size(){
+		return size;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return size == 0;
+	}
+
+	public Iterator iterator(){
+		return new ArrayListIterator(this);
+	}
+
+	private class ArrayListIterator<E> implements Iterator{
+
+		private Object [] array;
+		private int endIndex = 0;
+		private int index = 0;
+
+		public ArrayListIterator(ArrayList list){
+			this.array=list.elementData;
+			this.endIndex = list.size();
+		}
+		@Override
+		public boolean hasNext() {
+			return this.index < this.endIndex;
+		}
+
+		@Override
+		public E next() {
+			if(!this.hasNext()) {
+				throw new NoSuchElementException();//没有元素了
+			} else {
+				return (E)Array.get(this.array, this.index++);
+			}
+		}
+	}
+}

group10/1363044717/第一次作业(数据结构)/BinaryTreeNode.java

@@ -0,0 +1,68 @@
+package com.coding.basic;
+
+
+public class BinaryTreeNode implements Comparable<BinaryTreeNode> {
+    public BinaryTreeNode(Object data) {
+        this.data = data;
+    }
+
+    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 = new BinaryTreeNode(o);
+        insertNode(node);
+        return node;
+    }
+    private void insertNode(BinaryTreeNode node){
+        insertNode(this,node);
+    }
+    private void insertNode(BinaryTreeNode parentNode, BinaryTreeNode node) {
+        if (parentNode.compareTo(node) <= 0) {//数字大于父节点
+            if (parentNode.right == null) {
+                parentNode.right = node;
+                return;
+            }
+            insertNode(parentNode.right, node);
+        } else {
+            if (parentNode.left == null) {
+                parentNode.left = node;
+                return;
+            }
+            insertNode(parentNode.left, node);
+        }
+    }
+
+    @Override
+    public int compareTo(BinaryTreeNode o) {
+        Integer i = (Integer) this.data;
+        return i.compareTo((Integer) o.data);
+    }
+}

group10/1363044717/第一次作业(数据结构)/Iterator.java

@@ -0,0 +1,6 @@
+package com.coding.basic;
+
+public interface Iterator<E> {
+	public boolean hasNext();
+	public E next();
+}

group10/1363044717/第一次作业(数据结构)/JavaTest.java

@@ -0,0 +1,62 @@
+package com.coding.basic;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Created by Mori on 2017/2/21.
+ */
+public class JavaTest {
+    @Test
+    public void testBinaryTreeNode(){
+        BinaryTreeNode node = new BinaryTreeNode(5);
+        node.insert(4);//左
+        node.insert(7);//右
+        node.insert(2);//左左
+        node.insert(6);//右左
+        node.insert(5);//右左左
+        node.insert(6);//右左右
+        System.out.println(node.getData());
+        System.out.println(node.getLeft().getData());
+        System.out.println(node.getRight().getData());
+        System.out.println(node.getLeft().getLeft().getData());
+        System.out.println(node.getRight().getLeft().getData());
+        System.out.println(node.getRight().getLeft().getLeft().getData());
+        System.out.println(node.getRight().getLeft().getRight().getData());
+    }
+    @Test
+    public void testArrayList(){
+        ArrayList<Integer> list =new ArrayList<>();
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        list.add(5);
+        Assert.assertEquals((Object) list.get(2),3);
+        Assert.assertEquals((Object) list.remove(2),3);
+        Assert.assertEquals((Object) list.get(2),5);
+       Iterator listIterator = list.iterator();
+        while (listIterator.hasNext()){
+            System.out.println(listIterator.next());
+        }
+    }
+    @Test
+    public void testLinkedList(){
+        LinkedList<Integer> linkedList = new LinkedList<>();
+        linkedList.add(1);
+        linkedList.add(2);
+        linkedList.add(5);
+        linkedList.addFirst(10);
+        linkedList.add(1,6);
+        // linkedList.removeLast();
+        //linkedList.removeFirst();
+        Iterator linkedListIterator = linkedList.iterator();
+        while (linkedListIterator.hasNext()){
+            System.out.println(linkedListIterator.next());
+        }
+        System.out.println("----");
+        System.out.println(linkedList.remove(0));
+        System.out.println(linkedList.remove(2));
+        //System.out.println(linkedList.get(3));
+        //System.out.println(linkedList.get(4));
+    }
+}