Thread: Sorting from lowest to highest issue

I'm very new to Java and ran into a problem. My results are not in order and I'm not sure what I'm doing wrong.

My results come out like this instead of being in order from lowest to highest:
"77 99 44 55 22 88 11 0 66 33"


Here's what I have:

class ArrayIns
   {
   private long[] a;                 // ref to array a
   private int nElems;               // number of data items
//--------------------------------------------------------------
   public ArrayIns(int max)          // constructor
      {
      a = new long[max];                 // create the array
      nElems = 0;                        // no items yet
      }
//--------------------------------------------------------------
   public void insert(long value)    // put element into array
      {
      a[nElems] = value;             // insert it
      nElems++;                      // increment size
      }
//--------------------------------------------------------------
   public void display()             // displays array contents
      {
      for(int j=0; j<nElems; j++)       // for each element,
         System.out.print(a[j] + " ");  // display it
      System.out.println("");
      }
//--------------------------------------------------------------
   public void insertionSort()
      {
      int in, out;
 
      for(out=1; out<nElems; out++)     // out is dividing line
         {
         long temp = a[out];            // remove marked item
         in = out;                      // start shifts at out
         while(in>0 && a[in-1] >= temp) // until one is smaller,
            {
            a[in] = a[in-1];            // shift item to right
            --in;                       // go left one position
            }
         }  // end for
      }  // end insertionSort()
//--------------------------------------------------------------
   }  // end class ArrayIns

// InsertSortTest.java
// Test the insert sort algorithm
//--------------------------------------------------------------
 
class InsertSortTest
{
	public static void main(String[] args) {
		int maxSize = 100; 	// array size
		ArrayIns  arr;		// reference to array
   		arr = new ArrayIns(maxSize);  // create the array
 
 
   		arr.insert(77);
   		arr.insert(99);
   		arr.insert(44);
   		arr.insert(55);
   		arr.insert(22);
   		arr.insert(88);
   		arr.insert(11);
   		arr.insert(00);
   		arr.insert(66);
   		arr.insert(33);
 
   		arr.display();   // display items
   		arr.insertionSort();  // execute insertion sort
   		arr.display();   // display items again
	}
}  // end class InsertSortTest

If you want an algorithm that will sort the array of long type, try this one:
1. get first element, compare it to next element,
if the next element is lower, interchange the two of them.
something like this var[0] > var[1] ? or var[1] < var[0] ?
then, compare again that first element to the next one,
var[0] > var[2] ? if first element is higher, then interchange the their value.
do it until you compare the first element up to the last element.

next get the second element and compare it to the next element
just like what you did with the first element. (just do what you did with first element,
but this time, you don't need to compare the second element to the first element,
since we already got the lowest element of array in first step.
just repeat that until the last element

that's the algorithm

Another way is to use Arrays class in java.
try to read this link.
Java - Arrays (Class)Processing
make sure to read that tutorial.
specially the last part which is the methods and descriptions each methods in Arrays class

At first glance it appears the problem is with the implementation of the insertion sort algorithm. Is insertion sorting what you need to implement? (I.e., you can't use any other algorithm?)

That's correct, jashburn.

A quick google search using the search term "java insertion sort" will give you lots of hits, e.g., Beginning Java - Unit 6 Arrays - Insertion Sort . The referred web page contains the Java code implementation of this algorithm. Hth!