Merge pull request diliuzuzhanghao#16 from HarryHook/master

Submit my first code

group02/727171008/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

group02/727171008/.gitignore

@@ -0,0 +1,19 @@
+/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  

group02/727171008/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>727171008Learning</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

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

group02/727171008/src/com/github/HarryHook/coding2017/basic/BinaryTreeNode.java

@@ -0,0 +1,121 @@
+/*
+ * Created by Harry 2017-2-23 10:50:39
+ * 实现二叉树,并按二叉查找树插入节点
+ * 
+ */
+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);	
+	}
+
+}

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

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

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

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