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 help

P: 28
I'm having problem to test a recursive version of a binary search algorithm. These are my codes:

Expand|Select|Wrap|Line Numbers
  1. public class OrderedArrayList extends ArrayListClass
  2. {
  3.         //default constructor
  4.     public OrderedArrayList()
  5.     {
  6.         super();
  7.     }
  8.  
  9.         //constructor with a parameter
  10.     public OrderedArrayList(int size)
  11.     {
  12.         super(size);
  13.     }
  14.  
  15.         //copy constructor
  16.     public OrderedArrayList(OrderedArrayList otherList)
  17.     {
  18.         super(otherList);
  19.     }
  20.  
  21.  
  22.         //Method to insert insertItem in the list at the proper
  23.         //place. However, first the list is searched to
  24.         //see if the item to be inserted is already in the list.
  25.         //Postcondition: insertItem is inserted and length++
  26.         //           If insertItem is already in the list or the list
  27.         //           is full, an appropriate message is output.
  28.     public void insert(DataElement insertItem)
  29.     {
  30.         int first = 0;
  31.         int last = length - 1;
  32.         int mid = 0;
  33.  
  34.         boolean found = false;
  35.  
  36.         if(length == 0)   //list is empty
  37.         {
  38.             list[0] = insertItem.getCopy();
  39.             length++;
  40.         }
  41.         else
  42.             if(length == maxSize)
  43.                 System.err.println("Cannot insert into a full list.");
  44.             else
  45.             {
  46.                 while(first <= last && !found)
  47.                 {
  48.                     mid = (first + last) / 2;
  49.  
  50.                     if(list[mid].equals(insertItem))
  51.                         found = true;
  52.                     else
  53.                         if(list[mid].compareTo(insertItem) > 0)
  54.                             last = mid - 1;
  55.                         else
  56.                             first = mid + 1;
  57.                 }//end while
  58.  
  59.                 if(found)
  60.                     System.err.println("The insert item is already in the list. "
  61.                                      + "Duplicates are not allowed.");
  62.                 else
  63.                 {
  64.                     if(list[mid].compareTo(insertItem) < 0)
  65.                         mid++;
  66.  
  67.                     insertAt(mid, insertItem);
  68.                 }
  69.             }
  70.     }//end insert
  71.  
  72.  
  73.      public int recBinarySearch(DataElement[] list, DataElement item, int first, int last)
  74.     {
  75.         if (first > last)
  76.         return - (list[first].compareTo(item) < 0? first++ : first);//base case for unsuccessful search
  77.         else
  78.            {
  79.             int mid = (first + last) / 2;//index for next probe
  80.  
  81.             if (list[mid].equals(item))
  82.             return mid;
  83.             else if(list[mid].compareTo(item) > 0)
  84.             return recBinarySearch(list, item, first, mid - 1);//base case for successful search
  85.             else
  86.             return recBinarySearch(list, item, mid + 1, last);
  87.           }
  88.  
  89.  
  90.     }
  91.  
  92.     public int recBinarySearch(DataElement list[], DataElement item)
  93.     {
  94.         return recBinarySearch(list, item, 0, list.length - 1);
  95.     }
  96.  
  97. }//end binarySearch

Expand|Select|Wrap|Line Numbers
  1. import java.io.*;
  2. import java.util.*;
  3.  
  4. public class TestRecursiveBinarySearchProg
  5. {
  6.     static BufferedReader keyboard = new
  7.            BufferedReader(new InputStreamReader(System.in));
  8.  
  9.     public static void main(String[] args) throws IOException
  10.     {
  11.         OrderedArrayList intList
  12.                           = new OrderedArrayList();
  13.         OrderedArrayList temp =
  14.                             new OrderedArrayList();
  15.  
  16.         IntElement num = new IntElement();
  17.  
  18.  
  19.  
  20.         int counter;
  21.         int result;
  22.  
  23.         StringTokenizer tokenizer;
  24.  
  25.         System.out.print("Enter 10 integers on the " + "same line: ");
  26.  
  27.         System.out.flush();
  28.  
  29.         tokenizer = new
  30.                    StringTokenizer(keyboard.readLine());
  31.  
  32.         for(counter = 0; counter < 10; counter++)
  33.         {
  34.             num.setNum(Integer.parseInt(tokenizer.nextToken()));
  35.             intList.insert(num);
  36.         }
  37.  
  38.         temp.copyList(intList);
  39.  
  40.         System.out.println();
  41.         System.out.print("The list you " + "entered is: ");
  42.         intList.print();
  43.         System.out.println();
  44.  
  45.         System.out.print("Enter the search " +  "item: ");
  46.         System.out.flush();
  47.         num.setNum(Integer.parseInt(keyboard.readLine()));
  48.         System.out.println();
  49.  
  50.           result = recBinarySearch(temp, num());
  51.           System.out.println("Binary search (Recursive): " + result);
  52.     }
  53. }
Nov 27 '06 #1
Share this Question
Share on Google+
3 Replies


10K+
P: 13,264
I'm having problem to test a recursive version of a binary search algorithm. These are my codes:

