I am just looking for a basic code that follows all instructions and requirements that work!

Program 4 details
program-4-details-hxtj1bbs.docx

Question

I am just looking for a basic code that follows all instructions and requirements that work!Program 4 details

Rushendra · Accepted Answer

PhoneBookUtility/.classpath
 
	 
		 
			 
		
	
	 
	 
PhoneBookUtility/.project
 
	 PhoneBookUtility
	 
	 
	
	 
		 
			 org.eclipse.jdt.core.javabuilder
			 
			
		
	
	 
		 org.eclipse.jdt.core.javanature
	
PhoneBookUtility/.settings/org.eclipse.jdt.core.prefs
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=15
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=15
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
org.eclipse.jdt.core.compiler.release=enabled
org.eclipse.jdt.core.compiler.source=15
PhoneBookUtility/bin/data_structures/BalancedTree.class
PhoneBookUtility/bin/data_structures/BinarySearchTree$IteratorHelper.class
PhoneBookUtility/bin/data_structures/BinarySearchTree$KeyIteratorHelper.class
PhoneBookUtility/bin/data_structures/BinarySearchTree$Node.class
PhoneBookUtility/bin/data_structures/BinarySearchTree$ValueIteratorHelper.class
PhoneBookUtility/bin/data_structures/BinarySearchTree.class
PhoneBookUtility/bin/data_structures/DictionaryADT.class
PhoneBookUtility/bin/data_structures/HashTable$DictionaryNode.class
PhoneBookUtility/bin/data_structures/HashTable$IteratorHelper.class
PhoneBookUtility/bin/data_structures/HashTable$KeyIteratorHelper.class
PhoneBookUtility/bin/data_structures/HashTable$ValueIteratorHelper.class
PhoneBookUtility/bin/data_structures/HashTable.class
PhoneBookUtility/bin/data_structures/LinearList.class
PhoneBookUtility/bin/data_structures/LinearListADT$IteratorHelper.class
PhoneBookUtility/bin/data_structures/LinearListADT$Node.class
PhoneBookUtility/bin/data_structures/LinearListADT.class
PhoneBookUtility/bin/PhoneBook.class
PhoneBookUtility/bin/PhoneNumber.class
PhoneBookUtility/src/data_structures/BalancedTree.java
PhoneBookUtility/src/data_structures/BalancedTree.java
package data_structures;
import java.util.TreeMap;
import java.util.Map.Entry;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.ConcurrentModificationException;
public class BalancedTree implements DictionaryADT{
    TreeMap treemap;
    public BalancedTree(){
        treemap = new TreeMap();
    }
    
    public boolean contains(K key){
        return treemap.containsKey(key);
    }
    
    public boolean add(K key, V value){
        return treemap.put(key,value)==null;
    }
    public boolean delete(K key){
        if(treemap.remove(key)==null) return false;
        return true;
    }
    
    public V getValue(K key){
        return treemap.get(key);
    }
    
    public K getKey(V value){
        for(Entry map : treemap.entrySet()) {
            if(map.getKey().equals(map.getValue()))
                return map.getKey();
        }
        return null;
    }
    
    public int size(){
        return treemap.size();
    } 
    
    
    public boolean isFull(){
        return false;
    }
    
    public boolean isEmpty(){
        return treemap.isEmpty();
    }
    
    
    public void clear(){
        treemap.clear();
    }
    public Iterator keys(){
        return treemap.keySet().iterator();
    }
    
    public Iterator values(){
        return treemap.values().iterator();
    }
    
    
}
PhoneBookUtility/src/data_structures/BinarySearchTree.java
PhoneBookUtility/src/data_structures/BinarySearchTree.java
package data_structures;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.ConcurrentModificationException;
public class BinarySearchTree implements DictionaryADT {
    private Node root, parent;
    private int currentSize, modificationCounter;
    private K k;
    private boolean wasLeft;
    private int maxSize;
    public BinarySearchTree(int maxSize) {
        root = null;
        parent = null;
        currentSize = 0;
        modificationCounter = 0;
        this.maxSize = maxSize;
    }
    public boolean contains(K key) {
        if (findValue(key, root) == null)
            return false;
        return true;
    }
    public boolean add(K key, V value) {
        if (isFull())
            return false;
        if (contains(key))
            return false;
        if (root == null)
            root = new Node(key, value);
        else
            insert(key, value, root, null, false);
        currentSize++;
        modificationCounter++;
        return true;
    }
    public boolean delete(K key) {
        if (isEmpty())
            return false;
        if (!contains(key))
            return false;
        if (currentSize == 1 && (key).equals(root.key))
            root = null;
        else {
            Node node = find(key, root);
            remove(node, parent);
        }
        currentSize--;
        modificationCounter++;
        return true;
    }
    public V getValue(K key) {
        return findValue(key, root);
    }
    public K getKey(V value) {
        k = null;
        findKey(root, value);
        return k;
    }
    // Returns the number of key/value pairs currently stored
    // in the dictionary
    public int size() {
        return currentSize;
    }
    // Returns true if the dictionary is at max capacity
    public boolean isFull() {
        return currentSize == maxSize;
    }
    // Returns true if the dictionary is empty
    public boolean isEmpty() {
        if (currentSize == 0)
            return true;
        return false;
    }
    public void clear() {
        root = null;
        currentSize = 0;
        modificationCounter = 0;
    }
    public Iterator keys() {
        return new KeyIteratorHelper();
    }
    public Iterator values() {
        return new ValueIteratorHelper();
    }
    private void insert(K key, V value, Node n, Node parent, boolean wasLeft) {
        if (n == null) {
            if (wasLeft)
                parent.leftChild = new Node(key, value);
            else
                parent.rightChild = new Node(key, value);
        } else if (((Comparable) key).compareTo((K) n.key)  n, Node parent) {
        if (n.leftChild == null && n.rightChild == null) {
            if (wasLeft)
                parent.leftChild = null;
            else
                parent.rightChild = null;
        } else if (n.leftChild == null || n.rightChild == null) {
            if (n == root) {
                if (n.leftChild == null) {
                    root = n.rightChild;
                    n.rightChild = null;
                } else {
                    root = n.leftChild;
                    n.leftChild = null;
                }
            } else if (n.leftChild == null && wasLeft) {
                parent.leftChild = n.rightChild;
                n.rightChild = null;
            } else if (n.leftChild == null && !wasLeft) {
                parent.rightChild = n.rightChild;
                n.rightChild = null;
            } else if (n.rightChild == null && wasLeft) {
                parent.leftChild = n.leftChild;
                n.leftChild = null;
            } else {
                parent.rightChild = n.leftChild;
                n.leftChild = null;
            }
        } else {
            Node rightNode, leftNode, successor;
            leftNode = n.leftChild;
            rightNode = successor = n.rightChild;
            if (successor.leftChild == null) {
                n.key = successor.key;
                n.value = successor.value;
                n.rightChild = successor.rightChild;
            } else {
                while (successor.leftChild != null) {
                    rightNode = successor;
                    successor = successor.leftChild;
                }
                if (successor.rightChild == null) {
                    n.key = successor.key;
                    n.value = successor.value;
                    rightNode.leftChild = null;

Program 4 details

Answer To: Program 4 details

Answer To This Question Is Available To Download

Related Questions & Answers

Submit New Assignment