作业

group22/17457741/src/ArrayList.java

@@ -0,0 +1,110 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class ArrayList<T> implements Iterable<T>{
+    private static final int CAPACITY = 5;
+
+    private int size;
+
+    private T [] items;
+
+    public ArrayList(){doClear();}
+
+    public void clear(){
+    	doClear();
+    }
+
+    private void doClear(){
+    	this.size=0;ensureCapacity(CAPACITY);
+    }
+
+    public int size(){
+    	return size;
+    }
+
+    public boolean isEmpty(){
+    	return size==0;
+    }
+
+    public void trimToSize(){
+    	ensureCapacity(size());
+    }
+
+    public T get( int a){
+    	return items[a];
+    }
+
+    public T set(int a,T b){
+    	T old = items[a];
+    	items[a]=b;
+    	return old;
+    }
+
+    public void ensureCapacity(int newCapacity){
+    	if(newCapacity<size){
+    		return ;
+    	}
+    	T []old =items;
+    	items=(T[]) new Object[newCapacity];
+    	for(int i=0;i<size();i++){
+    		items[i]=old[i];
+    	}
+    }
+
+    public boolean add(T a){
+    	add(size(),a);
+    	return true;
+    }
+
+    public void add(int a,T b){
+    	if(items.length==size())
+    		ensureCapacity(size()*2-1);
+    	for(int i=size;i>a;i--){
+    		items[i]=items[i-1];
+    	}
+    		items[a]=b;
+    		size++;
+    	}
+
+    public T remove(int a){
+    	T removedItem=items[a];
+    	for(int i=a;i<size()-1;i++){
+    		items[i]=items[i+1];
+    	}
+    	size--;
+    	return removedItem;
+    }
+
+
+	@Override
+	public Iterator<T> iterator() {
+		// TODO Auto-generated method stub
+		return new ArrayListIterator();
+	}
+
+	private class ArrayListIterator implements Iterator<T>{
+
+		private int current =0;
+
+		@Override
+		public boolean hasNext() {
+			// TODO Auto-generated method stub
+			return current<size();
+		}
+
+		@Override
+		public T next() {
+			// TODO Auto-generated method stub
+			if(!hasNext())
+				throw new NoSuchElementException();
+			return items[current++];
+
+		}
+		public void remove(){
+			ArrayList.this.remove(--current);
+		}
+	}
+
+
+}
+

group22/17457741/src/BinaryTreeNode.java

@@ -0,0 +1,53 @@
+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){
+		if (data == null || ((Integer)data).intValue() == ((Integer)o).intValue()) {
+			data = o;
+			return this;
+		}
+		else if (((Integer)o).intValue() < ((Integer)data).intValue()) {
+			if (left == null) {
+				left = new BinaryTreeNode();
+			}
+			return left.insert(o);
+		}
+		else {
+			if (right == null) {
+				right = new BinaryTreeNode();
+			}
+			return right.insert(o);
+		}
+	}
+
+
+    public boolean isEmpty(){
+    	return data==null;
+    }
+}

group22/17457741/src/LinkedList.java

