Sortalgoryhtmen

import java.util.Arrays;


public class Sortierung {
    private static int[] _array;
    private final static int _shortViewItemCount = 20;
    private static int _count = 9000;
    private static int _range = 1000;

    /**
     * @param args
     */
    public static void main(String[] args) {
        //*****Initializing*****
        initArray(_count, _range);
        printArray(_array, "Initial array");

        //*****BubbleSort*****
        int[] bubbled = bubbleSort(_array, false);
        printArray(bubbled, "BubbleSort");

        int[] bubbledRev = bubbleSort(_array, true);
        printArray(bubbledRev, "BubbleSort reversed");

        //*****InsertionSort*****
        int[] inserted = insertionSort(_array, false);
        printArray(inserted, "InsertionSort");

        int[] insertedRev = insertionSort(_array, true);
        printArray(insertedRev, "InsertionSort reversed");

        //*****SelectionSort*****
        int[] selected = selectionSort(_array, false);
        printArray(selected, "SelectionSort");

        int[] selectedRev = selectionSort(_array, true);
        printArray(selectedRev, "SelectionSort reversed");

        System.out.println("Icke hab en jelbet T-Shirt an.");
    }

    public static void initArray(int count, int range) {
        _array = new int[count];

        for(int i = 0; i < _array.length; i++) {
            int num = (int)(Math.random() * range);
            _array[i] = num;
        }
    }

    // TODO:
    public static int[] bubbleSort(int[] arr, boolean reverse) {
        //important: do a copy of our array, so the passed one is not altered!
        int[] array = Arrays.copyOf(arr, arr.length);

        long start = System.nanoTime();

        boolean swapped = true;
        int j = 0;
        int swap = 0;

          while (swapped) {
                swapped = false;
                j++;
                for (int i = 0; i < array.length - j; i++) {
                      if (array[i] > array[i + 1]) {
                            swap = array[i];
                            array[i] = array[i + 1];
                            array[i + 1] = swap;
                            swapped = true;
                      }
                }
          }

          long elapsed = System.nanoTime() - start;
          System.out.println("BubbleSort took " + elapsed / 1000000 + " ms");

          if(reverse)
              reverseArray(array);

          return array;
    }

    public static void quickSort(int[] arr, boolean reverse) {
        //important: do a copy of our array, so the passed one is not altered!
        int[] array = Arrays.copyOf(arr, arr.length);
    }

    //TODO: https://www.inf.fh-flensburg.de/lang/algorithmen/sortieren/insert/insertion.htm
    public static int[] insertionSort(int[] arr, boolean reverse) {
        //important: do a copy of our array, so the passed one is not altered!
        int[] array = Arrays.copyOf(arr, arr.length);

        long start = System.nanoTime();

        int len = array.length;
        int j = 0;
        int t = 0;

        for (int i = 0; i < len; i++) {
            j= i;
            t=array[j];
            while(j > 0 && array[j - 1] > t) {
                array[j] = array[j-1];
                j--;
            }
            array[j] = t;
        }

        long elapsed = System.nanoTime() - start;
        System.out.println("InsertionSort took " + elapsed / 1000000 + " ms");

        if(reverse)
            reverseArray(array);

        return array;
    }

    // TODO: https://de.wikipedia.org/wiki/Selectionsort
    public static int[] selectionSort(int[] arr, boolean reverse) {
        //important: do a copy of our array, so the passed one is not altered!
        int[] array = Arrays.copyOf(arr, arr.length);

        long start = System.nanoTime();

        int len = array.length - 1;
        int left = 0;

        do {
            int min = left;

            for(int i = left + 1; i < len; i++) {
                if(array[i] < array[min])
                    min = i;
            }

            int tmp = array[min];
            array[min] = array[left];
            array[left] = tmp;

            left = left + 1;
        } while(left < len);


        long elapsed = System.nanoTime() - start;
        System.out.println("SelectionSort took " + elapsed / 1000000 + " ms");

        if(reverse)
            reverseArray(array);

        return array;
    }

    public static void printArray(int[] array, String desc) {
        int len = array.length;
        boolean shortenedView = false;

        if(len > _shortViewItemCount) {
            len = _shortViewItemCount;
            shortenedView = true;
        }

        System.out.print(desc + ": { ");

        // TODO: join method?
        for(int i = 0; i < len; i++) {
            System.out.print(array[i]);

            if(i < len - 1)
                System.out.print(", ");
            else
                if(shortenedView)
                    System.out.print("...");
        }

        System.out.print(" }");
        if(shortenedView) {
            System.out.print(" (");
            System.out.print(array.length);
            System.out.print(" items in total)");
        }
        System.out.println();
    }

    //TODO: https://stackoverflow.com/questions/2137755/how-do-i-reverse-an-int-array-in-java
    public static void reverseArray(int[] data) {
        for (int left = 0, right = data.length - 1; left < right; left++, right--) {
            int temp = data[left];
            data[left]  = data[right];
            data[right] = temp;
        }
    }
}