fork download
copy 
  1. class Sorts
  2. {
  3.     // bubble sort
  4.     public static int[] bubbleSort(int[] array)
  5.     {
  6.         int pass = 0;
  7.         boolean sorted = true;
  8.         do
  9.         {
  10.             for(int ii = 0; ii < (array.length-pass)-1; ii++)
  11.             {
  12.                 if(array[ii] > array[ii+1])
  13.                 {
  14.                     int temp = array[ii];
  15.                     array[ii] = array[ii+1];
  16.                     array[ii+1] = temp;
  17.                     sorted = false;
  18.                 }
  19.             }
  20.             pass++;
  21.         } while(sorted != true);
  22.         return array;
  23.     }//bubbleSort()
  24.     // selection sort
  25.     public static int[] selectionSort(int[] array)
  26.     {
  27.         for(int nn = 0; nn < array.length-1; nn++)
  28.         {
  29.             int midIdx = nn;
  30.             for(int jj = nn++; jj < array.length-1; jj++)
  31.             {
  32.                 if(array[jj] < array[midIdx])
  33.                 {
  34.                     midIdx = jj;
  35.                 }
  36.             }
  37.             int temp = array[midIdx];
  38.             array[midIdx] = array[nn];
  39.             array[nn] = temp;
  40.         }
  41.         return array;
  42.     }// selectionSort()
  43.     // insertion sort
  44.     public static int[] insertionSort(int[] array)
  45.     {
  46.         for(int nn = 1; nn < array.length-1; nn++)
  47.         {
  48.             int ii = nn;
  49.             int temp = array[ii];
  50.             while (ii > 0 && array[ii-1] > temp)
  51.             {
  52.                 array[ii] = array[ii-1];
  53.                 ii--;
  54.             }
  55.             array[ii] = temp;
  56.         }
  57.         return array;
  58.     }// insertionSort()
  59.     // mergeSort - wrapper method for kick-starting the recursive algorithm
  60.     public static void mergeSort(int[] array)
  61.     {
  62.         int leftIdx = 0, rightIdx = array.length-1;
  63.         array = mergeSortRecurse(array, leftIdx, rightIdx);
  64.     }//mergeSort()
  65.     private static int[] mergeSortRecurse(int[] array, int leftIdx, int rightIdx)
  66.     {
  67.         if(leftIdx < rightIdx)
  68.         {
  69.             int midIdx = (leftIdx + rightIdx) / 2;
  70.  
  71.             mergeSortRecurse(array, leftIdx, midIdx);
  72.             mergeSortRecurse(array, midIdx++, rightIdx);
  73.  
  74.             merge(array, leftIdx, midIdx, rightIdx);
  75.         }
  76.         return array;
  77.     }//mergeSortRecurse()
  78.     private static int[] merge(int[] array, int leftIdx, int midIdx, int rightIdx) 
  79.     {
  80.         int[] tempArr = new int[leftIdx - rightIdx + 1];
  81.         int ii = leftIdx, jj = midIdx++, kk = 0;
  82.  
  83.         while(ii <= midIdx && jj <= rightIdx)
  84.         {
  85.             if(array[ii] < array[jj])
  86.             {
  87.                 tempArr[kk] = array[ii];
  88.                 ii++;
  89.             }
  90.             else
  91.             {
  92.                 tempArr[kk] = array[jj];
  93.                 jj++;
  94.             }
  95.             kk++;
  96.         }
  97.  
  98.         for(ii = ii; ii < midIdx; ii++)
  99.         {
  100.             tempArr[kk] = array[ii];
  101.             kk++;
  102.         }
  103.         for(jj = jj; jj < rightIdx; jj++)
  104.         {
  105.             tempArr[kk] = array[jj];
  106.             kk++;
  107.         }
  108.  
  109.         for(kk = kk; kk < leftIdx; kk++)
  110.         {
  111.             array[kk] = tempArr[kk - leftIdx];
  112.         }
  113.         return array;
  114.     }//merge()
  115.     // quickSort - wrapper method for kick-starting the recursive algorithm
  116.     public static void quickSort(int[] array)
  117.     {
  118.     	int leftIdx = 0, rightIdx = array.length-1;
  119.     	array = quickSortRecurse(array, leftIdx, rightIdx);
  120.     }//quickSort()
  121.     private static int[] quickSortRecurse(int[] array, int leftIdx, int rightIdx)
  122.     {
  123.     	if(rightIdx > leftIdx)
  124.     	{
  125.     		int pivotIdx = (leftIdx+rightIdx)/2;
  126.     		int newPivotIdx = doPartioning(array, leftIdx, rightIdx, pivotIdx);
  127.  
  128.     		quickSortRecurse(array, leftIdx, newPivotIdx-1);
  129.     		quickSortRecurse(array, newPivotIdx+1, rightIdx);
  130.     	}
  131.     	return array;
  132.     }//quickSortRecurse()
  133.     private static int doPartitioning(int[] array, int leftIdx, int rightIdx, int pivotIdx)
  134.     {
  135.     	int pivotVal = array[pivotIdx];
  136.     	array[pivotIdx] = array[rightIdx];
  137.     	array[rightIdx] = pivotVal;
  138.  
  139.     	int currIdx = leftIdx;
  140.  
  141.     	for(int ii = leftIdx; ii < rightIdx-1; ii++)
  142.     	{
  143.     		if(array[ii] , pivotVal)
  144.     		{
  145.     			int temp = array[ii];
  146.     			array[ii] = array[currIdx];
  147.     			array[currIdx] = temp;
  148.     			currIdx++;
  149.     		}
  150.     	}
  151.  
  152.     	int newPivotIdx = currIdx;
  153.     	array[rightIdx] = array[newPivotIdx];
  154.     	array[newPivotIdx] = pivotVal;
  155.  
  156.         return newPivotIdx;
  157.     }// TEMP - Replace this when you implement QuickSort }//doPartitioning
  158. }//end Sorts class
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
Main.java:143: error: ')' expected
    		if(array[ii] , pivotVal)
    		            ^
Main.java:143: error: illegal start of expression
    		if(array[ii] , pivotVal)
    		             ^
Main.java:143: error: ';' expected
    		if(array[ii] , pivotVal)
    		                       ^
Main.java:143: error: variable declaration not allowed here
    		if(array[ii] , pivotVal)
    		               ^
4 errors
stdout
copy 
Standard output is empty
https://ideone.com/GFcuLx
language:
Java (HotSpot 12)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!