import java.util.Random;

public class ArrayTools
{

    /*  Diese Methode erzeugt ein int-Array mit der 
     *  angegebenen Laenge.
     */
    public static int[] erzeugeArray(int laenge)
    {
        if (laenge <= 0)
            return new int[0];

        return new int[laenge];
    }

    /* Diese Methode fuellt einen Teil des Array mit Zufallszahlen
     * anzahl = Die Anzahl der zu erzeugenden Arrayelemente
     * min/max= Untere/obere Grenze des Wertebereichs der Zufallszahlen
     */
    public static void fuelleArrayMitZufallszahlen(int[] array, int anzahl, int min, int max)
    {
        if (array == null || anzahl <= 0 || min > max)
            return;

        Random wuerfel = new Random();
        int limit = Math.min(anzahl, array.length);      

        for (int i = 0; i < limit; i++)
        {
            array[i] = wuerfel.nextInt(max - min + 1) + min;
        }
    }

    public static void zeigeArray(int[] array, int anzahl)
    {
        if (array == null || anzahl <= 0)
        {
            System.out.println("(keine Daten)");
            return;
        }

        int limit = Math.min(anzahl, array.length);

        for (int i = 0; i < limit; i++)
        {
            System.out.printf("%5d", array[i]);

            if ((i + 1) % 10 == 0)
                System.out.println();
        }

        System.out.println();
    }   

    public static void zeigeArray(int[] array)
    {
        zeigeArray(array,array.length);
    }

    public static int[] kopiereArray(int [] array)
    {
        int[] temp = new int[array.length];
        for (int i=0; i < array.length; i++)
            temp[i] = array[i];

        return temp;
    }

    /*
     * Hilfsmethoden
     * ------------------------------------------------------------------------------------------
     */

    public static int getMinimum(int[] a)
    {
        int mini = a[0];
        for (int i=1; i<a.length; i++)
            if (a[i] < mini) 
                mini = a[i];

        return mini;
    }

    public static int getMaximum(int[] a)
    {
        int maxi = a[0];
        for (int i=1; i<a.length; i++)
            if (a[i] > maxi) 
                maxi = a[i];

        return maxi;
    }   

    public static int sucheLinearVorwaerts(int[] a, int startIndex, int suchzahl)
    {
        if (a[startIndex] < suchzahl)
        {
            for (int i = startIndex + 1; i < a.length; i++)
            {
                if (a[i] == suchzahl)
                    return i;
                if (a[i] > suchzahl)
                    return -1;
            }
        }

        return -1;
    }  

    public static int sucheLinearRueckwaerts(int[] a, int startIndex, int suchzahl)
    {
        if (a[startIndex] >= suchzahl)
        {
            for (int i = startIndex - 1; i >= 0; i--)
            {
                if (a[i] == suchzahl)
                    return i;
                if (a[i] < suchzahl)
                    return -1;
            }
        }

        return -1;
    }      

    private static void tausche(int[] array, int index1, int index2)
    {
        int temp = array[index1];
        array[index1] = array[index2];
        array[index2] = temp;
    }
    
    /*
     * Sortier- und Suchmethoden
     * ---------------------------------------------------------------------------------------------
     */

    public static void bubblesort(int[] array)
    {
        if (array == null || array.length < 2)
            return;

        int n = array.length;

        for (int durchgang = 0; durchgang < n - 1; durchgang++)
        {
            for (int i = 0; i < n - 1 - durchgang; i++)
            {
                if (array[i] > array[i + 1])
                {
                    tausche(array, i, i + 1);
                }
            }
        }
    }  

    // Sortiert nur die ersten 'n' Elemente eines Arrays mit Selectionsort
    // Wird zum Beispiel fuer einen Bucketsort benoetigt, wenn ein Bucket mit Platz
    // fuer 100 Variablen nur mit 12 Variablen gefuellt ist (n = 12).
    public static void selectionSortTeilarray(int[] array, int n)
    {
        for (int start = 0; start < n - 1; start++)
        {
            int miniPos = start;

            for (int i = start + 1; i < n; i++)
            {
                if (array[i] < array[miniPos])
                    miniPos = i;
            }

            // falls kleineres Element gefunden → tauschen
            int temp = array[start];
            array[start] = array[miniPos];
            array[miniPos] = temp;
        }
    }    
    
    /*
     * Methoden zum Einfuegen und Loeschen von Elementen
     * ---------------------------------------------------------------------------------------------
     */
    

    public static void delete(int[] numbers, int index)
    {
        if (numbers == null || numbers.length == 0)
            return;

        if (index < 0 || index >= numbers.length)
            return;

        // Alle Elemente rechts vom Loeschindex nach links verschieben
        for (int i = index; i < numbers.length - 1; i++)
        {
            numbers[i] = numbers[i + 1];
        }

        // Letztes Element auf 0 setzen
        numbers[numbers.length - 1] = 0;
    }  

    public static void insert(int[] numbers, int index, int value)
    {
        if (numbers == null || numbers.length == 0)
            return;

        if (index < 0 || index >= numbers.length)
            return;

        // Elemente nach rechts verschieben
        // (beginnend am rechten Ende
        for (int i = numbers.length - 1; i > index; i--)
        {
            numbers[i] = numbers[i - 1];
        }

        // Neuen Wert einfuegen
        numbers[index] = value;
    }   

    /*
     * Weitere Analyse-Methoden
     * ---------------------------------------------------------------------------------------------
     */


    public static boolean enthaeltWert(int[] numbers, int value)
    {
        if (numbers == null || numbers.length == 0)
            return false;

        for (int i = 0; i < numbers.length; i++)
        {
            if (numbers[i] == value)
                return true;
        }

        return false;
    }    

    public static boolean istSortiert(int[] array)
    {
        boolean sortiert = true;

        for (int i=0; i < array.length-1; i++)
            if (array[i] > array[i+1])
                return false;

        return true;      
    }


}