A LinkNodestructure or classwhich will have two attributes - adataattribute and a pointer attribute...

Question

A LinkNodestructure or classwhich will have two attributes - adataattribute and a pointer attribute to thenextnode. The data attribute of the LinkNode should be the Dollar class of Lab 1.

A Singly Linked Listclasswhich will be composed of three attributes - acountattribute, a LinkedNode pointer/reference attribute pointing to thestartof the list and a LinkedNode pointer/reference attribute pointing to theendof the list. Since this is a class, make sure all these attributes are private.

The attribute names for the Node and Linked List are the words in bold in #1 and #2.

For the Linked List, implement the most common linked-list behaviors as explained in class -
1. getters/setters/constructors/destructors for the attributes of the class,
2. (a) create new list, (b) add data, (c) delete data, (d) find data, (e) count of data items in the list, (f) is list empty, (g) empty/destroy the list and (h) print all data items in a list.
3. Any other methods you think would be useful in your program.

A Stackclassderived from the Linked List but with no additional attributes and the usual stack methods - (a) create stack, (b) push, (c) pop, (d) peek, and (e) destroy/empty the stack. Ensure that the Stack objects do not allow Linked List functions to be used on them.

A Queueclassderived from the Linked List but with no additional attributes and the usual queue methods - (a) create queue, (b) enqueue, (c) dequeue, (d) peekFront, (e) peekRear, and (f) destroy/empty the queue. Ensure that the Queue objects do not allow Linked List functions to be used on them.

Ensure that all your classes are mimimal and cohesive with adequate walls around them. Try to reuse and not duplicate any code. Define interfaces as needed, so you can reuse them in your project.

Then write a main driver program that will demonstrate all the capabilities of your ADTs as follows -
1. Create seven (7) Node objects of Dollars to be used in the program.
2. Demonstrate the use of your LinkedList with the seven Dollar Node objects inserted/deleted/searched in a random order. Remember, you will need to print the contents of the List several times to demonstrate the functionality.
3. Demonstrate the use of your Stack with the seven Dollar Node objects pushed/popped/peeked in a random order different from the one in LinkedList.
4. Demonstrate the use of your Queue with the seven Dollar Node objects enqueued/dequeued/peeked in a random order different from both the LinkedList and Stack.
5. Demonstrate use of all the methods above by providing sufficient information to screen for actions being taken.
6. Restrict all your input / output to the main driver program only.

Remember your classes should be in 2 code files - one for LinkedNode and LinkedList and the other for Stack and Queue. Including the code file for your Dollar class as well as main, your submission will have 4 code files. Remember to include pre/post documentation and comment blocks as necessary in your code files. In your submission, also include screenshots.

dollarcurrency-jxfsqbws-3jh1xqtz.java

Arun Shankar · Accepted Answer

StacksAndQueues/.DS_Store
__MACOSX/StacksAndQueues/._.DS_Store
StacksAndQueues/.classpath
 
	 
		 
			 
		
	
	 
	 
StacksAndQueues/.project
 
	 StacksAndQueues
	 
	 
	
	 
		 
			 org.eclipse.jdt.core.javabuilder
			 
			
		
	
	 
		 org.eclipse.jdt.core.javanature
	
StacksAndQueues/bin/Stack.class
StacksAndQueues/bin/Dollar_Currency.class
StacksAndQueues/bin/Queue.class
StacksAndQueues/bin/Main.class
StacksAndQueues/bin/LinkedList$LinkedNode.class
StacksAndQueues/bin/LinkedList.class
StacksAndQueues/.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=14
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=14
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=14
StacksAndQueues/src/LinkedList.java
StacksAndQueues/src/LinkedList.java
class LinkedList
{
  class LinkedNode
  {
    Dollar_Currency data;
    LinkedNode next;
    // Constructor
    LinkedNode(Dollar_Currency data)
    {
      this.data = data;
      this.next = null;
    }
    public String toString()
    {
      return data.toString();
    }
  }
  // Attributes of the LinkedList class
  private LinkedNode start;     // A pointer to the head of the list
  private LinkedNode end;       // A pointer to the end of the list
  private int count;            // Number of nodes in the list
  // Constructor of the class 
  public LinkedList()
  {
    count = 0;
    start = end = null;
  }
  /**
   * @return the number of nodes in the list. 
   */
  public int getCount()
  {
    return this.count;
  }
  /**
   * @return the data item of the first node in the list.
   *         null if the list is empty.
   */
  public Dollar_Currency getFirst()
  {
    if(isEmpty())
        return null;
     return this.start.data;
  } 
  /**
   * @return data item of the last node in the list.
   *         null if the list is empty.
   */
  public Dollar_Currency getLast()
  {
    if(isEmpty())
      return null;
    return end.data;
  }
  
  /**
   * @param data
   * @return nothing
   * The function adds a new node at the end of the list.
   */
  public void addData(Dollar_Currency data)
  {
    LinkedNode newNode = new LinkedNode(data);
    if(isEmpty())
      start = end = newNode; 
    else
    {
        end.next = newNode;
        end = newNode;
    }
    this.count++;
  }
  /**
   * @param     data
   * @return    the first reference to 'data' in the list
   *            while scanning from start to end.
   *            null if 'data' is not present in the list.
   */
  public LinkedNode find(Dollar_Currency data)
  {
    LinkedNode curr = start;
    while(curr != null)
    {
      if(curr.data.equals(data))
        return curr;
      curr = curr.next;
    }
    return null;
  }
  /**
   * This function deletes the first node in the list.
   * @return a reference to the first node in the list
   */
  public Dollar_Currency deleteFrontNode()
  {
    if(isEmpty())
      return null;
    
    Dollar_Currency data = start.data;
    start = start.next;
    this.count--;
    
    if(count == 0)
        end = null;
    
    return data;
  }
  /**
   * @return a reference to the last node in the linked list. 
   * @throws Exception
   */
  public Dollar_Currency deleteEndNode()
  {
    if(isEmpty())   // List is empty. Do nothing
      return null;
    
    LinkedNode curr = start;
    LinkedNode prev = null;
    while(curr != end)
    {
      prev = curr;
      curr = curr.next;
    }
    end = prev;
    end.next = null;
    this.count--;
    return curr.data;
  }
  
  /**
   * The function empties a list.

A LinkNode structure or class which will have two attributes - a data attribute and a pointer attribute to the next node. The data attribute of the LinkNode should be the Dollar class of Lab 1. A...

Answer To: A LinkNode structure or class which will have two attributes - a data attribute and a pointer...

Answer To This Question Is Available To Download

Related Questions & Answers

Submit New Assignment