By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
438,034 Members | 822 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 438,034 IT Pros & Developers. It's quick & easy.

need assistance

P: 28
I need to call the recursive binarySearch method from my OrderedArrayList class into my main program

Expand|Select|Wrap|Line Numbers
  1. public abstract class ArrayListClass
  2. {
  3.     protected int length;           //to store the length of the list
  4.     protected int maxSize;          //to store the maximum size of the list
  5.     protected DataElement[] list;   //array to hold the list elements
  6.  
  7.  
  8.         //Default constructor
  9.         //Creates an array of size 100
  10.         //Postcondition: list points to the array, length = 0,
  11.         //               and maxSize = 100
  12.     public ArrayListClass()
  13.     {
  14.         maxSize = 100;
  15.  
  16.         length = 0;
  17.         list = new DataElement[maxSize];
  18.     }
  19.  
  20.         //Constructor with parameter
  21.         //Creates an array of size specified by the parameter
  22.         //size.
  23.         //Postcondition: list points to the array, length = 0,
  24.         //               and maxSize = size
  25.     public ArrayListClass(int size)
  26.     {
  27.         if(size <= 0)
  28.         {
  29.             System.err.println("The array size must be positive. "
  30.                              + "Creating an array of size 100. ");
  31.              maxSize = 100;
  32.         }
  33.         else
  34.             maxSize = size;
  35.  
  36.         length = 0;
  37.         list = new DataElement[maxSize];
  38.     }
  39.  
  40.          //copy constructor
  41.     public ArrayListClass(ArrayListClass otherList)
  42.     {
  43.         maxSize = otherList.maxSize;
  44.         length = otherList.length;
  45.         list = new DataElement[maxSize];    //create the array
  46.  
  47.         for(int j = 0; j < length; j++)  //copy otherList
  48.             list[j] = otherList.list[j].getCopy();
  49.     }//end copy constructor
  50.  
  51.  
  52.         //Method to determine whether the list is empty.
  53.         //Postcondition: Returns true if the list is empty;
  54.         //               otherwise, returns false.
  55.     public boolean isEmpty()
  56.     {
  57.         return (length == 0);
  58.     }
  59.  
  60.         //Method to determine whether the list is full.
  61.         //Postcondition: Returns true if the list is full;
  62.         //               otherwise, returns false.
  63.     public boolean isFull()
  64.     {
  65.         return (length == maxSize);
  66.     }
  67.  
  68.         //Method to return the number of elements in the list.
  69.         //Postcondition: Returns the value of length.
  70.     public int listSize()
  71.     {
  72.         return length;
  73.     }
  74.  
  75.         //Method to return the maximum size of the list.
  76.         //Postcondition: Returns the value of maxSize.
  77.     public int maxListSize()
  78.     {
  79.         return maxSize;
  80.     }
  81.  
  82.         //Method to output the elements of the list.
  83.         //Postcondition: Elements of the list are output on the
  84.         //standard output device.
  85.     public void print()
  86.     {
  87.         for(int i = 0; i < length; i++)
  88.             System.out.print(list[i] + " ");
  89.         System.out.println();
  90.     }
  91.  
  92.         //Method to determine whether item is the same as the item in
  93.         //the list at the position specified by location.
  94.         //Postcondition: Returns true if list[location] is
  95.         //               same as location; otherwise, returns false.
  96.     public boolean isItemAtEqual(int location, DataElement item)
  97.     {
  98.           return(list[location].equals(item));
  99.     }
  100.  
  101.         //Method to insert insertItem in the list at the position
  102.         //specified by location.
  103.         //Postcondition: Starting at location, the elements of the list
  104.         //               are shifted to make room for the new item,
  105.         //               list[location] = insertItem;, and
  106.         //               length++;
  107.         //     If the list is full or location is out of range,
  108.         //     an appropriate message is displayed.
  109.     public void insertAt(int location, DataElement insertItem)
  110.     {
  111.         if(location < 0 || location >= maxSize)
  112.             System.err.println("The position of the item to be inserted "
  113.                               + "is out of range");
  114.         else
  115.             if(length >= maxSize)  //list is full
  116.                 System.err.println("Cannot insert in a full list.");
  117.             else
  118.             {
  119.                 for(int i = length; i > location; i--)
  120.                     list[i] = list[i - 1];  //move the elements down
  121.  
  122.                 list[location] = insertItem.getCopy();  //insert the
  123.                                         //item at the specified position
  124.                 length++;   //increment the length
  125.             }
  126.     } //end insertAt
  127.  
  128.         //Method to inserts insertItem at the end of the list.
  129.         //Postcondition: list[length] = insertItem; and length++;
  130.         //           If the list is full, an appropriate
  131.         //           message is displayed.
  132.     public void insertEnd(DataElement insertItem)
  133.     {
  134.         if(length >= maxSize)  //the list is full
  135.             System.err.println("Cannot insert in a full list.");
  136.         else
  137.         {
  138.               list[length] = insertItem.getCopy();  //insert the
  139.                                                   //item at the end
  140.               length++; //increment the length
  141.         }
  142.     } //end insertEnd
  143.  
  144.         //Method to remove the item from the list at the position
  145.         //specified by location.
  146.         //Postcondition: The list element at list[location] is removed
  147.         //    and length is decremented by 1.
  148.         //    If location is out of range, an appropriate message
  149.         //    is printed.
  150.     public void removeAt(int location)
  151.     {
  152.         if(location < 0 || location >= length)
  153.             System.err.println("The location of the item to be removed "
  154.                              + "is out of range.");
  155.         else
  156.         {
  157.             for(int i = location; i < length - 1; i++)
  158.                   list[i] = list[i+1];
  159.  
  160.             list[length - 1] = null;
  161.  
  162.             length--;
  163.         }
  164.     } //end removeAt
  165.  
  166.  
  167.         //Method to retrieve  the element from the list at the
  168.         //position specified by location.
  169.         //Postcondition: A copy of the element at the position
  170.         //               specified by location is returned.
  171.         //               If location is out of range, an
  172.         //               appropriate message is printed and
  173.         //               null is returned.
  174.     public DataElement retrieveAt(int location)
  175.     {
  176.         if(location < 0 || location >= length)
  177.         {
  178.            System.err.println("The location of the item to be "
  179.                             + "retrieved is out of range.");
  180.            return null;
  181.         }
  182.         else
  183.            return list[location].getCopy();
  184.     } //end retrieveAt
  185.  
  186.         //Method to replace the element in the list at
  187.         //the position specified by location with repItem.
  188.         //Postcondition: list[location] = repItem
  189.         //     If location is out of range, an appropriate
  190.         //     message is printed.
  191.     public void replaceAt(int location, DataElement repItem)
  192.     {
  193.         if(location < 0 || location >= length)
  194.               System.err.println("The location of the item to be replaced "
  195.                                + "is out of range.");
  196.         else
  197.            list[location].makeCopy(repItem);
  198.     } //end replaceAt
  199.  
  200.           //Method to remove all the elements from the list.
  201.           //Postcondition: length = 0
  202.     public void clearList()
  203.     {
  204.         for(int i = 0; i < length; i++)
  205.             list[i] = null;
  206.  
  207.           length = 0;
  208.  
  209.         System.gc();
  210.     } //end clearList
  211.  
  212.         //Method to determine whether searchItem is in the list.
  213.         //Postcondition: If searchItem is found, returns the location
  214.         //               in the array where searchItem is found;
  215.         //               otherwise, returns -1.
  216.     public abstract int binarySearch(DataElement[]list, DataElement searchItem);
  217.  
  218.  
  219.         //Method to insert insertItem in the list.
  220.         //However, first the list is searched to see whether
  221.         //the item to be inserted is already in the list.
  222.         //Postcondition: insertItem is inserted and length++
  223.         //           If insertItem is already in the list or the list
  224.         //           is full, an appropriate message is output.
  225.     public abstract void insert(DataElement insertItem);
  226.  
  227.  
  228.         //Method to remove an item from the list.
  229.         //The parameter removeItem specifies the item to
  230.         //be removed.
  231.         //Postcondition: If removeItem is found in the list, it is
  232.         //               removed from the list and length is
  233.         //               decremented by one.
  234.  
  235.     public void copyList(ArrayListClass otherList)
  236.     {
  237.           if(this != otherList) //avoid self-assignment
  238.           {
  239.               for(int j = 0; j < length; j++)  //destroy this list
  240.                 list[j] = null;
  241.             System.gc();
  242.  
  243.                 maxSize = otherList.maxSize;
  244.             length = otherList.length;
  245.             list = new DataElement[maxSize];    //create the array
  246.  
  247.             for(int j = 0; j < length; j++)     //copy otherList
  248.                 list[j] = otherList.list[j].getCopy();
  249.           }
  250.     }
  251. }
  252.  
  253.  
Nov 21 '06 #1
Share this question for a faster answer!
Share on Google+

Post your reply

Sign in to post your reply or Sign up for a free account.