Data structures in java.

Author: krypton36

LinkedListDS.java

@@ -0,0 +1,174 @@
+/* Joshua Villasenor
+	masc0431
+ */
+package data_structures;
+import java.util.*;
+
+public class LinkedListDS<E> implements ListADT<E> {
+	private int size;
+	private Node <E> head, tail;
+	private Node <E> pElement,cElement;
+	
+	public LinkedListDS(){
+		size = 0;
+        head= tail = null;
+	}
+	
+	public void addFirst(E obj) {
+		Node <E> newNode = new Node <E>(obj);
+		
+		if(isEmpty()){
+			head = tail = newNode;
+		}	
+		else{
+			newNode.next = head;
+			head = newNode;
+		}
+		size++;
+	}
+
+	public void addLast(E o) {
+		
+		if(isEmpty()){
+			addFirst(o);
+		}
+		else{
+			Node <E> newNode = new Node <E>(o);
+			tail.next = newNode;
+			tail = newNode;
+			size++;
+		}
+	}
+
+	public E removeFirst() {
+		if(head == null) return null;
+		E tmp = head.data;
+		head = head.next;
+        size--;
+		return tmp;	
+	}
+	
+	public E removeLast() {
+		if(head == null) return null;
+		E temp = tail.data;
+		remove(tail.data);
+        size--;
+		return temp;
+	}
+
+	public E peekFirst() {
+		if(head == null ) return null;
+		return head.data;
+	}
+	
+	public E peekLast() {
+		if(tail == null) return null;
+ 		return tail.data;
+	}
+
+	
+	public E find(E obj) {
+		if(contains(obj))	
+		return cElement.data;
+		return null;
+	}
+
+	public boolean remove(E obj) {
+		boolean rTF = contains(obj);
+
+		if(cElement == null) return false;
+		
+		if(head == tail){
+			if(rTF)
+			    makeEmpty();
+			return rTF;
+		}
+		
+		if(cElement == head){
+			head = head.next;
+		}
+	
+		if(cElement == tail){
+			pElement.next = null;
+			tail = pElement;
+		}
+		else{
+			pElement.next = cElement.next;	
+		}
+		size--;
+		return rTF;
+	}
+	
+	public void makeEmpty() {
+		head = null;
+		tail = null;
+		size = 0;
+	}
+
+	@SuppressWarnings("unchecked")
+	public boolean contains(E obj) {
+		cElement = head;
+		pElement = head;
+    
+		
+		while(cElement != null && ((Comparable<E>)obj).compareTo(cElement.data)!=0){
+			pElement = cElement;
+			cElement = cElement.next;
+		}
+		if(cElement == null) return false;
+		return cElement != null;
+	}
+
+	public boolean isEmpty() {
+		return head==null;
+	}
+
+	public boolean isFull() {
+		return false;
+	}
+	
+	public int size() {
+		return size;
+	}
+	
+	public Iterator<E> iterator() {
+		return new IteratorHelper();
+	}
+	
+	@SuppressWarnings("hiding")
+	private class Node<E>{
+		E data;
+		Node<E> next;
+		
+		public Node(E dat){
+			data = dat;
+			next = null;
+		}
+	}
+	
+	class IteratorHelper implements Iterator<E>{
+		protected Node <E> iterIndex;
+
+		public IteratorHelper(){
+			iterIndex = head;
+		}
+		
+		public boolean hasNext(){
+		 return iterIndex != null;
+		}
+		
+		public E next(){	
+			if(!hasNext()) throw new NoSuchElementException();
+			
+			if(iterIndex == null) return iterIndex.data;
+			
+			E tmp = iterIndex.data;
+			iterIndex = iterIndex.next;
+			
+			return tmp;	
+		}
+		public void remove() {
+			throw new UnsupportedOperationException();
+		}
+	}
+}

ListADT.java

