P r ogram Requirements: Create a class (to be named IntegerList ), to hold integ

Question

Program Requirements:

Create a class (to be named IntegerList), to hold integers. Use dynamic memory allocation (smart pointers) for handling any number of integers at run-time (read the integers until a number greater than 3500 is entered).

The member data elements should be private with public member functions to handle the following operations:

Constructor:

with a pointer to an integer as parameter to initialize the class to contain a copy of the integer

Public Member functions:

Add function (AddtoList) to allow the adding an integer at the end of the list

Print function (PrintNum) to display the integers in the List on the standard output

Count function (CountNum) to return the number of integers stored in the list

Explanation / Answer

package node;

/** Node of a doubly linked list of strings */
public class DNode {
   private int element; // String element stored by a node
   private DNode next, prev; // Pointers to next and previous nodes

   public DNode(int e, DNode p, DNode n) {
       element = e;
       prev = p;
       next = n;
   }

   public int getElement() {
       return element;
   }

   public DNode getPrev() {
       return prev;
   }

   public DNode getNext() {
       return next;
   }

   public void setElement(int newElem) {
       element = newElem;
   }

  
   public void setPrev(DNode newPrev) {
       prev = newPrev;
   }

   public void setNext(DNode newNext) {
       next = newNext;
   }
}

package node;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/** Doubly linked list with nodes of type DNode storing strings. */
public class IntegerList {
   private int size; // number of elements
   private DNode header, trailer; // sentinels

   public IntegerList(int n) {
       size = 1;
       header = new DNode(n, null, null); // create header
       trailer = new DNode(Integer.MAX_VALUE, header, null); // create trailer
       header.setNext(trailer);
   }

   /** Returns the number of elements in the list */
   public int size() {
       return size;
   }

   /** Returns whether the list is empty */
   public boolean isEmpty() {
       return (size == 0);
   }

   /**
   * Returns the first node of the list Precondition: List is not empty
   * Throws: IllegalStateException Indicates that the list is empty
   **/
   public DNode getFirst() throws IllegalStateException {
       if (isEmpty())
           throw new IllegalStateException("List is empty");
       return header.getNext();
   }

   public DNode getLast() throws IllegalStateException {
       if (isEmpty())
           throw new IllegalStateException("List is empty");
       return trailer.getPrev();
   }

   public DNode getPrev(DNode v) throws IllegalArgumentException {
       if (v == header)
           throw new IllegalArgumentException("Cannot move back past the header of the list");
       return v.getPrev();
   }

   public DNode getNext(DNode v) throws IllegalArgumentException {
       if (v == trailer)
           throw new IllegalArgumentException("Cannot move forward past the trailer of the list");
       return v.getNext();
   }

   public void addBefore(DNode v, DNode z) throws IllegalArgumentException {
       DNode u = getPrev(v); // may throw an IllegalArgumentException

       z.setPrev(u);
       z.setNext(v);
       v.setPrev(z);
       u.setNext(z);
       size++;
   }

   public void addAfter(DNode v, DNode z) throws IllegalArgumentException {
       DNode w = getNext(v); // may throw an IllegalArgumentException

       z.setPrev(v);
       z.setNext(w);
       w.setPrev(z);
       v.setNext(z);
       size++;
   }

   public void addFirst(DNode v) {
       addAfter(header, v);
   }

   public void addLast(DNode v) {
       addBefore(trailer, v);
   }

   /**
   * Returns whether a given node has a previous node Parameters: v -
   * reference to a node in the list Precondition: v is not null Returns: true
   * if v has a previous node and the previous node is not a header; false
   * otherwise
   **/
   public boolean hasPrev(DNode v) {
       return (v.getPrev() != header) && (v != header);
   }

   /**
   * Returns whether a given node has a next node Parameters: v - reference to
   * a node in the list Precondition: v is not null Returns: true if v has a
   * next node and the next node is not a trailer; false otherwise
   **/
   public boolean hasNext(DNode v) {
       return (v.getNext() != trailer) && (v != trailer);
   }

   public void printAll() {
       DNode temp = header;

       while (temp.getNext() != null) {
           System.out.println(temp.getElement());
           temp = temp.getNext();
       }
   }

   public static void main(String args[]) throws NumberFormatException, IOException{
      
       BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       IntegerList list = null;
       int number = 0;
      
       while(true){
           System.out.println("Enter the number: ");
           number = Integer.parseInt(br.readLine());
           if(number<3500){
               if(list == null){
                   list = new IntegerList(number);
               }
               else{
                   list.addLast(new DNode(number,null,null));
               }
           }
           else{
               break;
           }
       }
       list.printAll();
   }

}

Output:

Enter the number:
12
Enter the number:
13
Enter the number:
14
Enter the number:
76
Enter the number:
45
Enter the number:
400
Enter the number:
567
Enter the number:
3500
12
13
14
76
45
400
567

Related Questions

Navigate

• Browse (All)
• Browse P
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.