@@ -0,0 +1,148 @@
+import java.util.Iterator;
+
+
+
+
+
+public class LinkedList<T> implements Iterable<T>{
+	private Node<T>begin;
+	private Node<T>end;
+	private int size;
+	private int modCount=0;
+
+	public LinkedList(){
+		doClear();
+	}
+	public void clear(){
+		doClear();
+	}
+	private void doClear(){
+		begin=new Node<T>(null,null,null);
+		end=new Node<T>(null,begin,null);
+		begin.next=end;
+			}
+
+	public int size(){
+		return size;
+	}
+	public boolean isEmpty(){
+		return size==0;
+	}
+
+	public boolean add( T x){
+		add(size(),x);
+		return true;
+	}
+	public void add(int a,T x){
+		addBefore(getNode(a,0,size()),x);
+	}
+
+	public T get(int a){
+		return getNode(a).data;
+	}
+	public T set(int a,T newVal){
+		Node<T>p=getNode(a);
+		T old=p.data;
+		p.data=newVal;
+		return old;
+	}
+
+	public T remove(int a){
+		return remove(getNode(a));
+	}
+
+	private void addBefore(Node<T>p,T x){
+		Node <T>newNode=new Node<>(x,p.prev,p);
+		newNode.prev.next=newNode;
+		p.prev=newNode;
+		size++;
+		modCount--;
+	}
+
+	private T remove(Node<T>p){
+		p.next.prev=p.prev;
+		p.prev.next=p.next;
+		size--;
+		modCount++;
+
+		return p.data;
+	}
+
+	private Node<T>getNode(int a){
+		return getNode(a,0,size()-1);
+	}
+
+	private Node<T>getNode(int a,int lower,int upper){
+		Node<T>p;
+
+		if(a<lower||a>upper)
+			throw new IndexOutOfBoundsException();
+		if(a<size()/2){
+			p=begin.next;
+			for(int i=0;i<a;i++)
+				p=p.next;
+		}
+		else
+		{
+			p=end;
+			for(int i=size();i>a;i--)
+				p=p.prev;
+		}
+		return p;
+	}
+	@Override
+	public Iterator iterator() {
+		// TODO Auto-generated method stub
+		return new LinkedListIterator();
+	}
+	private class LinkedListIterator implements Iterator<T>{
+	    private Node<T> current=begin.next;
+	   private int expectedModCount=modCount;
+	   private boolean toRemove=false;
+
+	@Override
+	public boolean hasNext() {
+		// TODO Auto-generated method stub
+		return current!=end;
+	}
+	@Override
+	public T next() {
+		// TODO Auto-generated method stub
+		if(modCount!=expectedModCount)
+			throw new java.util.ConcurrentModificationException();
+		if(!toRemove)
+			throw new IllegalStateException();
+
+		T nextItem=current.data;
+		current=current.next;
+		toRemove=true;
+		return nextItem;
+	}  
+
+	public void remove(){
+		if(modCount!=expectedModCount)
+			throw new java.util.ConcurrentModificationException();
+		if(!toRemove)
+			throw new IllegalStateException();
+
+	    LinkedList.this.remove(current.prev);
+		expectedModCount++;
+		toRemove=false;
+	}
+	}
+
+	private static class Node<T>{
+
+		public T data;
+		public Node<T> prev;
+		public Node<T> next;
+
+		public Node(T d, Node<T> p,Node<T> n) {
+			// TODO Auto-generated constructor stub
+			data=d;prev=p;next=n;
+		}
+
+	}
+
+}
+

group22/17457741/src/Queue.java

@@ -0,0 +1,29 @@
+
+
+public class Queue {
+
+    private ArrayList list = new ArrayList();
+
+    public void enQueue(Object o) {
+        list.add(o);
+    }
+
+    public Object deQueue() {
+        final int size = list.size();
+        if (0 == size)
+            return null;
+        Object o = list.remove(size);
+        return o;
+    }
+
+    public boolean isEmpty() {
+        return list.isEmpty();
+    }
+
+    public int size() {
+        return list.size();
+    }
+
+}
+
+

group22/17457741/src/Stack.java

@@ -0,0 +1,33 @@
+
+
+public class Stack {
+	private ArrayList elementData = new ArrayList();
+
+	public void push(Object o){		
+
+		elementData.add(o);
+	}
+
+	public Object peek(){
+		return elementData.get(0);
+	}
+
+	public Object pop(){
+		Object a = null;
+		if(elementData.size() > 0) {
+
+			a = elementData.get(elementData.size() - 1);
+			elementData.remove(elementData.size() - 1);
+		}
+		return a;
+	}
+
+	public boolean isEmpty(){
+		return elementData.size() == 0;
+	}
+
+	public int size(){
+		return elementData.size();
+	}
+
+}