diff --git a/.gitignore b/.gitignore index ec55baf87d..ecebe0642e 100644 --- a/.gitignore +++ b/.gitignore @@ -14,3 +14,22 @@ hs_err_pid* #ide config .metadata .recommenders +/bin/ +.idea/workspace.xml +.idea/dictionaries/myj.xml +.idea/ +.DS_Store +*.classpath +*.project +.settings +.project +.target +.classpath +**/.settings +**/.classpath +**/.eclipse +**/target/ +target/ +bin/ +.svn +*.iml \ No newline at end of file diff --git a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/ArrayList.java b/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/ArrayList.java deleted file mode 100644 index c2acf20e4d..0000000000 --- a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/ArrayList.java +++ /dev/null @@ -1,62 +0,0 @@ -package com.github.hwjcc969.coding2017.basic; - -import javax.lang.model.element.Element; - -public class ArrayList implements List { - - private int size = 0; - - private Object[] elementData = new Object[100]; - - public void add(Object o){ - if (o == null){ - throw new NullPointerException("空对象"); - } - if (size >= 100){ - throw new RuntimeException("越界"); - } - elementData[size] = o; - size++; - } - public void add(int index, Object o){ - if (o == null){ - throw new NullPointerException("空对象"); - } - if (index >= 99){ - throw new RuntimeException("越界"); - } - for (int i = size; i >= index; i--) { - elementData[i + 1] = elementData[i]; - } - elementData[index] = o; - size++; - } - - public Object get(int index){ - if (index >= 100 || index < 0){ - throw new RuntimeException("越界"); - } - return elementData[index]; - } - - public Object remove(int index){ - if (index >= 100 || index < 0){ - throw new RuntimeException("越界"); - } - Object o = elementData[index]; - for (int i = index; i < size - 1; i++) { - elementData[i] = elementData[i + 1]; - } - size--; - return null; - } - - public int size(){ - return size; - } - - public Iterator iterator(){ - return null; - } - -} diff --git a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/BinaryTreeNode.java b/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/BinaryTreeNode.java deleted file mode 100644 index 0381f88c69..0000000000 --- a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/BinaryTreeNode.java +++ /dev/null @@ -1,32 +0,0 @@ -package com.github.hwjcc969.coding2017.basic; - -public class BinaryTreeNode { - - 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){ - return null; - } - -} diff --git a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/Iterator.java b/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/Iterator.java deleted file mode 100644 index 0e8394844b..0000000000 --- a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/Iterator.java +++ /dev/null @@ -1,7 +0,0 @@ -package com.github.hwjcc969.coding2017.basic; - -public interface Iterator { - public boolean hasNext(); - public Object next(); - -} diff --git a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/LinkedList.java b/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/LinkedList.java deleted file mode 100644 index d000967c19..0000000000 --- a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/LinkedList.java +++ /dev/null @@ -1,117 +0,0 @@ -package com.github.hwjcc969.coding2017.basic; - -public class LinkedList implements List { - - private Node head; - private int size; - - public void add(Object o){ - Node newNode = new Node(o); - if (head == null) { - head = newNode; - } - else{ - Node last = head.next; - while (last != null){ - last = last.next; - } - last = newNode; - } - size++; - - } - public void add(int index , Object o){ - Node dummy = new Node(); - dummy.next = head; - Node pre = dummy; - while (index > 0) { - pre = pre.next; - } - Node cur = new Node(o); - cur.next = pre.next; - pre.next = cur; - size++; - } - public Object get(int index){ - Node cur = head; - while (index > 0 && cur != null) { - cur = cur.next; - } - return cur; - } - public Object remove(int index){ - Node dummy = new Node(); - dummy.next = head; - Node pre = dummy; - while (index > 0) { - pre = pre.next; - } - Node cur = pre.next; - Node next = pre.next.next; - pre.next = next; - size--; - return cur; - - } - - public int size(){ - return size; - } - - public void addFirst(Object o){ - Node firstNode = new Node(o); - firstNode.next = head; - head = firstNode; - } - public void addLast(Object o){ - Node pre = new Node(); - while (pre.next != null){ - pre = pre.next; - } - Node lastNode = new Node(o); - pre.next = lastNode; - } - public Object removeFirst(){ - Node dummy = new Node(); - dummy.next = head; - dummy.next = head.next; - return dummy.next; - } - public Object removeLast(){ - Node pre = new Node(); - while (pre.next.next != null) { - pre = pre.next; - } - Node lastNode = pre.next.next; - pre.next = null; - return lastNode; - - } - public Iterator iterator(){ - return null; - } - - - private static class Node{ - public Node(Object o) { - // TODO Auto-generated constructor stub - } - public Node() { - // TODO Auto-generated constructor stub - } - Object data; - Node next; - - } - - - public boolean isEmpty() { - // TODO Auto-generated method stub - if (size() == 0){ - return false; - } - return true; - } - - -} diff --git a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/Queue.java b/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/Queue.java deleted file mode 100644 index f7cb7b1ad4..0000000000 --- a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/Queue.java +++ /dev/null @@ -1,27 +0,0 @@ -package com.github.hwjcc969.coding2017.basic; - -public class Queue { - private LinkedList list = new LinkedList(); - public void enQueue(Object o){ - list.addLast(o); - } - - public Object deQueue(){ - if (!list.isEmpty()){ - return list.removeFirst(); - } - return "空队列"; - - } - - public boolean isEmpty(){ - if (list.size() == 0){ - return false; - } - return true; - } - - public int size(){ - return list.size(); - } -} diff --git a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/Stack.java b/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/Stack.java deleted file mode 100644 index a4229a7d12..0000000000 --- a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/Stack.java +++ /dev/null @@ -1,31 +0,0 @@ -package com.github.hwjcc969.coding2017.basic; - -public class Stack { - private ArrayList elementData = new ArrayList(); - private int size = 0; - - public void push(Object o){ - if (elementData.size() <= 99) - elementData.add(o); - size++; - - } - - public Object pop(){ - size--; - return elementData.remove(elementData.size() - 1); - - } - - public Object peek(){ - return elementData.get(elementData.size() - 1); - } - public boolean isEmpty(){ - if (size == 0) - return false; - return true; - } - public int size(){ - return size; - } -} diff --git a/group02/527705641/.gitignore b/group02/527705641/.gitignore new file mode 100644 index 0000000000..ae3c172604 --- /dev/null +++ b/group02/527705641/.gitignore @@ -0,0 +1 @@ +/bin/ diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/ArrayListTest.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/ArrayListTest.java new file mode 100644 index 0000000000..d623dd05e0 --- /dev/null +++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/ArrayListTest.java @@ -0,0 +1,55 @@ +package com.github.fei9009.coding2017.basic; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +public class ArrayListTest { + + private static ArrayList testArray = new ArrayList(); + @Before + public void setUp() throws Exception { + //testArray.clear(); + } + + @Test + public void testArrayList() { + //fail("Not yet implemented"); + } + + @Test + public void testAddObject() { + testArray.add(10); + assertEquals(10, testArray.get(0)); + //fail("Not yet implemented"); + } + + @Test + public void testAddIntObject() { + testArray.add(10); + testArray.add(0, 3); + testArray.add(0, 2); + assertEquals(3, testArray.get(1)); + assertEquals(2, testArray.get(0)); + //fail("Not yet implemented"); + } + + @Test + public void testGet() { + testArray.add(10); + assertEquals(10, testArray.get(0)); + //fail("Not yet implemented"); + } + + @Test + public void testRemove() { + fail("Not yet implemented"); + } + + @Test + public void testSize() { + fail("Not yet implemented"); + } + +} diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/LinkedListTest.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/LinkedListTest.java new file mode 100644 index 0000000000..1eb379a020 --- /dev/null +++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/LinkedListTest.java @@ -0,0 +1,92 @@ +package com.github.fei9009.coding2017.basic; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +public class LinkedListTest { + +private LinkedList aLinkedList; + + @Before + public void setUpLinkedList() { + aLinkedList = new LinkedList(); + } + + @Test + public void testAddFirst() { + aLinkedList.addFirst(5); + assertEquals(5, aLinkedList.get(0)); + + aLinkedList.addFirst(6); + assertEquals(6, aLinkedList.get(0)); + assertEquals(5, aLinkedList.get(1)); + assertEquals(2, aLinkedList.size()); + } + + @Test + public void testAddLast() { + aLinkedList.addLast("hello"); + assertEquals("hello", aLinkedList.get(0)); + + aLinkedList.addLast("world"); + assertEquals("hello", aLinkedList.get(0)); + assertEquals("world", aLinkedList.get(1)); + assertEquals(2, aLinkedList.size()); + } + + @Test + public void testRemoveFirst() { + aLinkedList.addLast("hello"); + aLinkedList.addLast("world"); + + aLinkedList.removeFirst(); + assertEquals("world", aLinkedList.get(0)); + assertEquals(1, aLinkedList.size()); + + aLinkedList.removeFirst(); + assertEquals(0, aLinkedList.size()); + } + + @Test + public void testRemoveLast() { + aLinkedList.addFirst("world"); + aLinkedList.addFirst("hello"); + + aLinkedList.removeLast(); + assertEquals("hello", aLinkedList.get(0)); + assertEquals(1, aLinkedList.size()); + + aLinkedList.removeLast(); + assertEquals(0, aLinkedList.size()); + } + + @Test + public void testLinkedListFunctional() { + for (int i=1; i<4; i++) { + aLinkedList.add(i); // [1,2,3] + } + aLinkedList.remove(1); // [1,3] + + aLinkedList.add(1, 0); // [1,0,3] + for (int i=4; i<6; i++) { + aLinkedList.addFirst(i); // [5, 4, 1, 0, 3] + } + assertEquals(5, aLinkedList.size()); + assertEquals(5, aLinkedList.get(0)); + assertEquals(1, aLinkedList.get(2)); + assertEquals(0, aLinkedList.get(3)); + + aLinkedList.remove(3); // [5, 4, 1, 3] + assertEquals(3, aLinkedList.get(aLinkedList.size()-1)); + aLinkedList.removeLast(); // [5, 4, 1] + assertEquals(1, aLinkedList.get(aLinkedList.size()-1)); + aLinkedList.removeFirst(); // [4,1] + + assertEquals(4, aLinkedList.get(0)); + assertEquals(1, aLinkedList.get(1)); + assertEquals(2, aLinkedList.size()); + } + +} diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/QueueTest.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/QueueTest.java new file mode 100644 index 0000000000..3e2889edc0 --- /dev/null +++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/QueueTest.java @@ -0,0 +1,35 @@ +package com.github.fei9009.coding2017.basic; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +public class QueueTest { + +private Queue queue; + + @Before + public void setUpQueue() { + queue = new Queue(); + } + + @Test + public void testQueueFunctional() { + assertEquals(true, queue.isEmpty()); + queue.enQueue(4); + queue.enQueue(2); + assertEquals(2, queue.size()); + assertEquals(false, queue.isEmpty()); + + int i = (Integer)queue.deQueue(); + assertEquals(4, i); + i = (Integer)queue.deQueue(); + assertEquals(2, i); + + assertEquals(0, queue.size()); + assertEquals(true, queue.isEmpty()); + } + + +} diff --git a/group02/527705641/src/com/github/fei9009/coding2017/basic/StackTest.java b/group02/527705641/src/com/github/fei9009/coding2017/basic/StackTest.java new file mode 100644 index 0000000000..2872efb3e3 --- /dev/null +++ b/group02/527705641/src/com/github/fei9009/coding2017/basic/StackTest.java @@ -0,0 +1,37 @@ +package com.github.fei9009.coding2017.basic; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +public class StackTest { + +private Stack stack; + + @Before + public void setUpStack() { + stack = new Stack(); + } + + @Test + public void testStackFunctional() { + assertEquals(true, stack.isEmpty()); + stack.push(4); + stack.push(2); + assertEquals(2, stack.size()); + assertEquals(false, stack.isEmpty()); + + int i = (Integer)stack.pop(); + assertEquals(2, i); + + i = (Integer)stack.peek(); + assertEquals(4, i); + + i = (Integer)stack.pop(); + assertEquals(4, i); + + assertEquals(0, stack.size()); + assertEquals(true, stack.isEmpty()); + } +} diff --git a/group02/609990377/DataStructure/.gitignore b/group02/609990377/DataStructure/.gitignore new file mode 100644 index 0000000000..fa968c2f2b --- /dev/null +++ b/group02/609990377/DataStructure/.gitignore @@ -0,0 +1,3 @@ +/bin/ +.classpath +.project diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/ArrayList.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/ArrayList.java new file mode 100644 index 0000000000..cfdc5fefe1 --- /dev/null +++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/ArrayList.java @@ -0,0 +1,113 @@ +package com.github.congcongcong250.coding2017.basic; + +import java.util.Arrays; +import java.util.InputMismatchException; +import java.util.NoSuchElementException; + +public class ArrayList implements List { + + private int size = 0; + + private Object[] elementData = new Object[10]; + + public void add(Object o){ + + //check size limit + if(size + 1 > elementData.length){ + int newlength = elementData.length * 3 / 2 + 1; + elementData = Arrays.copyOf(elementData, newlength); + } + + elementData[size++] = o; + } + + public void add(int index, Object o){ + //Check Object class + if(size >= 1){ + if(o.getClass() != elementData[0].getClass()) + throw new InputMismatchException("Index:"+index+" Size:"+size); + } + + //index Check + if(index >= size || index < 0){ + throw new IndexOutOfBoundsException("Index:"+index+" Size:"+size); + } + + //check size limit + if(size + 1 > elementData.length){ + Object oldData[] = elementData; + int newlength = elementData.length * 3 / 2 + 1; + elementData = Arrays.copyOf(elementData, newlength); + } + + for(int i = size-1; i >= index; i-- ){ + elementData[i] = elementData[i-1]; + } + + elementData[index] = o; + + } + + public Object get(int index){ + //index Check + if(index >= size || index < 0){ + throw new IndexOutOfBoundsException("Index:"+index+" Size:"+size); + } + + return elementData[index]; + } + + public Object remove(int index){ + //index Check + if(index >= size || index < 0){ + throw new IndexOutOfBoundsException("Index:"+index+" Size:"+size); + } + + Object old = elementData[index]; + for(int i = index; i < size-1 ; i++ ){ + elementData[i] = elementData[i+1]; + } + elementData[--size] = null; + return old; + } + + public int size(){ + return size; + } + + public Iterator iterator(){ + return new Itr(); + } + + private class Itr implements Iterator{ + //index for next element to visit + private int cursor = 0; + + @Override + public boolean hasNext() { + return cursor != size; + } + + @Override + public Object next() { + if(cursor >= size){ + throw new NoSuchElementException(); + } + return elementData[cursor++]; + } + + @Override + public void remove() { + //Check bound + if(cursor == 0){ + throw new NoSuchElementException(); + } + + ArrayList.this.remove(--cursor); + + } + + + } + +} diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/BinaryTreeNode.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/BinaryTreeNode.java new file mode 100644 index 0000000000..fb71311dc4 --- /dev/null +++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/BinaryTreeNode.java @@ -0,0 +1,72 @@ +package com.github.congcongcong250.coding2017.basic; + +public class BinaryTreeNode >{ + + private Object data; + private BinaryTreeNode left; + private BinaryTreeNode right; + + public BinaryTreeNode(){ + data = null; + left = null; + right = null; + } + + public BinaryTreeNode(Object obj){ + data = obj; + left = null; + 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 BinaryTreeNode insert(Object o){ + //If is empty root + if(data == null){ + data = o; + return this; + } + + //If it is a normal root + BinaryTreeNode in; + + if(o.compareTo(data) <= 0){ + if(left == null){ + in = new BinaryTreeNode(o); + left = in; + }else{ + in = left.insert(o); + } + }else{ + if(right == null){ + in = new BinaryTreeNode(o); + right = in; + }else{ + in = right.insert(o); + } + } + + assert (in == null):"Insert error"; + return in; + } + + + +} diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Iterator.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Iterator.java new file mode 100644 index 0000000000..9033ad33be --- /dev/null +++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Iterator.java @@ -0,0 +1,8 @@ +package com.github.congcongcong250.coding2017.basic; + +public interface Iterator { + public boolean hasNext(); + public Object next(); + public void remove(); + +} diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/LinkedList.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/LinkedList.java new file mode 100644 index 0000000000..840bb14f7c --- /dev/null +++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/LinkedList.java @@ -0,0 +1,163 @@ +package com.github.congcongcong250.coding2017.basic; + +import java.util.NoSuchElementException; + +public class LinkedList implements List { + + private Node head; + private int size; + + public LinkedList(){ + head.next = head; + head.previous = head; + size = 0; + } + + public void add(Object o){ + addLast(o); + } + + public void add(int index , Object o){ + //Check bound + if(index >= size){ + throw new IndexOutOfBoundsException("Index:"+index+" Size:"+size); + } + + Node nx = this.find(index); + Node pr = nx.previous; + Node in = new Node(o,pr,nx); + nx.previous = in; + pr.next = in; + size++; + } + + public Object get(int index){ + //Check bound + if(index >= size){ + throw new IndexOutOfBoundsException("Index:"+index+" Size:"+size); + } + return this.find(index); + } + + public Object remove(int index){ + //Check bound + if(index >= size){ + throw new IndexOutOfBoundsException("Index:"+index+" Size:"+size); + } + Node rem = this.find(index); + + Node pr = rem.previous; + Node nx = rem.next; + pr.next = nx; + nx.previous = pr; + + Object ret = rem.data; + rem.previous = null; + rem.next = null; + rem.data = null; + size--; + return ret; + } + + public int size(){ + return size; + } + + public void addFirst(Object o){ + Node nx = head.next; + Node in = new Node(o,head, nx); + head.next = in; + nx.previous = in; + size++; + } + + public void addLast(Object o){ + Node last = head.previous; + Node in = new Node(o,last,head); + last.next = in; + head.previous = in; + + size++; + } + public Object removeFirst(){ + return remove(0); + } + public Object removeLast(){ + return remove(size-1); + } + public Iterator iterator(){ + return new ListItr(); + } + + private Node find(int index){ + Node tra = head; + + //If index < size/2 + if( index < (size >> 1)){ + for(int i = 0; i <= index; i++){ + tra = tra.next; + } + }else{ + for(int i = size; i >= index; i--){ + tra = tra.previous; + } + } + return tra; + } + + private static class Node{ + Object data; + Node next; + Node previous; + + public Node(Object obj,Node pre, Node nx){ + data = obj; + next = nx; + previous = pre; + } + + + } + + private class ListItr implements Iterator{ + //Point to next node + Node cursor; + int nextIndex; + + public ListItr(){ + cursor = head.next; + nextIndex = 0; + } + + @Override + public boolean hasNext() { + return nextIndex < size; + } + + @Override + public Object next() { + Node re = cursor; + cursor = cursor.next; + nextIndex++; + return re; + } + + public Object previous() { + Node re = cursor.previous.previous; + cursor = cursor.previous; + nextIndex--; + return re; + } + + @Override + public void remove() { + //Check bound + if(nextIndex > size){ + throw new NoSuchElementException("Iterates to the end"); + } + LinkedList.this.remove(--nextIndex); + + } + + } +} diff --git a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/List.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/List.java similarity index 74% rename from coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/List.java rename to group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/List.java index 56d67bdf29..fe05e60f37 100644 --- a/coding2017/group02/447809161Learning/src/com/github/hwjcc969/coding2017/basic/List.java +++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/List.java @@ -1,4 +1,4 @@ -package com.github.hwjcc969.coding2017.basic; +package com.github.congcongcong250.coding2017.basic; public interface List { public void add(Object o); diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Queue.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Queue.java new file mode 100644 index 0000000000..2cdd329b0b --- /dev/null +++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Queue.java @@ -0,0 +1,30 @@ +package com.github.congcongcong250.coding2017.basic; + +public class Queue { + private LinkedList elementData; + + public Queue(){ + elementData = new LinkedList(); + } + + public void enQueue(Object o){ + elementData.addFirst(o); + } + + public Object deQueue(){ + Object ret = elementData.removeLast(); + return ret; + } + + public Object peek(){ + return elementData.get(elementData.size()-1); + } + + public boolean isEmpty(){ + return (elementData.size() == 0); + } + + public int size(){ + return elementData.size(); + } +} diff --git a/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Stack.java b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Stack.java new file mode 100644 index 0000000000..e3024202da --- /dev/null +++ b/group02/609990377/DataStructure/src/com/github/congcongcong250/coding2017/basic/Stack.java @@ -0,0 +1,28 @@ +package com.github.congcongcong250.coding2017.basic; + +public class Stack { + private LinkedList elementData = new LinkedList(); + + public Stack(){ + elementData = new LinkedList(); + } + + public void push(Object o){ + elementData.addLast(o); + } + + public Object pop(){ + Object ret = elementData.removeLast(); + return ret; + } + + public Object peek(){ + return elementData.get(elementData.size()-1); + } + public boolean isEmpty(){ + return (elementData.size() == 0); + } + public int size(){ + return elementData.size(); + } +} diff --git a/group02/727171008/.gitignore b/group02/727171008/.gitignore new file mode 100644 index 0000000000..806b57f381 --- /dev/null +++ b/group02/727171008/.gitignore @@ -0,0 +1,36 @@ +/bin/ +*.class + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files # +*.jar +*.war +*.ear + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* + +#ide config +.metadata +.recommenders +/bin/ +.idea/workspace.xml +.idea/dictionaries/myj.xml +.idea/ +.DS_Store +*.classpath +*.project +.settings +.project +.target +.classpath +**/.settings +**/.classpath +**/.eclipse +**/target/ +target/ +bin/ +.svn +*.iml \ No newline at end of file diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/ArrayListTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/ArrayListTest.java new file mode 100644 index 0000000000..0f22f6ba80 --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/ArrayListTest.java @@ -0,0 +1,15 @@ +package com.github.HarryHook.coding2017.basic; + +import org.junit.Before; +import com.github.HarryHook.coding2017.basic.MyArrayList; + + +public class ArrayListTest extends ListTest { + + @Before + public void setUpArrayList() + { + aList = new MyArrayList(); + } + +} diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNode.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNode.java new file mode 100644 index 0000000000..2d962d9083 --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNode.java @@ -0,0 +1,121 @@ +/* + * Created by Harry 2017-2-23 10:50:39 + * 实现二叉树,并按二叉查找树插入节点 + * 能实现基本的功能，但测试时存在问题，传进去的数据为空 2017-2-2523:49:43 + */ +package com.github.HarryHook.coding2017.basic; + +public class BinaryTreeNode +{ + private Integer data; + private BinaryTreeNode left; + private BinaryTreeNode right; + + //中序遍历二叉树 + public void inOrder(BinaryTreeNode node) + { + if(node != null) + { + inOrder(node.left); + System.out.print(" " + node.data); + inOrder(node.right); + } + } + + //获取给节点的值 + public Integer getData() + { + return data; + } + //给一个节点赋值 + public void setData(Integer 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(Integer obj) + { + // 新增节点 + BinaryTreeNode newNode = new BinaryTreeNode(); + // 当前节点,保留根的值 + BinaryTreeNode current = this; + // 上个节点 + BinaryTreeNode parent = null; + // 如果根节点为空 + if (current.data == null) + { + newNode.setData(obj); + newNode.setLeft(null); + newNode.setRight(null); + return newNode; + }else + { + while (true) + { + parent = current; + if (obj < current.data) + { + current = current.left; + if (current == null) + { + newNode.setData(obj); + newNode.setLeft(null); + newNode.setRight(null); + parent.left = newNode; + return newNode; + } + } else + { + current = current.right; + if (current == null) + { + newNode.setData(obj); + newNode.setLeft(null); + newNode.setRight(null); + parent.right = newNode; + return newNode; + } + } + } + } + } + + public static void main(String[] args) + { + BinaryTreeNode BTN = new BinaryTreeNode(); + + BTN = BTN.insert(5); + System.out.print(BTN.getData() + " "); + System.out.print(BTN.insert(2).getData() + " "); + System.out.print(BTN.insert(1).getData() + " "); + System.out.print(BTN.insert(4).getData() + " "); + System.out.print(BTN.insert(6).getData() + " "); + System.out.print(BTN.insert(8).getData() + " "); + System.out.println(""); + System.out.println("中序遍历二叉树： "); + BTN.inOrder(BTN); + } + +} diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNodeTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNodeTest.java new file mode 100644 index 0000000000..60d1979713 --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNodeTest.java @@ -0,0 +1,40 @@ +package com.github.HarryHook.coding2017.basic; + +import static org.junit.Assert.assertEquals; + +import org.junit.Before; +import org.junit.Test; + +import com.github.HarryHook.coding2017.basic.BinaryTreeNode; + +public class BinaryTreeNodeTest +{ + + BinaryTreeNode binaryTreeNode; + + @Before + public void setUpBinaryTreeNode() + { + binaryTreeNode = new BinaryTreeNode(); + } + + @Test + public void testBinaryTreeNodeFunctional() + { + binaryTreeNode = binaryTreeNode.insert(4); + binaryTreeNode.insert(1); + binaryTreeNode.insert(3); + binaryTreeNode.insert(5); + binaryTreeNode.insert(2); + + assertEquals(true, 4 == binaryTreeNode.getData()); + assertEquals(true, 1 == binaryTreeNode.getLeft().getData()); + assertEquals(true, 5 == binaryTreeNode.getRight().getData()); + assertEquals(true, 3 == binaryTreeNode.getLeft().getRight().getData()); + assertEquals(true, 2 == binaryTreeNode.getLeft().getRight().getLeft().getData()); + + //节点为空 说明值没有插进去 + binaryTreeNode.inOrder(binaryTreeNode); + } + +} diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/Iterator.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/Iterator.java new file mode 100644 index 0000000000..3fae84a22f --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/Iterator.java @@ -0,0 +1,7 @@ +package com.github.HarryHook.coding2017.basic; + +public interface Iterator +{ + public boolean hasNext(); + public Object next(); +} diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/LinkedListTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/LinkedListTest.java new file mode 100644 index 0000000000..7c754e37af --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/LinkedListTest.java @@ -0,0 +1,93 @@ +package com.github.HarryHook.coding2017.basic; + +import static org.junit.Assert.*; +import org.junit.Before; +import org.junit.Test; +import com.github.HarryHook.coding2017.basic.MyLinkedList; + +public class LinkedListTest extends ListTest{ + + private MyLinkedList aLinkedList; + + @Before + public void setUpLinkedList() { + aList = new MyLinkedList(); + aLinkedList = new MyLinkedList(); + } + + @Test + public void testAddFirst() { + aLinkedList.addFirst(5); + assertEquals(5, aLinkedList.get(0)); + + aLinkedList.addFirst(6); + assertEquals(6, aLinkedList.get(0)); + assertEquals(5, aLinkedList.get(1)); + assertEquals(2, aLinkedList.size()); + } + + @Test + public void testAddLast() { + aLinkedList.addLast("hello"); + assertEquals("hello", aLinkedList.get(0)); + + aLinkedList.addLast("world"); + assertEquals("hello", aLinkedList.get(0)); + assertEquals("world", aLinkedList.get(1)); + assertEquals(2, aLinkedList.size()); + } + + @Test + public void testRemoveFirst() { + aLinkedList.addLast("hello"); + aLinkedList.addLast("world"); + + aLinkedList.removeFirst(); + assertEquals("world", aLinkedList.get(0)); + assertEquals(1, aLinkedList.size()); + + aLinkedList.removeFirst(); + assertEquals(0, aLinkedList.size()); + } + + @Test + public void testRemoveLast() { + aLinkedList.addFirst("world"); + aLinkedList.addFirst("hello"); + + aLinkedList.removeLast(); + assertEquals("hello", aLinkedList.get(0)); + assertEquals(1, aLinkedList.size()); + + aLinkedList.removeLast(); + assertEquals(0, aLinkedList.size()); + } + + @Test + public void testLinkedListFunctional() { + for (int i=1; i<4; i++) { + aLinkedList.add(i); // [1,2,3] + } + aLinkedList.remove(1); // [1,3] + + aLinkedList.add(1, 0); // [1,0,3] + for (int i=4; i<6; i++) { + aLinkedList.addFirst(i); // [5, 4, 1, 0, 3] + } + assertEquals(5, aLinkedList.size()); + assertEquals(5, aLinkedList.get(0)); + assertEquals(1, aLinkedList.get(2)); + assertEquals(0, aLinkedList.get(3)); + + aLinkedList.remove(3); // [5, 4, 1, 3] + assertEquals(3, aLinkedList.get(aLinkedList.size()-1)); + aLinkedList.removeLast(); // [5, 4, 1] + assertEquals(1, aLinkedList.get(aLinkedList.size()-1)); + aLinkedList.removeFirst(); // [4,1] + + assertEquals(4, aLinkedList.get(0)); + assertEquals(1, aLinkedList.get(1)); + assertEquals(2, aLinkedList.size()); + } + +} diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/List.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/List.java new file mode 100644 index 0000000000..f2299e8e83 --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/List.java @@ -0,0 +1,14 @@ +package com.github.HarryHook.coding2017.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(); + + public Iterator iterator(); +} + diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/ListTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/ListTest.java new file mode 100644 index 0000000000..92f84b687c --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/ListTest.java @@ -0,0 +1,122 @@ +package com.github.HarryHook.coding2017.basic; + +import static org.junit.Assert.*; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import com.github.HarryHook.coding2017.basic.Iterator; +import com.github.HarryHook.coding2017.basic.List; + +public class ListTest { + + protected static List aList; + + @Test + public void testFunctional() { + aList.add(1); + aList.add(2); + assertEquals(1, aList.get(0)); + assertEquals(2, aList.get(1)); + + aList.add(3); + aList.add(0, 5); + aList.add(2, 11); + assertEquals(5, aList.get(0)); + assertEquals(11, aList.get(2)); + + aList.add("hi"); + assertEquals("hi", aList.get(5)); + assertEquals(6, aList.size()); + + aList.remove(1); + assertEquals(11, aList.get(1)); + assertEquals(2, aList.get(2)); + + assertEquals(5, aList.size()); + } + + @Test + public void testAdd() { + for (int i=0; i<100; i++) + aList.add(i); + assertEquals(0, aList.get(0)); + assertEquals(99, aList.get(99)); + assertEquals(44, aList.get(44)); + } + + @Test + public void testRemove() { + aList.add(1); + aList.add(2); + aList.add(3); + int u = (Integer)aList.remove(2); + assertEquals(3, u); + assertEquals(2, aList.size()); + + aList.add(1, 5); + u = (Integer)aList.remove(0); + assertEquals(1, u); + assertEquals(5, aList.get(0)); + assertEquals(2, aList.get(1)); + assertEquals(2, aList.size()); + + aList.remove(0); + aList.remove(0); + assertEquals(0, aList.size()); + + + } + + @Test + public void testSize() { + for (int i=0; i<10; i++) + aList.add(i*2); + assertEquals(10, aList.size()); + } + + @Rule + public ExpectedException expectedEx = ExpectedException.none(); + + @Test + public void testException() { + expectedEx.expect(Exception.class); + aList.remove(1); + aList.add(3); + aList.add(2, 5); + expectedEx.expect(Exception.class); + } + + @Test + + public void testIterator() + { + Iterator it = aList.iterator(); + assertEquals(false, it.hasNext()); + + aList.add(1); + aList.add(2); + aList.add(3); + + it = aList.iterator(); + assertEquals(true, it.hasNext()); + assertEquals(1, it.next()); + assertEquals(2, it.next()); + assertEquals(3, it.next()); + assertEquals(false, it.hasNext()); + + aList.remove(1); + it = aList.iterator(); + assertEquals(true, it.hasNext()); + assertEquals(1, it.next()); + assertEquals(3, it.next()); + assertEquals(false, it.hasNext()); + + expectedEx.expect(Exception.class); + it.next(); + + } + + + +} diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyArrayList.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyArrayList.java new file mode 100644 index 0000000000..dbfd8aae19 --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyArrayList.java @@ -0,0 +1,167 @@ +/* + * created by Harry 2017-2-20 18:53:38 + * 实现简单的ArrayList,具有基本的增删改查功能 + */ +package com.github.HarryHook.coding2017.basic; + +import java.util.Arrays; +import java.util.NoSuchElementException; + +public class MyArrayList implements List +{ + private int size = 0; //数组元素个数 + + private Object[] elementData = new Object[10]; //初始化数组大小为10 + + //将元素添加到数组尾部 + public void add(Object o) + { //需要判断数组空间是否够用 + ensureCapacity(size + 1); + elementData[size++] = o; + } + //在指定位置添加元素 + public void add(int index, Object o) + { + //判断下标记是否越界 + if (index > size || index < 0) + throw new IndexOutOfBoundsException( + "Index: " + index + ", Size: " + size); + ensureCapacity(size + 1); + //判断当前位置是否有元素，没有元素添加到当前位置；若有，当前元素及之后元素向右移 + if(elementData[index] == null) + { + elementData[index] = o; + } + else + { + for(int i=elementData.length-1; i>index; i--) + { + elementData[i] = elementData[i-1]; + } + elementData[index] = o; + } + size++; + + /* + //判断索引位置是否正确 + if (index > size || index < 0) + throw new IndexOutOfBoundsException( + "Index: " + index + ", Size: " + size); + //扩容检测 + ensureCapacity(size+1); + /* + * 对源数组进行复制处理（位移），从index + 1到size-index。 + * 主要目的就是空出index位置供数据插入， + * 即向右移动当前位于该位置的元素以及所有后续元素。 + + System.arraycopy(elementData, index, elementData, index + 1, + size - index); + //在指定位置赋值 + elementData[index] = 0; + size++; + + */ + } + + public Object get(int index) + { + //若index超出size应该抛出异常 + if(index >= size) + throw new IndexOutOfBoundsException( "Index: " + index + ", Size: " + size); + return elementData[index]; + + } + + public Object remove(int index) + { //涉及到元素移位 + Object oldValue = elementData[index]; + for(int i=index; i oldCapacity) + { + //Object oldData[] = elementData; //防止copyof()执行的过程中新内存或者其他进程分配内存时占用旧内存 + int newCapacity = (oldCapacity * 3)/2 + 1; //增加50%+1 + if (newCapacity < minCapacity) + newCapacity = minCapacity; + // minCapacity is usually close to size, so this is a win: + elementData = Arrays.copyOf(elementData, newCapacity); + } + } + + //返回数组的大小 + public int size() + { + return size; + } + + public Iterator iterator() + { + return new MyArrayListIterator(); + } + + private class MyArrayListIterator implements Iterator + { + private int cursor = 0; //记录索引位置 + public boolean hasNext() + { + return cursor != size; + } + public Object next() + { + try { + Object next = get(cursor); + cursor++; + return next; + + } catch (IndexOutOfBoundsException e) + { + throw new NoSuchElementException(); + } + + } + } + + public static void main(String[] args) + { + MyArrayList myArrays = new MyArrayList(); + myArrays.add(3); + myArrays.add(0, 11); + myArrays.add(1, 2); + myArrays.add(3, 5); + myArrays.add(2, 1); + myArrays.add(7); + Print(myArrays); + + for(int i = 0; i < 19; i++) + myArrays.add(i, 55); + + System.out.println("获取指定位置元素： " + myArrays.get(2)); + System.out.println("删除指定位置元素： " + myArrays.remove(1)); + System.out.println("当前元素个数：" + myArrays.size()); + + Print(myArrays); + + } + public static void Print(MyArrayList myArrays) + { + Iterator it = myArrays.iterator(); + System.out.println("对链表中的元素进行打印："); + while(it.hasNext()) + System.out.print(it.next() + " "); + System.out.println(""); + System.out.println("当前元素个数： " + myArrays.size()); + + } + +} + diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyLinkedList.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyLinkedList.java new file mode 100644 index 0000000000..5aeab57496 --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyLinkedList.java @@ -0,0 +1,219 @@ +/* + * created by Harry 2017-2-21 14:43:41 + * 实现简单的LinkedList + */ + +package com.github.HarryHook.coding2017.basic; + +public class MyLinkedList implements List +{ + private Node head = null; //头指针 + private int size = 0; + private static class Node + { + Object data; + Node next; + } + public void add(Object o) + { + addLast(o); + } + //在指定位置添加元素 + public void add(int index , Object o) + { + + if (index > size || index < 0) + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); + //存在插入头结点的情况 + if(index == 0) + addFirst(o); + else + { //即 index != 0 的情况 + // p保存待插入节点的前一节点，x指向要插入的节点 + Node x = head; + Node p = null; + int i = 0; + while(i < index) + { + p = x; + x = x.next; + i++; + } + Node n = new Node(); + p.next = n; + n.next = x; + n.data = o; + size++; + } + + } + //返回指定位置元素 + public Object get(int index) + { + Node x = head; + int i = 0; + while(i < index && x != null) + { + x = x.next; + i++; + } + return x.data; + } + + //移除指定位置节点 + public Object remove(int index) + { + if (index > size || index < 0) + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); + //先判断是否是头节点 + if( index == 0) + { + return removeFirst(); + } + else + { + Node x = head; + Node pre = null; + int i = 0; + while(i < index) + { + pre = x; + x = x.next; + i++; + } + Object Data = pre.next.data; + pre.next = x.next; + x = null; + size--; + return Data; + } + + } + //头部添加节点 + public void addFirst(Object o) + { + Node n = new Node(); + n.next = head; + head = n; + n.data = o; + size++; + } + //尾部添加节点 + public void addLast(Object o) + { + if (head == null) + { + head = new Node(); + head.data = o; + } + else + { + Node x = head; + while(x.next != null) + { + x = x.next; + } + Node n = new Node(); + x.next = n; + n.next = null; + n.data = o; + } + size++; + } + //移除第一个节点 + public Object removeFirst() + { + Node n = head; + Object Data = n.data; + head = head.next; + n = null; + size--; + return Data; + } + + //移除最后一个节点 + //removeLast()方法存在bug + public Object removeLast() + { + Node x = head; + Node p = null; + if(x.next == null) + { + return removeFirst(); + } + else + { + while(x.next != null) + { + p = x; + x = x.next; + } + Object Data = x.data; + p.next = null; + x = null; //删除最后一个节点 + size--; + return Data; + } + } + public int size(){ + return size; + } + public Iterator iterator() + { + return new MyLinkedListIterator(); + } + private class MyLinkedListIterator implements Iterator + { + private int cursor = 0; //记录索引位置 + public boolean hasNext() + { + return cursor != size; + } + public Object next() + { + Object next = get(cursor); + cursor ++; + return next; + } + } + public static void main(String[] args) + { + MyLinkedList myList = new MyLinkedList(); + myList.add(3); + myList.add(5); + myList.add(0, 4); + myList.add(2, 7); + myList.addFirst(1); + myList.addLast(6); + + Print(myList); + + System.out.println("当前指定位置元素： " + myList.get(1)); + System.out.println("移除指定位置元素： " + myList.remove(4)); + Print(myList); + + System.out.println("移除第一个节点元素： " + myList.removeLast()); + Print(myList); + System.out.println("移除最后一个节点元素： " + myList.removeLast()); + Print(myList); + System.out.println("移除最后一个节点元素： " + myList.removeLast()); + Print(myList); + System.out.println("移除最后一个节点元素： " + myList.removeLast()); + Print(myList); + System.out.println("移除最后一个节点元素： " + myList.removeLast()); + Print(myList); + + } + public static void Print(MyLinkedList myList) + { + Iterator it = myList.iterator(); + System.out.println("对链表中的元素进行打印："); + while(it.hasNext()) + System.out.print(it.next() + " "); + System.out.println(""); + System.out.println("当前元素个数： " + myList.size()); + System.out.println(""); + } + + +} diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyQueue.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyQueue.java new file mode 100644 index 0000000000..9b713eaea9 --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyQueue.java @@ -0,0 +1,54 @@ +/* + * created by Harry 2017-2-22 13:06:43 + * 实现简单的队列 + */ +package com.github.HarryHook.coding2017.basic; +import java.util.*; +public class MyQueue +{ + private MyArrayList elementData = new MyArrayList(); + private int size = 0; + //入队 + public void enQueue(Object o) + { + elementData.add(o); + size++; + } + //出队 + public Object deQueue() + { + if(isEmpty()) + throw new NoSuchElementException(); + Object Data = elementData.remove(0); + size--; + return Data; + } + //判断队列是否为空 + public boolean isEmpty() + { + return size() == 0; + } + //队列中元素个数 + public int size() + { + return size; + } + public static void main(String[] args) + { + MyQueue mq = new MyQueue(); + mq.enQueue(1); + mq.enQueue(2); + mq.enQueue(3); + mq.enQueue(4); + System.out.println("队列出栈，出栈元素为： " + mq.deQueue()); + System.out.println("队列中元素个数： " + mq.size()); + System.out.println("队列出栈，出栈元素为： " + mq.deQueue()); + System.out.println("队列中元素个数： " + mq.size()); + System.out.println("队列出栈，出栈元素为： " + mq.deQueue()); + System.out.println("队列中元素个数： " + mq.size()); + System.out.println("队列出栈，出栈元素为： " + mq.deQueue()); + System.out.println("队列中元素个数： " + mq.size()); + //System.out.println("队列出栈，出栈元素为： " + mq.deQueue()); + //System.out.println("队列中元素个数： " + mq.size()); + } +} diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyStack.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyStack.java new file mode 100644 index 0000000000..c7f87c04e6 --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/MyStack.java @@ -0,0 +1,59 @@ +/* + * created by Harry 2017-2-22 10:48:34 + * 实现简单的Stack + */ +package com.github.HarryHook.coding2017.basic; + +import java.util.*; + +public class MyStack +{ + private MyArrayList elementData = new MyArrayList(); + private int size = 0; + + //入栈操作 + public void push(Object o) + { + elementData.add(o); + size++; + } + //出栈操作 + public Object pop() + { + Object obj = peek(); + elementData.remove(size() - 1); + size--; + return obj; + } + //获取当前栈顶元素，不用出栈 + public Object peek() + { + if(isEmpty()) + throw new EmptyStackException(); + return elementData.get(size() - 1); + } + //判断栈是否为空 + public boolean isEmpty() + { + return size() == 0; + } + //返回栈内元素个数 + public int size(){ + return size; + } + + public static void main(String[] args) + { + MyStack ms = new MyStack(); + + ms.push(1); + ms.push(2); + ms.push(13); + System.out.println("当前栈顶元素是: " + ms.peek()); + System.out.println("出栈元素是: " + ms.pop()); + System.out.println("出栈元素是: " + ms.pop()); + ms.push(12); + System.out.println("出栈元素是: " + ms.pop()); + System.out.println("当前栈顶元素是: " + ms.peek()); + } +} diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/QueueTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/QueueTest.java new file mode 100644 index 0000000000..340f79d240 --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/QueueTest.java @@ -0,0 +1,33 @@ +package com.github.HarryHook.coding2017.basic; + +import static org.junit.Assert.*; +import org.junit.Before; +import org.junit.Test; +import com.github.HarryHook.coding2017.basic.MyQueue; + +public class QueueTest { + private MyQueue queue; + + @Before + public void setUpQueue() { + queue = new MyQueue(); + } + + @Test + public void testQueueFunctional() { + assertEquals(true, queue.isEmpty()); + queue.enQueue(4); + queue.enQueue(2); + assertEquals(2, queue.size()); + assertEquals(false, queue.isEmpty()); + + int i = (Integer)queue.deQueue(); + assertEquals(4, i); + i = (Integer)queue.deQueue(); + assertEquals(2, i); + + assertEquals(0, queue.size()); + assertEquals(true, queue.isEmpty()); + } + +} diff --git a/group02/727171008/src/com/github/HarryHook/coding2017/basic/StackTest.java b/group02/727171008/src/com/github/HarryHook/coding2017/basic/StackTest.java new file mode 100644 index 0000000000..26160faef6 --- /dev/null +++ b/group02/727171008/src/com/github/HarryHook/coding2017/basic/StackTest.java @@ -0,0 +1,40 @@ +package com.github.HarryHook.coding2017.basic; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +import com.github.HarryHook.coding2017.basic.MyStack; + +public class StackTest { + + private MyStack stack; + + @Before + public void setUpStack() { + stack = new MyStack(); + } + + @Test + public void testStackFunctional() { + assertEquals(true, stack.isEmpty()); + stack.push(4); + stack.push(2); + assertEquals(2, stack.size()); + assertEquals(false, stack.isEmpty()); + + int i = (Integer)stack.pop(); + assertEquals(2, i); + + i = (Integer)stack.peek(); + assertEquals(4, i); + + i = (Integer)stack.pop(); + assertEquals(4, i); + + assertEquals(0, stack.size()); + assertEquals(true, stack.isEmpty()); + } + +} diff --git a/liuxin/src/com/coding/basic/BinaryTreeNode.java b/liuxin/src/com/coding/basic/BinaryTreeNode.java index d7ac820192..736ae328c7 100644 --- a/liuxin/src/com/coding/basic/BinaryTreeNode.java +++ b/liuxin/src/com/coding/basic/BinaryTreeNode.java @@ -1,11 +1,51 @@ package com.coding.basic; -public class BinaryTreeNode { - - private Object data; - private BinaryTreeNode left; - private BinaryTreeNode right; - +public class BinaryTreeNode +{ + public static TreeNode root; //根节点 + public BinaryTreeNode() + { + this.root = null; + } + public TreeNode insert (int key) + { + // 新增节点 + TreeNode newNode = new TreeNode(key); + // 当前节点 + TreeNode current = root; + // 上个节点 + TreeNode parent = null; + // 如果根节点为空 + if (current == null) + { + root = newNode; + return newNode; + } + while (true) + { + parent = current; + if (key < current.value) + { + current = current.left; + if (current == null) + { + parent.left = newNode; + return newNode; + } + } else + { + current = current.right; + if (current == null) + { + parent.right = newNode; + return newNode; + } + } + } + } + +} + public Object getData() { return data; } @@ -30,3 +70,44 @@ public BinaryTreeNode insert(Object o){ } } + +class TreeNode //树的节点 +{ + int value; + TreeNode left; + TreeNode right; + + public TreeNode(int value) + { + this.value = value; + left = null; + right = null; + } +} + +public class BinaryTreeNodeTest { + + public static void main(String[] args) { + BinaryTreeNode b = new BinaryTreeNode(); + b.insert(3);b.insert(8);b.insert(1);b.insert(4);b.insert(6); + b.insert(2);b.insert(10);b.insert(9);b.insert(20);b.insert(25); + + // 打印二叉树 + b.toString(b.root); + System.out.println(); + + // 是否存在节点值10 + TreeNode node01 = b.search(10); + System.out.println("是否存在节点值为10 => " + node01.value); + // 是否存在节点值11 + TreeNode node02 = b.search(11); + System.out.println("是否存在节点值为11 => " + node02); + + // 删除节点8 + TreeNode node03 = b.delete(8); + System.out.println("删除节点8 => " + node03.value); + b.toString(b.root); + + + } +} diff --git a/liuxin/src/com/coding/basic/insert.java b/liuxin/src/com/coding/basic/insert.java new file mode 100644 index 0000000000..9ded2fcfac --- /dev/null +++ b/liuxin/src/com/coding/basic/insert.java @@ -0,0 +1,37 @@ + + //2017年2月24日17:02:55 + public BinaryTreeNode insert (Integer key) + { + // 新增节点 + BinaryTreeNode newNode = new BinaryTreeNode(key); + // 当前节点 + BinaryTreeNode current = root; + // 上个节点 + BinaryTreeNode parent = null; + // 如果根节点为空 + if (current == null) { + root = newNode; + return newNode; + } + while (true) + { + parent = current; + if (key < current.value) + { + current = current.left; + if (current == null) + { + parent.left = newNode; + return newNode; + } + } else + { + current = current.right; + if (current == null) + { + parent.right = newNode; + return newNode; + } + } + } + }