MergeSort and Quick Sort

package mergeSort;

import java.util.Random;

/**
 * Array are rearranged with smallest item first
 * @author 
 *
 */
public class MergeSort {
	private static final int NUM_ITEMS = 30;
	private static final Random rnd = new Random();

	public static void main(String[] args) {
		Integer[] a = new Integer[NUM_ITEMS];
		
		for(int i=0; i
   
   
    
    >
	void insertionSort(T[] array, int left, int right){
		for(int p= left+1; p<= right; p++){
			T tmp = array[p];
			int j;
			for(j=p; j>left && tmp.compareTo(array[j-1])<0; j--){
				array[j] = array[j-1];
				array[j] = tmp;
			}
		}
	}
	
	
	
	
	
	
	public static 
    
    
     
     > 
	void mergeSort(T[] a){
		@SuppressWarnings("unchecked")
		T[] tmpArray = (T[]) new Comparable[a.length];
		
		mergeSort(a, tmpArray, 0, a.length-1);
  	}
	
	/**
	 * Internal method that makes recursive calls
	 * @param a an array of Comparable items
	 * @param tmpArray an array to place the merged result
	 * @param left the left-most index of the subarray
	 * @param right the right-most index of the subarray
	 */
	
	private static 
     
     
      
      > 
	void mergeSort(T[] a, T[] tmpArray, int left, int right){
		if(left < right){
			int center = (left + right)/2;
			mergeSort(a, tmpArray, left, center);
			mergeSort(a, tmpArray, center+1, right);
			merge(a, tmpArray, left, center+1, right);
		}
  	}
	
	/**
	 * Internal method that merges two sorted halves of a subarray
	 * @param a
	 * @param tmpArray an array to place the merged result
	 * @param leftPos 
	 * @param rightPos the index of the start of the second half
	 * @param rightEnd
	 */
	private static 
      
      
       
       > 
	void merge(T[] a, T[] tmpArray, int leftPos, int rightPos, int rightEnd){
		int leftEnd = rightPos - 1;
		int tmpPos = leftPos;
		int numEles = rightEnd - leftPos + 1;
		
		//Merge
		while(leftPos <= leftEnd && rightPos <= rightEnd){
			if(a[leftPos].compareTo(a[rightPos])<=0){
				tmpArray[tmpPos++] = a[leftPos++];
			}else{
				tmpArray[tmpPos++] = a[rightPos++];
			}
		}
		
		//copy rest of first half
		while(leftPos <= leftEnd){
			tmpArray[tmpPos++] = a[leftPos++];
		}
		
		//copy rest of right half
		while(rightPos <= rightEnd){
			tmpArray[tmpPos++] = a[rightPos++];
		}
		
		//copy tmpArray back
		for(int i=0; i
       
       
         =0; index--){ //swap(rnd.nextInt(index+1), index); int rndPos = rnd.nextInt(index+1); int tmp = array[rndPos]; array[rndPos]= array[index]; array[index] = tmp; } } } 
       
      
      
     
     
    
    
   
   

The most important thing is to choose proper pivot!!!

import util.SortUtil;

public class QuickSort {

	public static void main(String[] args) {
		int[] a = new int[30];
		
		for(int i=0; i
   
   
    
    =0; index--){
			//swap(rnd.nextInt(index+1), index);
			int rndPos = rnd.nextInt(index+1);
			
			int tmp = array[rndPos];
			array[rndPos]= array[index];
			array[index] = tmp;
		}
	}

}