Need help with sorting random array of integers

[Ray Chappel]

I am not sure if this belongs here or in beginners. I have been working on this assignment for a while now and I can't figure this one issue out. I was given four files, Name.java, SortableArrayList.java, NameListDriver.java, and SortableArrayListWithBubbleSort.java. The program is meant to take a text file with a list of names and sort them alphabetically. Part one of the assignment was to change the bubble sort to a recursive selection sort. I seem to have completed that part. The second part requires me to make a driver that does the following things: Fill an array with random integers, output the array before sorting, then sort the array and output the sorted array. The size of the array is determined by a command line argument. It is supposed to be sorted by the same method that sorts the text file. I am able to create the array of random integers and output them, but I cant sort them.

Here is the randomDriver.java, which creates the array and outputs.

import java.util.*;
import java.io.*;
import java.util.Arrays;

class randomDriver
{
 
public static void main (String args[])
{//start main
	int capacity = Integer.parseInt(args[0]);
	
	int[] listItem = new int[capacity];
	
	Random generator = new Random();
	
	//fills array with random integers
	
	for (int i = 0; i < listItem.length; i++)
	{//for
		listItem[i] = (generator.nextInt(1001));
	}//for

SortableArrayList nameList = new SortableArrayListWithSelectionSortII(capacity);

//output array before sort

System.out.println("List of numbers before sort:\n");
System.out.println(Arrays.toString(listItem));

//sort array and display

nameList.sort(); //sort list
System.out.println("\nList of numbers after sort:\n");
System.out.println(Arrays.toString(listItem));

}//end main


}//end class

Now here is the SortableArrayListWithSelectionSortII.java that sorts the array. It works for the list of names, but not for the integers. It seems like the if (lowIndex < highIndex) statement isnt working for the array of integers.

//class that uses a selection sort to sort the text file of names
class SortableArrayListWithSelectionSortII<T extends Comparable<T>>
      extends SortableArrayList<T>
{

  public SortableArrayListWithSelectionSortII(int capacity)
  {
     super(capacity);
  }
  // sortSublist method

   protected void sortSublist(int lowIndex, int highIndex)
   {//start sortSublist
	System.out.println("sortSublist is linked");
	if (lowIndex < highIndex)
	{//start if
	   for (int i = lowIndex; i < highIndex; i++)
		{ //start for
		int indexOfNextSmallest = getIndexOfSmallest(listItem, i, highIndex-1);
		swap(listItem, i, indexOfNextSmallest);
		}//end for
		sortSublist(lowIndex, highIndex - 1);//recursive call
	}// end if
   } //end sortSublist

   private static <T extends Comparable<T>>
           int getIndexOfSmallest(T[] listItem, int first, int last)
   {
      T min = listItem[first];
      int indexOfMin = first;
      for (int i = first + 1; i <= last; i++)
      {
         if (listItem[i].compareTo(min) < 0)
         {
            min = listItem[i];
            indexOfMin = i;
         } // end if
         // Assertion: min is the smallest of a[first] through a[index].
      } // end for

      return indexOfMin;
   } // end getIndexOfSmallest

 
   private static void swap(Object[] listItem, int i, int j)
   {
      Object temp = listItem[i];
      listItem[i] = listItem[j];
      listItem[j] = temp; 
   } // end swap
} // end SortArray

Here is the SortableArrayList abstract class

abstract class SortableArrayList<T extends Comparable<T>>
{
   protected T[] listItem;
	
	protected int itemCount;
	
	private static int DEFAULT_CAPACITY = 50;
	
	private boolean isSorted;
	
	// Constructs a list with the specified capacity
	public SortableArrayList(int capacity)
	{
	   @SuppressWarnings("unchecked")
	   T[] tempList = (T[]) new Comparable[DEFAULT_CAPACITY];
		listItem = tempList;
		itemCount = 0;
		isSorted = false;
   }

   // Constructs a list with the default capacity	
	public SortableArrayList()
	{
	   this(DEFAULT_CAPACITY);
	}
	
