import java.util.*;

public class QuickSorter
{

    static final int FASTEST = 0; /* ohne zuruecklegen */
    static final int NETWORK_CARD = 1;  /* ohne zuruecklegen */
    static final int REMAINING_BW = 2; /* mit zureucklegen */
    static final int REMAINING_CPU = 3; /* mit zuruecklegen */

    static final int OPERATOR = 7; /* sortiert operatorList nach opId */


    private static ArrayList<Proc> a;
    private static ArrayList<Operator> aOp;
  
    public static void sortFastest(ArrayList<Proc> a0)
	{
	    if(a0.size() == 0) return;
	    a=a0;
	    quicksort(0, a.size()-1, FASTEST);
	}
  
    public static void sortCard(ArrayList<Proc> a0)
	{
	    if(a0.size() == 0) return;
	    a=a0;
	    quicksort(0, a.size()-1, NETWORK_CARD);
	}
 
    public static void sortRemainingBw(ArrayList<Proc> a0)
	{
	    if(a0.size() == 0) return;
	    a=a0;
	    quicksort(0, a.size()-1, REMAINING_BW);
	}
       
    public static void sortRemainingCPU(ArrayList<Proc> a0)
	{
	    if(a0.size() == 0) return;
	    a=a0;
	    quicksort(0, a.size()-1, REMAINING_CPU);
	} 
    
 
  public static void sortOpId(ArrayList<Operator> a0)
    {
	if(a0.size() == 0) return;
	    aOp=a0;
	    quicksortOp(0, aOp.size()-1, OPERATOR);
	}
    

    private static void quicksort (int lo, int hi, int mode)
    {
        int i=lo, j=hi;
	int middle = (lo+hi)/2; 
        Proc x = (Proc)a.get(middle);

        //  Aufteilung
        while (i<=j)
        {    
	    switch(mode) {
	    case FASTEST:
		while (compareFastest((Proc)a.get(i),x)<0) i++; 
		while (compareFastest((Proc)a.get(j),x)>0) j--;
		break;
	    case NETWORK_CARD:
		while (compareCard((Proc)a.get(i),x)<0) i++; 
		while (compareCard((Proc)a.get(j),x)>0) j--;
		break; 
	    case REMAINING_BW:
		while (compareRemainingBw((Proc)a.get(i),x)<0) i++; 
		while (compareRemainingBw((Proc)a.get(j),x)>0) j--;
		break;
	    case REMAINING_CPU:
		while (compareRemainingCPU((Proc)a.get(i),x)<0) i++; 
		while (compareRemainingCPU((Proc)a.get(j),x)>0) j--;
		break;
	  
	    }
	    
            if (i<=j)
		{
                exchange(i, j);
                i++; j--;
            }
        }

        // Rekursion
        if (lo<j) quicksort(lo, j, mode);
        if (i<hi) quicksort(i, hi, mode);
    }

    private static void quicksortOp (int lo, int hi, int mode)
    {
        int i=lo, j=hi;
	int middle = (lo+hi)/2; 
        Operator x = (Operator)aOp.get(middle);
	
        //  Aufteilung
        while (i<=j)
	    {    
		while (compareOpId((Operator)aOp.get(i),x)<0) i++; 
		while (compareOpId((Operator)aOp.get(j),x)>0) j--;
		
		if (i<=j)
		    {
			exchangeOp(i, j);
			i++; j--;
		    }
	    }
	
	// Rekursion
	if (lo<j) quicksortOp(lo, j, mode);
	if (i<hi) quicksortOp(i, hi, mode);
    }
    
 
    private static double compareFastest(Proc a, Proc b) {
	return (b.cpu - a.cpu);
	
    }

    private static int compareOpId(Operator a, Operator b) {
	return (a.id - b.id);
    }

    private static double compareCard(Proc a, Proc b) {
	return (b.bw - a.bw);
    }
    
    private static double compareId(Proc a, Proc b) {
	return (a.id - b.id);
    }
    
    private static double compareRemainingBw(Proc a, Proc b) {
	double remainingA = a.bw - a.bwUsage;
	double remainingB = b.bw - b.bwUsage;
	return (remainingB - remainingA);
    }
    
    private static double compareRemainingCPU(Proc a, Proc b) {
	double remainingA = a.cpu - a.actSumCPU;
	double remainingB = b.cpu - b.actSumCPU;
	return (remainingB - remainingA);
    }  

   
    private static void exchange(int i, int j)
    {
        Proc t = (Proc)a.get(i);
        a.set((i),(Proc)a.get(j));
        a.set(j,t);
    }
    
    private static void exchangeOp(int i, int j)
    {
        Operator t = (Operator)aOp.get(i);
        aOp.set((i),(Operator)aOp.get(j));
        aOp.set(j,t);
    }
    
}    // end class QuickSorter