Signed-off-by: [email protected]，11组

group11/996108220/.classpath

@@ -0,0 +1,6 @@
+<?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="output" path="bin"/>
+</classpath>

group11/996108220/.gitignore

@@ -0,0 +1 @@
+/bin

group11/996108220/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>996108220Learning</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>

group11/996108220/src/com/coding/basic/ArrayList.java

@@ -0,0 +1,124 @@
+package com.coding.basic;
+
+public class ArrayList implements List {
+
+	private int size = 0;
+	private Object[] elementData = new Object[100];
+	/**
+	 * 在队尾添加元素
+	 */
+	public void add(Object o){
+		if(size+1>elementData.length)this.grow(elementData);
+		else elementData[size++]=o;
+	}
+	/**
+	 * 在index处添加元素，index+1到size-1元素向后移动
+	 */
+	public void add(int index, Object o){
+		if(index<0||index>size){
+			System.out.println("数组越界"+index);
+			return;
+		}
+		if(size+1>elementData.length)this.grow(elementData);
+		else {
+			for(int i=size;i>=index+1;)
+			{
+				elementData[i]=elementData[--i];
+			}
+			size++;
+			elementData[index]=o;
+		}
+
+	}
+	/**
+	 * 获得index处的元素elementData[index]
+	 */
+	public Object get(int index){
+		//TODO越界抛出异常
+		if(index<0||index>size){
+			System.out.println("数组越界"+index);
+			return null;
+		}
+		else{
+			return elementData[index];
+		}
+	}
+	/**
+	 * 移除index处的元素，将index+1到size-1的元素向前移动
+	 */
+	public Object remove(int index){
+		//TODO越界抛出异常
+		if(index<0||index>=size){
+			System.out.println("数组越界"+index);
+			return null;
+			}
+		else{
+			Object value=elementData[index];
+			for(int i=index;i<size;)
+			{
+				elementData[i]=elementData[++i];
+			}
+			size--;
+			return value;
+		}
+	}
+
+	public int size(){
+		return size;
+	}
+
+	public Iterator iterator(){
+		return new Itr();
+	}
+
+	 private class Itr implements Iterator {
+	        int cursor;       // index of next element to return
+	        Itr() {
+	            cursor=0;
+	        }
+	        public boolean hasNext() {
+	            return cursor != size;
+	        }
+
+
+	        public Object next() {
+
+	            int i = cursor;
+	            if (i >= size)
+	                System.out.println("超过size");;
+	            Object[] elementData = ArrayList.this.elementData;
+	            if (i >= elementData.length)
+	                System.out.println("超过length");
+	            cursor = i + 1;
+	            return  elementData[i];
+	        }
+
+	 }
+	public void grow(Object[] elementData2){
+		int[] elementData=new int[elementData2.length+elementData2.length/2];
+		System.arraycopy(elementData2,0,elementData,0,elementData2.length); 
+	}
+	/**
+	 * 测试方法
+	 * @param args
+	 */
+	public static void main(String args[]){
+		ArrayList list=new ArrayList();
+		list.add(1);
+		list.add(2);
+		list.add(3);
+		list.add(4);
+		list.add(5);
+		list.add(6);
+		//list.add(2,0);
+		//list.remove(list.size-1);
+		System.out.println(list.size());
+		Iterator itr=list.iterator();
+		while (itr.hasNext()) {
+			System.out.println(itr.next());
+
+		}
+	}
+
+}
+

group11/996108220/src/com/coding/basic/BinaryTree.java

@@ -0,0 +1,129 @@
+package com.coding.basic;
+
+import com.sun.corba.se.impl.orbutil.graph.Node;
+
+public class BinaryTree <T extends Comparable>{
+
+	private BinaryTreeNode root=null;
+	private int size=0;
+	/**
+	 * 插入节点，保持二叉树的性质
+	 * @param o
+	 */
+	public void insert(T o){
+		if (size==0) {
+			root=new BinaryTreeNode<Comparable>(o);
+			}
+		else{
+			insert(o,root);	
+			}
+		size++;
+		}
+
+	private void insert(T o,  BinaryTreeNode<?> ptr) {
+		if ((ptr.right==null&&(ptr.data.compareTo(o)<=0))){
+			ptr.right=new BinaryTreeNode<Comparable>(o);	
+		}
+		else if (ptr.left==null&&(ptr.data.compareTo(o)>0)) {
+			ptr.left=new BinaryTreeNode<Comparable>(o);
+
+		} 
+		else if (ptr.left!=null&&(ptr.data.compareTo(o)>0)) {
+			insert(o, ptr.left);
+		}
+		else {
+			insert(o, ptr.right);
+		}		
+	}
+	private static  class BinaryTreeNode <T extends Comparable>{
+		private T data;
+		private BinaryTreeNode left;
+		private BinaryTreeNode right;	
+		private BinaryTreeNode(T o) {
+			this.data=o;
+			this.left=null;
+			this.right=null;
+		}
+		private BinaryTreeNode() {
+
+		}
+	}
+	  /**
+     * 前序遍历
+     */
+    public void preOrder(BinaryTreeNode Node)
+    {
+        if (Node != null)
+        {
+            System.out.print(Node.data + " ");
+            preOrder(Node.left);
+            preOrder(Node.right);
+        }
+    }
+
+    /**
+     * 中序遍历
+     */
+    public void midOrder(BinaryTreeNode Node)
+    {
+        if (Node != null)
+        {
+            midOrder(Node.left);
+            System.out.print(Node.data + " ");
+            midOrder(Node.right);
+        }
+    }
+
+    /**
+     * 后序遍历
+     */
+    public void posOrder(BinaryTreeNode Node)
+    {
+        if (Node != null)
+        {
+            posOrder(Node.left);
+            posOrder(Node.right);
+            System.out.print(Node.data + " ");
+        }
+    }
+    /**
+     * @param key查找元素
+     * @param node
+     * @return 返回date的node引用
+     */
+    public BinaryTreeNode searchNode(T key,BinaryTreeNode node) {
+    	if (node!=null) {
+    		if (node.data.compareTo(key)==0) {
+				return node;
+			}
+    		else if (node.data.compareTo(key)>0) {
+    			return searchNode(key,node.left);
+			}
+    		else {
+    			return searchNode(key,node.right);
+			}	
+		}
+    	else{
+    		return null;
+    	}					
+	}
+
+	public static void main(String[] args) {
+		BinaryTree tree=new BinaryTree();
+		tree.insert(5);
+		tree.insert(3);
+		tree.insert(1);
+		tree.insert(6);
+		tree.insert(5);
+		tree.insert(2);
+		tree.preOrder(tree.root);
+		System.out.println();
+		tree.posOrder(tree.root);
+		System.out.println();
+		tree.midOrder(tree.root);
+		System.out.println(tree.searchNode(1, tree.root).data);
+
+
+	}
+
+}

group11/996108220/src/com/coding/basic/Iterator.java

@@ -0,0 +1,7 @@
+package com.coding.basic;
+
+public interface Iterator {
+	public boolean hasNext();
+	public Object next();
+
+}