   /* Adds item to end of list
	   pre-contition: itemCount < listItem.length() - 1
		post-contition: itemCount == itemCount@pre + 1
		                item added to end of list
	*/	
	public void append(T newItem)
	{
	  listItem[itemCount] = newItem;
	  itemCount++;
	  isSorted = false;  //List may no longer be sorted
	}
	
	/* Return item in given position
	   If position is out of range, return null
	*/
	public T getItem(int position)
	{
	   if (0 <= position && position < itemCount)
		  return listItem[position-1];
		else
		  return null;
	}
	
	// Return length of list
	public int getLength()
	{
	  return itemCount;
	}
	
	// Sort list
	public void sort()
	{
	  sortSublist(0,itemCount-1);
	}
	
	// Sort sublist from lowIndex to highIndex
	abstract protected void sortSublist(int lowIndex, int highIndex);
	
	/*
	  Returns the position of the item with the given value.
	  If the item is not in the list, returns -1.
	*/
	public int search(T searchValue)
	{
	   if (isSorted)
		{
		  return binarySearch(searchValue,0,itemCount-1);
		}
		else
		{
		  return linearSearch(searchValue);
		}
	}
	
	/*
	  Searches for the index of the given value using the binary search algorithm
	*/ 
	private int binarySearch(T searchValue, int lowIndex, int highIndex)
	{
	   if (highIndex < lowIndex)
		{
		  return -1; // not in list
		}
		else
		{
		  int midIndex = lowIndex + (highIndex-lowIndex)/2;
		
		  if (listItem[midIndex].equals(searchValue))
		  {
		    return midIndex;  //found it -- position is one more than index
		  }
		  else if (listItem[midIndex].compareTo(searchValue) > 0)
		  {
		    // searchValue comes before midIndex in array
		    return binarySearch(searchValue,lowIndex,midIndex-1);
		  }
		  else
		  {
		     // listItem[midIndex] comes after midIndex in array
		     return binarySearch(searchValue,midIndex+1,highIndex);
		  }
		}
	}
	
	// Searches for the index of the given value using linear search
	private int linearSearch(T searchValue)
	{
	   int index = itemCount-1;
		
		while (index >= 0 && !listItem[index].equals(searchValue))
		{
		   index--;
		}
		
		return index;
	}
	
}

It seems like the problem is with the first if statement in SortableArrayListWithSelectionSortII.java. It doesn't work with the bubble sort method that was originally supplied to me either. I am wondering if it might have to do with either variable names or data types? My sanity appreciates the help.

[Jayesh A Lalwani]

It's difficult to wade through 350 lines of code. Have you tried debugging through the code? Can you make a SSCCE? It might help narrow down your problem

[Ray Chappel]

I took out the classes, methods, and files that I don't think pertain to my problem. I have tried debugging and have spent a lot of time on this and I have hit a brick wall and can not figure this out.

[Ray Chappel]

SortableArrayList nameList = new SortableArrayListWithSelectionSortII(capacity);
//output array before sort
System.out.println("List of numbers before sort:\n");
System.out.println(Arrays.toString(listItem));
//sort array and display
nameList.sort(); //sort list
System.out.println("\nList of numbers after sort:\n");
System.out.println(Arrays.toString(listItem));

I was told this by someone else on another forum. It makes sense to me, but I'm just not sure how to fix the issue.

You create an empty SortableArrayList called nameList, then you print some stuff that's not connected to nameList, then you sort nameList even though it is empty, then you print some other stuff not connected to nameList. I expect that accomplishes very little.

I also notice that you print listItem twice without changing it between the two printings. That doesn't seem useful either.

[Tony Docherty]

I was told this by someone else on another forum. It makes sense to me, but I'm just not sure how to fix the issue.

Just looking at the extract of code shown (I don't have the time to wade through you initial post) and the attached comment I would say you have to copy the data from listItem to nameList and print out the contents of nameList.

[Ray Chappel]

thank you for your help