From 90911617860e37b4aa4e6bf1b4e75c87de529b7a Mon Sep 17 00:00:00 2001 From: zzl93 Date: Sun, 12 Mar 2017 10:39:33 +0800 Subject: [PATCH 1/3] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E4=B8=AA=E4=BA=BA?= =?UTF-8?q?=E6=96=87=E4=BB=B6=E5=A4=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- group27/514402862/zzl.md | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 group27/514402862/zzl.md diff --git a/group27/514402862/zzl.md b/group27/514402862/zzl.md new file mode 100644 index 0000000000..e69de29bb2 From 8f8bd04d4a35a526b441c6d18803a1dc3579a1c0 Mon Sep 17 00:00:00 2001 From: zzl93 Date: Sun, 12 Mar 2017 10:54:44 +0800 Subject: [PATCH 2/3] =?UTF-8?q?=E6=8F=90=E4=BA=A4eclipse=E9=9C=80=E8=A6=81?= =?UTF-8?q?=E5=BF=BD=E7=95=A5=E7=9A=84=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.gitignore b/.gitignore index d749cfbd62..4b6833e594 100644 --- a/.gitignore +++ b/.gitignore @@ -19,3 +19,9 @@ rebel.* .rebel.* target + +#eclipse +RemoteSystemsTempFiles +.classpath +.settings +.project \ No newline at end of file From 28295b6b8a475805a2c61a088579b22a1eab640c Mon Sep 17 00:00:00 2001 From: zzl93 Date: Sun, 19 Mar 2017 21:45:49 +0800 Subject: [PATCH 3/3] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E7=AC=AC=E4=B8=80?= =?UTF-8?q?=E5=91=A8=E4=BD=9C=E4=B8=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- group27/514402862/dataStructure/pom.xml | 14 ++ .../src/main/java/com/zzl/util/ArrayList.java | 91 ++++++++++ .../java/com/zzl/util/BinaryTreeNode.java | 34 ++++ .../src/main/java/com/zzl/util/Iterator.java | 6 + .../main/java/com/zzl/util/LinkedList.java | 159 ++++++++++++++++++ .../src/main/java/com/zzl/util/List.java | 13 ++ .../src/main/java/com/zzl/util/Queue.java | 24 +++ .../src/main/java/com/zzl/util/Stack.java | 40 +++++ .../src/main/java/test/TestMain.java | 14 ++ .../test/java/com/zzl/util/ArrayListTest.java | 100 +++++++++++ .../src/test/java/com/zzl/util/Common.java | 28 +++ .../java/com/zzl/util/LinkedListTest.java | 103 ++++++++++++ .../src/test/java/com/zzl/util/QueueTest.java | 44 +++++ .../src/test/java/com/zzl/util/StackTest.java | 54 ++++++ 14 files changed, 724 insertions(+) create mode 100644 group27/514402862/dataStructure/pom.xml create mode 100644 group27/514402862/dataStructure/src/main/java/com/zzl/util/ArrayList.java create mode 100644 group27/514402862/dataStructure/src/main/java/com/zzl/util/BinaryTreeNode.java create mode 100644 group27/514402862/dataStructure/src/main/java/com/zzl/util/Iterator.java create mode 100644 group27/514402862/dataStructure/src/main/java/com/zzl/util/LinkedList.java create mode 100644 group27/514402862/dataStructure/src/main/java/com/zzl/util/List.java create mode 100644 group27/514402862/dataStructure/src/main/java/com/zzl/util/Queue.java create mode 100644 group27/514402862/dataStructure/src/main/java/com/zzl/util/Stack.java create mode 100644 group27/514402862/dataStructure/src/main/java/test/TestMain.java create mode 100644 group27/514402862/dataStructure/src/test/java/com/zzl/util/ArrayListTest.java create mode 100644 group27/514402862/dataStructure/src/test/java/com/zzl/util/Common.java create mode 100644 group27/514402862/dataStructure/src/test/java/com/zzl/util/LinkedListTest.java create mode 100644 group27/514402862/dataStructure/src/test/java/com/zzl/util/QueueTest.java create mode 100644 group27/514402862/dataStructure/src/test/java/com/zzl/util/StackTest.java diff --git a/group27/514402862/dataStructure/pom.xml b/group27/514402862/dataStructure/pom.xml new file mode 100644 index 0000000000..f870b75fce --- /dev/null +++ b/group27/514402862/dataStructure/pom.xml @@ -0,0 +1,14 @@ + + 4.0.0 + com.zzl + dataStructure + 0.0.1-SNAPSHOT + + + + junit + junit + 4.11 + + + \ No newline at end of file diff --git a/group27/514402862/dataStructure/src/main/java/com/zzl/util/ArrayList.java b/group27/514402862/dataStructure/src/main/java/com/zzl/util/ArrayList.java new file mode 100644 index 0000000000..f95f3a4d35 --- /dev/null +++ b/group27/514402862/dataStructure/src/main/java/com/zzl/util/ArrayList.java @@ -0,0 +1,91 @@ +package com.zzl.util; + +import java.util.Arrays; +import java.util.NoSuchElementException; + +public class ArrayList implements List{ + + private static final int DEFAULT_SIZE = 4; + + private int size = 0; + private Object[] elementData = new Object[DEFAULT_SIZE]; + + public void add(Object o){ + ensureCapacity(size + 1); + elementData[size++] = o; + } + + public void add(int index, Object o){ + rangeCheck(index); + + ensureCapacity(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 moveNum = size - index - 1; + if(moveNum > 0) + System.arraycopy(elementData, index+1, elementData, index, moveNum); + + elementData[--size] = null; + return oldValue; + } + + public int size(){ + return size; + } + + public Iterator iterator(){ + return new ArrayListIterator(); + } + + private void rangeCheck(int index){ + if(index > size || index < 0) + throw new IndexOutOfBoundsException("Index:" + index + "size:" + size); + } + + private void ensureCapacity(int minCapacity){ + if(minCapacity <= DEFAULT_SIZE){ + minCapacity = DEFAULT_SIZE; + } + + if(minCapacity - elementData.length > 0) + grow(minCapacity); + } + + private void grow(int minCapacity){ + int oldSize = elementData.length; + int newSize = oldSize + DEFAULT_SIZE; + elementData = Arrays.copyOf(elementData, newSize); + } + + private class ArrayListIterator implements Iterator{ + int cursor; + + @Override + public boolean hasNext() { + return cursor < size; + } + + @Override + public Object next() { + if (hasNext()){ + return elementData[cursor++]; + } + throw new NoSuchElementException(); + } + + } +} diff --git a/group27/514402862/dataStructure/src/main/java/com/zzl/util/BinaryTreeNode.java b/group27/514402862/dataStructure/src/main/java/com/zzl/util/BinaryTreeNode.java new file mode 100644 index 0000000000..37fd8a3d4f --- /dev/null +++ b/group27/514402862/dataStructure/src/main/java/com/zzl/util/BinaryTreeNode.java @@ -0,0 +1,34 @@ +package com.zzl.util; + +public class BinaryTreeNode { + + private Object data; + private BinaryTreeNode left; + private BinaryTreeNode right; + private int size = 0; + + 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){ + data = o; + + return this; + } +} diff --git a/group27/514402862/dataStructure/src/main/java/com/zzl/util/Iterator.java b/group27/514402862/dataStructure/src/main/java/com/zzl/util/Iterator.java new file mode 100644 index 0000000000..33dba5b016 --- /dev/null +++ b/group27/514402862/dataStructure/src/main/java/com/zzl/util/Iterator.java @@ -0,0 +1,6 @@ +package com.zzl.util; + +public interface Iterator { + public boolean hasNext(); + public Object next(); +} diff --git a/group27/514402862/dataStructure/src/main/java/com/zzl/util/LinkedList.java b/group27/514402862/dataStructure/src/main/java/com/zzl/util/LinkedList.java new file mode 100644 index 0000000000..3ddeb2fb25 --- /dev/null +++ b/group27/514402862/dataStructure/src/main/java/com/zzl/util/LinkedList.java @@ -0,0 +1,159 @@ +package com.zzl.util; + +import java.util.NoSuchElementException; + +public class LinkedList implements List{ + + private int size = 0; + private Node head; + private Node last; + + void linkFirst(Object o){ + final Node h = head; + final Node newNode = new Node(o, h); + head = newNode; + if(h == null) + last = newNode; + + size++; + } + + void linkLast(Object o){ + final Node l = last; + final Node newNode = new Node(o, null); + last = newNode; + if(l == null) + head = newNode; + else + l.next = newNode; + + size++; + } + + void linkBefore(Object o, Node succ){ + final Node next = succ.next; + final Node newNode = new Node(o, next); + succ.next = newNode; + size++; + } + + @Override + public void add(Object o) { + linkLast(o); + } + + @Override + public void add(int index, Object o) { + rangeCheck(index); + + if(index == 0) + linkFirst(o); + else if(index == size) + linkLast(o); + else + linkBefore(o, node(index - 1)); + } + + @Override + public Object get(int index) { + rangeCheck(index); + + return node(index).data; + } + + @Override + public Object remove(int index) { + rangeCheck(index); + + return changeNode(node(index), index); + } + + @Override + public int size() { + return size; + } + + public void addFirst(Object o){ + linkFirst(o); + } + + public Object removeFirst(){ + return remove(0); + } + + public Object removeLast(){ + return remove(size - 1); + } + + public Iterator iterator(){ + return new LinkedListIterator(); + } + + private Object changeNode(Node oldNode, int index){ + Object oldNodeValue = oldNode.data; + if(index == 0){ + head = oldNode.next; + }else { + Node oldNodePrev = node(index - 1); + oldNodePrev.next = oldNode.next; + if(null == oldNode.next){ + last = oldNodePrev; + } + } + oldNode.data = null; + oldNode.next = null; + + size--; + return oldNodeValue; + } + + private void rangeCheck(int index){ + if(index > size || index < 0) + throw new IndexOutOfBoundsException("Index:" + index + "size:" + size); + } + + 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; + + private Node(Object o, Node l){ + this.next = l; + this.data = o; + } + } + + private class LinkedListIterator implements Iterator{ + private Node lastReturned; + private Node next; + private int nextIndex; + + LinkedListIterator(){ + next = LinkedList.this.head; + nextIndex = 0; + } + + @Override + public boolean hasNext() { + return nextIndex < size; + } + + @Override + public Object next() { + if (!hasNext()) + throw new NoSuchElementException(); + + lastReturned = next; + next = next.next; + nextIndex++; + return lastReturned.data; + } + + } +} diff --git a/group27/514402862/dataStructure/src/main/java/com/zzl/util/List.java b/group27/514402862/dataStructure/src/main/java/com/zzl/util/List.java new file mode 100644 index 0000000000..7268a54fbf --- /dev/null +++ b/group27/514402862/dataStructure/src/main/java/com/zzl/util/List.java @@ -0,0 +1,13 @@ +package com.zzl.util; + +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/group27/514402862/dataStructure/src/main/java/com/zzl/util/Queue.java b/group27/514402862/dataStructure/src/main/java/com/zzl/util/Queue.java new file mode 100644 index 0000000000..6e2869bd04 --- /dev/null +++ b/group27/514402862/dataStructure/src/main/java/com/zzl/util/Queue.java @@ -0,0 +1,24 @@ +package com.zzl.util; + +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(){ + int len = elementData.size(); + + return len == 0; + } + + public int size(){ + return elementData.size(); + } +} diff --git a/group27/514402862/dataStructure/src/main/java/com/zzl/util/Stack.java b/group27/514402862/dataStructure/src/main/java/com/zzl/util/Stack.java new file mode 100644 index 0000000000..bcaf5fec95 --- /dev/null +++ b/group27/514402862/dataStructure/src/main/java/com/zzl/util/Stack.java @@ -0,0 +1,40 @@ +package com.zzl.util; + +import java.util.EmptyStackException; + +public class Stack { + + private ArrayList elementData = new ArrayList(); + + public void push(Object o){ + elementData.add(o); + } + + public Object pop(){ + Object o; + int len = elementData.size(); + + o = peek(); + elementData.remove(len - 1); + return o; + } + + public Object peek(){ + int len = elementData.size(); + + if(len == 0) + throw new EmptyStackException(); + + return elementData.get(len - 1); + } + + public boolean isEmpty(){ + int len = elementData.size(); + + return len == 0; + } + + public int size(){ + return elementData.size(); + } +} diff --git a/group27/514402862/dataStructure/src/main/java/test/TestMain.java b/group27/514402862/dataStructure/src/main/java/test/TestMain.java new file mode 100644 index 0000000000..1e0a90a0a2 --- /dev/null +++ b/group27/514402862/dataStructure/src/main/java/test/TestMain.java @@ -0,0 +1,14 @@ +package test; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.Queue; +import java.util.Stack; +import java.util.TreeMap; + +public class TestMain { + public static void main(String[] args) { + + } +} diff --git a/group27/514402862/dataStructure/src/test/java/com/zzl/util/ArrayListTest.java b/group27/514402862/dataStructure/src/test/java/com/zzl/util/ArrayListTest.java new file mode 100644 index 0000000000..14cf0f02e0 --- /dev/null +++ b/group27/514402862/dataStructure/src/test/java/com/zzl/util/ArrayListTest.java @@ -0,0 +1,100 @@ +package com.zzl.util; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +public class ArrayListTest { + + private List list; + private ArrayList aList; + + @Before + public void init() { + list = new ArrayList(); + + list.add("1"); + list.add("2"); + list.add("3"); + list.add("4"); + list.add("5"); + + aList = new ArrayList(); + + aList.add("1"); + aList.add("2"); + aList.add("3"); + aList.add("4"); + aList.add("5"); + } + + @Test + public void testAddObject() { + + assertEquals(list.size(), 5); + } + + @Test + public void testAddIntObject() { + + list.add(2, "5"); + + assertEquals(list.get(2), "5"); + assertEquals(list.get(4), "4"); + } + + @Test + public void testGet() { + + String[] str = {"1","2","3","4","5"}; + Common.loop(list, str); + + list.add(4, "6"); + + String[] str1 = {"1","2","3","4","6","5"}; + Common.loop(list, str1); + } + + @Test + public void testRemove() { + + String[] str = {"1","2","4","5"}; + String result = Common.removeTest(list, 2, str); + list.add(2 ,result); + + String[] str1 = {"2","3","4","5"}; + result = Common.removeTest(list, 0, str1); + list.add(0 ,result); + + String[] str2 = {"1","2","3","4"}; + result = Common.removeTest(list, 4, str2); + list.add(4 ,result); + + String[] str3 = {"1","2","3","4","5"}; + Common.loop(list, str3); + } + + @Test + public void testIterator() { + + Iterator it = aList.iterator(); + + assertTrue(it.hasNext()); + assertEquals(it.next(), "1"); + + assertTrue(it.hasNext()); + assertEquals(it.next(), "2"); + + assertTrue(it.hasNext()); + assertEquals(it.next(), "3"); + + assertTrue(it.hasNext()); + assertEquals(it.next(), "4"); + + assertTrue(it.hasNext()); + assertEquals(it.next(), "5"); + + assertFalse(it.hasNext()); + } +} diff --git a/group27/514402862/dataStructure/src/test/java/com/zzl/util/Common.java b/group27/514402862/dataStructure/src/test/java/com/zzl/util/Common.java new file mode 100644 index 0000000000..05eee18628 --- /dev/null +++ b/group27/514402862/dataStructure/src/test/java/com/zzl/util/Common.java @@ -0,0 +1,28 @@ +package com.zzl.util; + +import static org.junit.Assert.assertEquals; + +public class Common { + public static String removeTest(List list,int index, String[] str){ + assertEquals(list.size(), 5); + String result = (String)list.remove(index); + assertEquals(list.size(), 4); + + loop(list,str); + return result; + } + + public static void loop(List list,String[] str){ + for(int i = 0; i < list.size(); i++){ + assertEquals(list.get(i), str[i]); + } + } + + public static void loop(Stack s,String[] str){ + int len = s.size(); + for(int i = len - 1; i >= 0; i--){ + assertEquals(s.peek(), str[i]); + s.pop(); + } + } +} diff --git a/group27/514402862/dataStructure/src/test/java/com/zzl/util/LinkedListTest.java b/group27/514402862/dataStructure/src/test/java/com/zzl/util/LinkedListTest.java new file mode 100644 index 0000000000..c4820fee8b --- /dev/null +++ b/group27/514402862/dataStructure/src/test/java/com/zzl/util/LinkedListTest.java @@ -0,0 +1,103 @@ +package com.zzl.util; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; + +public class LinkedListTest { + + private List list; + private LinkedList aList; + + @Before + public void init() { + list = new LinkedList(); + + list.add("1"); + list.add("2"); + list.add("3"); + list.add("4"); + list.add("5"); + + aList = new LinkedList(); + + aList.add("1"); + aList.add("2"); + aList.add("3"); + aList.add("4"); + aList.add("5"); + } + + @Test + public void testAddObject() { + assertEquals(list.size(), 5); + String[] str = {"1","2","3","4","5"}; + Common.loop(list, str); + } + + @Test + public void testAddIntObject() { + + list.add(3, "6"); + + assertEquals(list.get(3), "6"); + assertEquals(list.get(5), "5"); + + String[] str = {"1","2","3","6","4","5"}; + Common.loop(list, str); + } + + @Test + public void testRemove() { + + String[] str = {"1","2","4","5"}; + String result = Common.removeTest(aList, 2, str); + aList.add(2 ,result); + + String[] str1 = {"2","3","4","5"}; + result = Common.removeTest(aList, 0, str1); + aList.addFirst(result); + + String[] str2 = {"2","3","4","5"}; + aList.removeFirst(); + Common.loop(aList,str2); + aList.addFirst(result); + + String[] str3 = {"1","2","3","4"}; + result = Common.removeTest(aList, 4, str3); + aList.add(4 ,result); + + String[] str4 = {"1","2","3","4"}; + aList.removeLast(); + Common.loop(aList,str4); + aList.add(4 ,result); + + String[] str5 = {"1","2","3","4","5"}; + Common.loop(aList,str5); + } + + @Test + public void testIterator() { + + Iterator it = aList.iterator(); + + assertTrue(it.hasNext()); + assertEquals(it.next(), "1"); + + assertTrue(it.hasNext()); + assertEquals(it.next(), "2"); + + assertTrue(it.hasNext()); + assertEquals(it.next(), "3"); + + assertTrue(it.hasNext()); + assertEquals(it.next(), "4"); + + assertTrue(it.hasNext()); + assertEquals(it.next(), "5"); + + assertFalse(it.hasNext()); + } +} diff --git a/group27/514402862/dataStructure/src/test/java/com/zzl/util/QueueTest.java b/group27/514402862/dataStructure/src/test/java/com/zzl/util/QueueTest.java new file mode 100644 index 0000000000..bc9da8f843 --- /dev/null +++ b/group27/514402862/dataStructure/src/test/java/com/zzl/util/QueueTest.java @@ -0,0 +1,44 @@ +package com.zzl.util; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +public class QueueTest { + + private Queue q; + + @Before + public void init() { + q = new Queue(); + + q.enQueue("1"); + q.enQueue("2"); + q.enQueue("3"); + q.enQueue("4"); + q.enQueue("5"); + } + + @Test + public void testEnQueue() { + assertEquals(q.size(), 5); + + q.deQueue(); + assertEquals(q.size(), 4); + } + + @Test + public void testIsEmpty() { + q = new Queue(); + + assertEquals(q.isEmpty(), true); + + q.enQueue("1"); + assertEquals(q.isEmpty(), false); + + q.deQueue(); + assertEquals(q.isEmpty(), true); + } + +} diff --git a/group27/514402862/dataStructure/src/test/java/com/zzl/util/StackTest.java b/group27/514402862/dataStructure/src/test/java/com/zzl/util/StackTest.java new file mode 100644 index 0000000000..e104c49f45 --- /dev/null +++ b/group27/514402862/dataStructure/src/test/java/com/zzl/util/StackTest.java @@ -0,0 +1,54 @@ +package com.zzl.util; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +public class StackTest { + + private Stack s; + + @Before + public void init() { + s = new Stack(); + + s.push("1"); + s.push("2"); + s.push("3"); + s.push("4"); + s.push("5"); + } + + @Test + public void testPush() { + assertEquals(s.size(), 5); + } + + @Test + public void testPop() { + s.pop(); + + assertEquals(s.size(), 4); + String[] str = {"1","2","3","4"}; + Common.loop(s, str); + } + + @Test + public void testPeek() { + String[] str = {"1","2","3","4","5"}; + Common.loop(s, str); + } + + @Test + public void testIsEmpty() { + assertFalse(s.isEmpty()); + + String[] str = {"1","2","3","4","5"}; + Common.loop(s, str); + assertTrue(s.isEmpty()); + + s.push("1"); + assertFalse(s.isEmpty()); + } +}