2.26数据结构作业

group15/1515_337959725/.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>

group15/1515_337959725/.gitignore

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

group15/1515_337959725/.project

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

group15/1515_337959725/src/com/coding/basic/ArrayListTest.java

@@ -0,0 +1,65 @@
+package com.coding.basic;
+
+import java.util.Arrays;
+
+public class ArrayListTest implements ListTest{
+	private Object[] obj;
+
+	public ArrayListTest() {
+		obj=new Object[0];
+	}
+
+	public void add(Object o) {
+		 obj = Arrays.copyOf(obj, obj.length+1);
+		 obj[obj.length-1]=o;
+	}
+
+	public void add(int index, Object o) {
+		obj = Arrays.copyOf(obj, obj.length+1);
+		for(int i=index;i<obj.length-1;i++){
+			obj[i+1]=obj[i];
+		}
+		obj[index]=o;
+	}
+
+	public Object get(int index) {
+		return obj[index];
+	}
+
+	public Object remove(int index) {
+		Object o=obj[index];
+		for(int i=index;i<obj.length-1;i++){
+			obj[i]=obj[i+1];
+		}
+		obj[obj.length-1]=null;
+		obj=Arrays.copyOf(obj, obj.length-1);
+		return o;
+	}
+
+	public int size() {
+		return obj.length;
+	}
+
+	public Its getIts(){
+		Its its=new Its();
+		return its;
+	}
+
+	class Its implements IteratorTest{
+		int count=0;
+
+		public boolean hasNext() {
+			if(count<=size()-1){
+				return true;
+			}else{
+				return false;
+			}
+		}
+
+		public Object next() {
+			Object obj = get(count);
+			count++;
+			return obj;
+		}
+	}
+}

group15/1515_337959725/src/com/coding/basic/BinaryTreeTest.java

@@ -0,0 +1,42 @@
+package com.coding.basic;
+
+public class BinaryTreeTest {
+	private BinaryTreeNode rootNode;
+
+	class BinaryTreeNode{
+		private int data;
+		private BinaryTreeNode left;
+		private BinaryTreeNode right;
+		public BinaryTreeNode(int data) {
+			super();
+			this.data = data;
+		}	
+	}
+
+	public BinaryTreeNode insert(int o){
+		BinaryTreeNode newNode=new BinaryTreeNode(o);
+		if(rootNode==null){
+			rootNode=newNode;
+		}else{
+			compareNode(rootNode,newNode);
+		}
+		return  newNode;
+	}
+
+	private void compareNode(BinaryTreeNode node1,BinaryTreeNode node2){
+		if(node1.data>node2.data){
+			if(node1.left==null){
+				node1.left=node2;
+			}else{
+				compareNode(node1.left,node2);
+			}
+		}else{
+			if(node1.right==null){
+				node1.right=node2;
+			}else{
+				compareNode(node1.right,node2);
+			}
+		}
+	}
+
+}

group15/1515_337959725/src/com/coding/basic/IteratorTest.java

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

group15/1515_337959725/src/com/coding/basic/LinkedListTest.java

@@ -0,0 +1,100 @@
+package com.coding.basic;
+
+public class LinkedListTest implements ListTest {
+	private Node headNode;
+	private Node tailNode;
+
+	class Node{
+		private Object obj;
+//		private Node proNode;
+		private Node nextNode;
+
+		public Node(Object obj) {
+			this.obj = obj;
+		}
+
+
+	}
+
+	public void add(Object o) {
+		if(headNode==null){
+			headNode=new Node(o);
+			tailNode=headNode;
+		}else{
+			tailNode.nextNode=new Node(o);
+			tailNode=tailNode.nextNode;
+		}
+	}
+
+	public void add(int index, Object o) {
+		Node newNode=new Node(o);
+		Node node=headNode;
+		for(int i=0;i<index-1;i++){
+			node=node.nextNode;
+		}
+		newNode.nextNode=node.nextNode;	
+		node.nextNode=newNode;
+
+	}
+
+	public Object get(int index) {
+		Node node=headNode;
+		for(int i=0;i<index;i++){
+			node=node.nextNode;
+		}
+		return node.obj;
+	}
+
+	public Object remove(int index) {
+		Node node=headNode;
+		if(index==0){
+			return node.obj;
+		}else{
+			for(int i=0;i<index-1;i++){
+				node=node.nextNode;
+			}
+			Object obj=node.nextNode.obj;
+			node.nextNode=node.nextNode.nextNode;
+			return obj;
+		}
+
+	}
+
+	public int size() {
+		int length=1;
+		Node node=headNode;
+		if(headNode==null){
+			return 0;
+		}else{
+			while(node!=tailNode){
+				node=node.nextNode;
+				length++;
+			}
+			return length;
+		}
+	}
+
+	public Object removeFirst(){
+		Object obj = headNode.obj;
+		headNode=headNode.nextNode;
+		return obj;
+	}
+	public Object removeLast(){
+		int length=size();
+		Object obj = tailNode.obj;
+		Node node=headNode;
+		if(length==0){
+			return null;
+		}else if(length==1){
+			return headNode;
+		}else{
+			for(int i=0;i<length-2;i++){
+				node=node.nextNode;
+			}
+			tailNode=node;
+			return obj;
+		}
+
+	}
+}
+

group15/1515_337959725/src/com/coding/basic/ListTest.java

@@ -0,0 +1,9 @@
+package com.coding.basic;
+
+public interface ListTest {
+	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();
+}

group15/1515_337959725/src/com/coding/basic/Queue.java

@@ -0,0 +1,27 @@
+package com.coding.basic;
+
+public class Queue {
+	private LinkedListTest list = new LinkedListTest();
+	public void enQueue(Object o){
+		list.add(o);
+	}
+
+	public Object deQueue(){
+		Object obj = list.removeFirst();
+		return obj;
+	}
+
+	public boolean isEmpty(){
+		int size = list.size();
+		if(size==0){
+			return true;
+		}else{
+			return false;
+		}
+	}
+
+	public int size(){
+		int size = list.size();
+		return size;
+	}
+}

group15/1515_337959725/src/com/coding/basic/StackTest.java

@@ -0,0 +1,33 @@
+package com.coding.basic;
+
+public class StackTest {
+	private LinkedListTest list = new LinkedListTest();
+
+	public void push(Object o){
+		list.add(o);
+	}
+
+	public Object pop(){
+		Object obj = list.removeLast();
+		return obj;
+	}
+
+	public Object peek(){
+		Object obj = list.get(0);
+		return obj;
+	}
+
+	public boolean isEmpty(){
+		int size = list.size();
+		if(size==0){
+			return true;
+		}else{
+			return false;
+		}
+	}
+
+	public int size(){
+		int size = list.size();
+		return size;
+	}
+}