@@ -0,0 +1,59 @@
+/* Joshua Villasenor
+	masc0431
+ */
+package data_structures;
+import java.util.Iterator;
+
+
+public interface ListADT<E> extends Iterable<E> {
+    
+    //  Adds the Object obj to the beginning of the list
+    public void addFirst(E obj);
+    
+    //  Adds the Object obj to the end of the list
+    public void addLast(E o);
+    
+    //  Removes the first Object in the list and returns it.
+    //  Returns null if the list is empty.
+    public E removeFirst();
+    
+    //  Removes the last Object in the list and returns it.
+    //  Returns null if the list is empty.
+    public E removeLast();
+    
+    //  Returns the first Object in the list, but does not remove it.
+    //  Returns null if the list is empty.
+    public E peekFirst();
+    
+    //  Returns the last Object in the list, but does not remove it.
+    //  Returns null if the list is empty.
+    public E peekLast();
+    
+    //  Finds and returns the Object obj if it is in the list, otherwise
+    //  returns null.  Does not modify the list in any way
+    public E find(E obj);
+    
+    //  Removes the first instance of thespecific Object obj from the list, if it exists.
+    //  Returns true if the Object obj was found and removed, otherwise false
+    public boolean remove(E obj);
+    
+    //  The list is returned to an empty state.
+    public void makeEmpty();
+    
+    //  Returns true if the list contains the Object obj, otherwise false
+    public boolean contains(E obj);
+    
+    //  Returns true if the list is empty, otherwise false
+    public boolean isEmpty();
+    
+    //  Returns true if the list is full, otherwise false
+    public boolean isFull();
+    
+    //  Returns the number of Objects currently in the list.
+    public int size();
+    
+    //  Returns an Iterator of the values in the list, presented in
+    //  the same order as the list.
+    public Iterator<E> iterator();
+    
+}

Queue.java

@@ -0,0 +1,59 @@
+/* Joshua Villasenor
+	masc0431
+ */
+package data_structures;
+import java.util.*;
+
+public class Queue<E> implements Iterable<E> {
+	ListADT <E> list;
+	
+	public Queue(){
+		list = new LinkedListDS <E>();
+	}
+	// inserts the object obj into the queue
+    public void enqueue(E obj) {
+    	list.addLast(obj);
+    } 
+    // removes and returns the object at the front of the queue   
+    public E dequeue() {
+    	return list.removeFirst();
+    }
+    
+    // returns the number of objects currently in the queue    
+    public int size() {
+    	return list.size();
+    }
+    
+    // returns true if the queue is empty, otherwise false   
+    public boolean isEmpty() {
+    	return list.isEmpty();
+    }
+    
+    // returns but does not remove the object at the front of the queue   
+    public E peek() {
+    	return list.peekFirst();
+    }
+    
+    // returns true if the Object obj is in the queue    
+    public boolean contains(E obj) {
+    	return list.contains(obj);
+    }
+     
+    // returns the queue to an empty state  
+    public void makeEmpty() {
+    	list.makeEmpty();
+    }
+    
+    // removes the Object obj if it is in the queue and
+    // returns true, otherwise returns false.
+    public boolean remove(E obj){
+    	return list.remove(obj);
+    }
+    
+    // returns an iterator of the elements in the queue.  The elements
+    // must be in the same sequence as dequeue would return them.    
+    public Iterator<E> iterator() {
+    	return list.iterator();
+    }
+
+}

Stack.java

@@ -0,0 +1,60 @@
+/* Joshua Villasenor
+	masc0431
+ */
+package data_structures;
+import java.util.*;
+
+public class Stack <E> implements Iterable<E> {
+	ListADT <E> list;
+	public Stack(){
+		list = new LinkedListDS<E>();
+	}
+	// inserts the object obj into the stack
+    public void push(E obj) {
+    	list.addFirst(obj);
+    }
+    
+    // pops and returns the element on the top of the stack    
+    public E pop() {
+    	return list.removeFirst();
+    }
+    
+    // returns the number of elements currently in the stack
+    public int size() {
+    	return list.size();
+    }
+    
+    // return true if the stack is empty, otherwise false
+    public boolean isEmpty()  {
+    	return list.isEmpty();
+    }
+    
+    // returns but does not remove the element on the top of the stack    
+    public E peek() {
+    	return list.peekFirst();
+    }
+     
+    // returns true if the object obj is in the stack,
+    // otherwise false   
+    public boolean contains(E obj) {
+    	return list.contains(obj);
+    }
+    
+    // returns the stack to an empty state    
+    public void makeEmpty() {
+    	list.makeEmpty();
+    }
+    
+    // removes the Object obj if it is in the stack and
+    // returns true, otherwise returns false.
+    public boolean remove(E obj) {
+    	return list.remove(obj);
+    }
+    
+    // returns a iterator of the elements in the stack.  The elements
+    // must be in the same sequence as pop() would return them.    
+    public Iterator<E> iterator() {
+    	return list.iterator();
+    }
+
+}