Please help with natural mergesort

Question

I admit this is homework but I have spent so much time trying to figure this out and can't get a answer any where on the web or in my books,teacher etc.
Problem:
I need to write a natural Mergesort
Best case:O(n)
worst case:O(nlogn)
If you are not aware of natural Mergesort this is how it works.
You scan through an array to discover already sorted chunks you then would store there offsets in a new array.
Like mergesort you want to keep cutting the array in half (with recurrsion) until you are left with two just two elements to merge back together, after they are merged they return to be merged with what called them and so on until the array is sorted.
In mergesort you are dealing with actual values, where as I am dealing with offsets to be that need to be merged.
I am so confused
public void sort(Comparable[] a)
//make sure index array is big enough
int [] indexBuffer=new int[a.length];
int pIndexBuffer=1;
int Index=0;
indexBuffer[0]=0;
while(Index<a.length-1)
     if(a[Index].compareTo(a[Index+1])<0)
          Index++;
     else{
          indexBuffer[pIndexBuffer]=Index+1;
          pIndexBuffer++;
          Index++;
//copy array with a better fit
//do not have to delete old array
//because of java's garbage collection 
int [] IndexBuffer=new int[pIndexBuffer];
for (int i=0;i<IndexBuffer.length;i++)
     IndexBuffer=indexBuffer[i];
     System.out.println(IndexBuffer[i]);
nmsort(a,IndexBuffer, 0, IndexBuffer.length-1);
public void nmsort(Comparable [] a,int [] indexBuffer, int first, int last)
     if(first<last)
          int mid=first+((last-first)/2);
          nmsort(a, indexBuffer, first, mid);
          nmsort(a, indexBuffer, mid+1, last);     
          merge(a, indexBuffer, first, mid, last);
private void merge(Comparable []a, int [] indexBuffer, int first,int mid,int last)
//This is where I am having trouble
This is written in java, and I am not used to the language yet not having pointers seems strange.
So my problem comes to how do I write merge I have tried dozens of things but nothing has yet to work.
In case you would like to see a regular MergeSort here it is:
public void sort(Comparable[] a) 
  nmsort(a, 0, a.length - 1);  
public void nmsort(Comparable[] a, int left, int right)    {     
if (left < right)   
int mid = left + ((right - left) / 2);                        nmsort(a, left, mid);        
nmsort(a, mid + 1, right);           
merge(a, left, mid + 1, right);       
private void merge(Comparable[] a, int left, int mid, int right)  
Comparable[] tmpArray = new Comparable[a.length];  
int leftEnd = mid - 1;  
int tmpPos = 0;    
int left0 = left;   
while ((left <= leftEnd) && (mid <= right))       
if (a[left].compareTo(a[mid]) < 0)  
             tmpArray[tmpPos++] = a[left++];
else             
  tmpArray[tmpPos++] = a[mid++];
while (left <= leftEnd)
   tmpArray[tmpPos++] = a[left++];   
while (mid <= right)          
tmpArray[tmpPos++] = a[mid++];      
for (int i = 0; i < tmpPos; i++)     
      a[left0 + i] = tmpArray;
Thanks for all your help
-Marc                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

Answer 1

If you can't figure out how to do this with reccursion(Divide and Conquer) I am willing to try it another way as long as the big oh is right.
thanks again