נושא: עזרה בjava יעילות והורדת זמן ריצה

public class IntVector 
{
    private int []_arr;

    /**
     * Constructor for objects of class IntVector
     */
    public IntVector(int size)
    {
        _arr= new int[size]; 
    }

public void addInt(int num, int index)
{
 _arr[index] = num;
}


public boolean what (int[] other)
{
    if (_arr.length != other.length)
       return false;
    for (int i=0; i<_arr.length; i++)
    {
        boolean f = false;
        for (int j=0; j<other.length && !f; j++)
           if (_arr == other[j])
               f= true;
        if (!f)
           return false;
    }
    for (int i=0; i<other.length; i++)
    {
        boolean f = false;
        for (int j=0; j<_arr.length && !f; j++)
           if (other == _arr[j])
               f= true;
        if (!f)
           return false;
    }
    return true;
}

}

private void bubble (int[ ] _arr)
{
int last, current, temp;
 for (last = _arr.length-1; last > 0; last--)
 {
   for (current = 0; current < last; current++)
   {

       if ( _arr[current] < _arr[current + 1] )
       {

            temp = _arr[current];

           _arr[current] = _arr[current + 1];

           _arr[current + 1] = temp;

        }

    }
}

private int binary (int[ ] _arr, int num)
{
    int middle, lower = 0, upper = (_arr.length - 1);
    do
    {
        middle = ((lower + upper) / 2);
        if (num < _arr[middle])
        upper = middle - 1;

        else lower = middle + 1;
    }
    while ( (_arr[middle] != num) && (lower <= upper) );

    if (_arr[middle] == num)
    return middle;

    else
    return -1;
}

}

public boolean what (int[] other)
    {

bubble(_arr);

bubble(other);

כאן צריכה לבוא ההשוואה..

}

private void bubble (int[ ] _arr)
{
int last, current, temp;
 for (last = _arr.length-1; last > 0; last--)
 {
   for (current = 0; current < last; current++)
   {

       if ( _arr[current] < _arr[current + 1] )
       {

            temp = _arr[current];

           _arr[current] = _arr[current + 1];

           _arr[current + 1] = temp;

        }

    }
}

public boolean what (int[] other)
    {
        int index = 0 ;
                

bubble(_arr);

bubble(other);

       if ( (binary (other, _arr[index])!=-1) )
       return true;
       else return false;
    }

public boolean what (int[] other)
    {
        int index = 0 ;
        quicksort(_arr, 0, _arr.length-1);
        quicksort(other, 0, other.length-1);
           }

private  void quicksort(int[] a, int lo, int hi)
        {
            int m;

            if (hi > lo+1)
            {       // there are at least 3 elements
                     // so sort recursively
                     m = partition(a,lo, hi);
                     quicksort(a, lo, m-1);
                     quicksort(a, m+1, hi);
            }
            else    // 0, 1, or 2 elements, so sort directly
                    if (hi == lo+1  &&  a[lo] > a[hi])
                         swap(a,lo, hi);
        }

private  int medianLocation(int[] a, int i, int j, int k)
{
            if (a[i] <= a[j])
                if (a[j] <= a[k])
                         return j;
                else if (a[i] <= a[k])
                                 return k;
                           else    return i;
            else    // _arr[j] < _arr[i]
                if (a[i] <= a[k])
                         return i;
                else if (a[j] <= a[k])
                                 return k;
                            else    return j;
   }

private int partition(int[] a, int lo, int hi)
{
    swap(a, lo, medianLocation(a, lo+1, hi, (lo+hi)/2));
    int m = partition(a, lo+1, hi, a[lo]);
    swap(a, lo, m);
    return m;
}

private int partition(int[] a,int lo, int hi, int pivot)
{
    if (hi == lo)
    if (a[lo] < pivot)
        return lo;
    else
        return lo-1;
    else if (a[lo] <= pivot) // a[lo] in correct half
        return partition(a, lo+1, hi, pivot);
       
        else
        {
            // a[lo] in wrong half
            swap(a, lo, hi);
            return partition(a, lo, hi-1, pivot);
        }
}

private void swap(int[] a, int first, int second)
        {  
                //swaps between the contents of the array cells in
                //indexes first and second
                   int  temp;
                   temp = a[first];
                   a[first] = a[second];
                   a[second] = temp;
        }

public boolean what (int[] other)
{
        int n1 = other.length;
       int n2 = _arr.length;
       int i = 0 , j = 0;
        quicksort(_arr, 0, _arr.length-1);
        quicksort(other, 0, other.length-1);
      
while (i < n1 && j < n2)
{
    if (_arr[i] == other[j])
        return false;
    if (_arr[i] > other[j])
        ++j;
    else
        ++i;
}

return true;
}

private  void quicksort(int[] a, int lo, int hi)
{
    int m;

    if (hi > lo+1)
    {       // there are at least 3 elements
            // so sort recursively
      m = partition(a,lo, hi);
      quicksort(a, lo, m-1);
      quicksort(a, m+1, hi);
    }
    else    // 0, 1, or 2 elements, so sort directly
         if (hi == lo+1  &&  a[lo] > a[hi])
             swap(a,lo, hi);
}

private  int medianLocation(int[] a, int i, int j, int k)
{
            if (a[i] <= a[j])
                if (a[j] <= a[k])
                         return j;
                else if (a[i] <= a[k])
                                 return k;
                           else    return i;
            else    // a[j] < a[i]
                if (a[i] <= a[k])
                         return i;
                else if (a[j] <= a[k])
                                 return k;
                            else    return j;
   }

private int partition(int[] a, int lo, int hi)
{
    swap(a, lo, medianLocation(a, lo+1, hi, (lo+hi)/2));
    int m = partition(a, lo+1, hi, a[lo]);
    swap(a, lo, m);
    return m;
}

private int partition(int[] a,int lo, int hi, int pivot)
{
    if (hi == lo)
    if (a[lo] < pivot)
        return lo;
    else
        return lo-1;
    else if (a[lo] <= pivot) // a[lo] in correct half
        return partition(a, lo+1, hi, pivot);
       
        else
        {
            // a[lo] in wrong half
            swap(a, lo, hi);
            return partition(a, lo, hi-1, pivot);
        }
}

private void swap(int[] a, int first, int second)
        {  
                //swaps between the contents of the array cells in
                //indexes first and second
                   int  temp;
                   temp = a[first];
                   a[first] = a[second];
                   a[second] = temp;
        }

import java.util.Scanner;
public class Tester
{
 public static void main ( String[] args)
  {

    // _data = the array
     int [] _arr;
    // MAX = the length of the array
    final int MAX = 6;
   
 
   
         _arr = new int [MAX];
  

     /**
     * enterNumbers is a method that fills the array with data from
     * the user
     */
  
        Scanner scan = new Scanner (System.in);
        for (int i=0; i<_arr.length; i++)
        {
            System.out.print("enter an integer ");
            _arr[i] = scan.nextInt();
        }
  
    /**
     * printArray prints the array content
     */
   
        System.out.print("The array is: ");
        for (int i=0; i<_arr.length; i++)
            System.out.print("\t"+ _arr[i]);
        System.out.println();
       System.out.println(what(_arr)); ??????
    }
}