Expand|Select|Wrap|Line Numbers
  1. public class OrderedArrayList extends ArrayListClass
  2. {
  3. //default constructor
  4. public OrderedArrayList()
  5. {
  6. super();
  7. }
  8.  
  9. //constructor with a parameter
  10. public OrderedArrayList(int size)
  11. {
  12. super(size);
  13. }
  14.  
  15. //copy constructor
  16. public OrderedArrayList(OrderedArrayList otherList)
  17. {
  18. super(otherList);
  19. }
  20.  
  21.  
  22. //Method to insert insertItem in the list at the proper
  23. //place. However, first the list is searched to
  24. //see if the item to be inserted is already in the list.
  25. //Postcondition: insertItem is inserted and length++
  26. // If insertItem is already in the list or the list
  27. // is full, an appropriate message is output.
  28. public void insert(DataElement insertItem)
  29. {
  30. int first = 0;
  31. int last = length - 1;
  32. int mid = 0;
  33.  
  34. boolean found = false;
  35.  
  36. if(length == 0) //list is empty
  37. {
  38. list[0] = insertItem.getCopy();
  39. length++;
  40. }
  41. else
  42. if(length == maxSize)
  43. System.err.println("Cannot insert into a full list.");
  44. else
  45. {
  46. while(first <= last && !found)
  47. {
  48. mid = (first + last) / 2;
  49.  
  50. if(list[mid].equals(insertItem))
  51. found = true;
  52. else
  53. if(list[mid].compareTo(insertItem) > 0)
  54. last = mid - 1;
  55. else
  56. first = mid + 1;
  57. }//end while
  58.  
  59. if(found)
  60. System.err.println("The insert item is already in the list. "
  61. + "Duplicates are not allowed.");
  62. else
  63. {
  64. if(list[mid].compareTo(insertItem) < 0)
  65. mid++;
  66.  
  67. insertAt(mid, insertItem);
  68. }
  69. }
  70. }//end insert
  71.  
  72.  
  73.      public int recBinarySearch(DataElement[] list, DataElement item, int first, int last)
  74. {
  75.         if (first > last)
  76.         return - (list[first].compareTo(item) < 0? first++ : first);//base case for unsuccessful search
  77.         else
  78.          {
  79.             int mid = (first + last) / 2;//index for next probe
  80.  
  81.             if (list[mid].equals(item))
  82.             return mid;
  83.             else if(list[mid].compareTo(item) > 0)
  84.             return recBinarySearch(list, item, first, mid - 1);//base case for successful search
  85.             else
  86.             return recBinarySearch(list, item, mid + 1, last);
  87.          }
  88.  
  89.  
  90.     }
  91.  
  92.     public int recBinarySearch(DataElement list[], DataElement item)
  93.     {
  94.         return recBinarySearch(list, item, 0, list.length - 1);
  95.     }
  96.  
  97. }//end binarySearch

Expand|Select|Wrap|Line Numbers
  1. import java.io.*;
  2. import java.util.*;
  3.  
  4. public class TestRecursiveBinarySearchProg
  5. {
  6. static BufferedReader keyboard = new
  7. BufferedReader(new InputStreamReader(System.in));
  8.  
  9. public static void main(String[] args) throws IOException
  10. {
  11. OrderedArrayList intList
  12. = new OrderedArrayList();
  13. OrderedArrayList temp =
  14. new OrderedArrayList();
  15.  
  16. IntElement num = new IntElement();
  17.  
  18.  
  19.  
  20. int counter;
  21. int result;
  22.  
  23. StringTokenizer tokenizer;
  24.  
  25. System.out.print("Enter 10 integers on the " + "same line: ");
  26.  
  27. System.out.flush();
  28.  
  29. tokenizer = new
  30. StringTokenizer(keyboard.readLine());
  31.  
  32. for(counter = 0; counter < 10; counter++)
  33. {
  34. num.setNum(Integer.parseInt(tokenizer.nextToken()));
  35. intList.insert(num);
  36. }
  37.  
  38. temp.copyList(intList);
  39.  
  40. System.out.println();
  41. System.out.print("The list you " + "entered is: ");
  42. intList.print();
  43. System.out.println();
  44.  
  45. System.out.print("Enter the search " + "item: ");
  46. System.out.flush();
  47. num.setNum(Integer.parseInt(keyboard.readLine()));
  48. System.out.println();
  49.  
  50.          result = recBinarySearch(temp, num());
  51.          System.out.println("Binary search (Recursive): " + result);
  52. }
  53. }
Can't compile it to see what the problem is. Perhaps you should post codes for the other classes being used as well eg ArrayListClass
Nov 28 '06 #2

P: 28
Can't compile it to see what the problem is. Perhaps you should post codes for the other classes being used as well eg ArrayListClass
Here it is

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 recBinarySearch(DataElement[]list, DataElement item, int first, int last);
  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. }
Nov 28 '06 #3

10K+
P: 13,264
Here it is

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 recBinarySearch(DataElement[]list, DataElement item, int first, int last);
  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. }
Have to go now but try matching signatures

public int recBinarySearch(DataElement list[], DataElement item)

result = recBinarySearch(temp, num);

ie. make sure the data types tally
Nov 28 '06 #4

Post your reply

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