final docs

.gitattributes

@@ -0,0 +1,6 @@
+#
+# https://help.github.com/articles/dealing-with-line-endings/
+#
+# These are explicitly windows files and should use crlf
+*.bat           text eol=crlf
+

.gitignore

@@ -39,3 +39,6 @@ gradle-app.setting
 # # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
 # gradle/wrapper/gradle-wrapper.properties
 
+
+# Ignore Gradle build output directory
+build

build.gradle

@@ -0,0 +1,28 @@
+apply plugin: 'java'
+apply plugin: 'application'
+
+mainClassName = 'de.redstoneunion.git.MrGeorgen.timsort.test'
+
+// tag::repositories[]
+repositories {
+    mavenCentral()
+}
+// end::repositories[]
+
+// tag::jar[]
+jar {
+    archiveBaseName = 'timsort'
+    archiveVersion =  '0.1.0'
+}
+// end::jar[]
+
+// tag::dependencies[]
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
+
+dependencies {
+}
+// end::dependencies[]
+
+// tag::wrapper[]
+// end::wrapper[]

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,185 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=`expr $i + 1`
+    done
+    case $i in
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=`save "$@"`
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -0,0 +1,10 @@
+/*
+ * This file was generated by the Gradle 'init' task.
+ *
+ * The settings file is used to specify which projects to include in your build.
+ *
+ * Detailed information about configuring a multi-project build in Gradle can be found
+ * in the user manual at https://docs.gradle.org/6.7/userguide/multi_project_builds.html
+ */
+
+rootProject.name = 'timsort'

src/main/java/de/redstoneunion/git/MrGeorgen/timsort/test.java

@@ -0,0 +1,17 @@
+package de.redstoneunion.git.MrGeorgen.timsort;
+
+import java.util.Arrays;
+
+import de.redstoneunion.git.MrGeorgen.timsort.timsort;
+
+public class test {
+	public static void main(String[] args) {
+		long startTime = System.nanoTime();
+		int[] test = timsort.timsort(new int[]{20, 1, 573, 34, 281, 201, 0});
+		long endTime = System.nanoTime();
+
+		System.out.println(Arrays.toString(test));
+		long duration = (endTime - startTime);
+	System.out.println("Program executed in " + duration + " nanoseconds.");
+	}
+}

src/main/java/de/redstoneunion/git/MrGeorgen/timsort/timsort.java

@@ -0,0 +1,111 @@
+package de.redstoneunion.git.MrGeorgen.timsort;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class timsort {
+	private static int[] insertionsort(int[] unsorted) {
+		int[] output = new int[unsorted.length];
+		output[0] = unsorted[0]; // copies the first element
+		for(int i = 1; i < unsorted.length; ++i) {
+			int foundIndex = binarySearch(output, unsorted[i], 0, i); // searches the right index using binary search
+			for(int j = i; j > foundIndex; --j) { // shift each element after the found index one to the right
+				output[j] = output[j - 1];
+			}
+			output[foundIndex] = unsorted[i]; // insert the element
+		}
+		return output;
+	}
+	private static int binarySearch(int[] array, int search, int minIndex, int maxIndex) {
+		for(int j = maxIndex - 1; minIndex != maxIndex; j = minIndex + (maxIndex - minIndex) / 2 /* set j to middle between min and max Index */) {
+			if(search >= array[j]) {// check if the element is larger and set min or max Index accordingly
+				minIndex = j + 1;
+			}
+			else {
+				maxIndex = j;
+			}
+		}
+		return minIndex;
+	}
+	public static int[] timsort(int[] unsorted) {
+		// calculate minrun
+		int r = 0; 
+		// r becomes 1 any 1 bits are shifted off
+		int n = unsorted.length;
+		while(n >= 16)  {
+			r |= (n & 1);
+			n >>= 1;
+		} 
+		int minRun = n + r;
+
+		// split array into runs
+		ArrayList<int[]> runs = new ArrayList<int[]>();
+		for(int i = 0; i < unsorted.length - 1;) {
+			int j = i;
+			boolean ascending = true;
+			boolean descending = true;
+			boolean ascendingCache = false; // cache variables are needed to know if it is ascending or descending, both ascending and descending are false after the loop
+			boolean descendingCache = false;
+			for(; i < unsorted.length - 1 && (ascending || descending); ++i) {
+				ascendingCache = ascending;
+				descendingCache = descending;
+				ascending = ascending && unsorted[i] <= unsorted[i + 1];
+				descending = descending && unsorted[i] >= unsorted[i + 1];
+			}
+			boolean minRunNotMet = i - j < minRun;
+			if(minRunNotMet) i = j + minRun; // if minrun is not met enlarge the array range
+			if(i > unsorted.length) i = unsorted.length; // if the Index is out of Bounds set to the maxium.
+			int[] temp1 = Arrays.copyOfRange(unsorted, j, i); // the index same as the length is not out of Bounds because copyOfRange is excluding the last index
+			if(!ascendingCache && descendingCache && !minRunNotMet) { // if the array is descending and not ascending (if it is both all values are equal) and minrun is met (if it is not met the run is not ascending nor descending because of the enlargment of the run
+				// reverses the array
+				int l, temp; 
+				for(l = 0; l < temp1.length / 2; l++) { 
+					temp = temp1[l]; 
+					temp1[l] = temp1[temp1.length - l - 1]; 
+					temp1[temp1.length - l - 1] = temp; 
+				}
+			}
+			runs.add(temp1);
+		}
+
+		int[][] notMerged = new int[runs.size()][];
+		for(int i = 0; i < runs.size(); ++i) { // sort each runs with insertionsort
+			notMerged[i] = insertionsort(runs.get(i));
+		}
+		return merge(notMerged)[0];
+	}
+	private static int[][] merge(int[][] notMerged) {
+		int notEvenLen = notMerged.length % 2;
+		int[][] merged = new int[notMerged.length / 2 + notEvenLen][]; // the merged array is half as the unmerged. if the length of notMerged is not even we have to add one because the one remaining arary will just be copied
+		for(int i = 0; i < notMerged.length - 1; /* -1 becasue index of i + 1 is used later */ i += 2) {
+			int[] temp = new int[notMerged[i].length + notMerged[i + 1].length]; // length of the merged is the sum of the 2 not merged arrays
+			merged[i / 2] = temp;
+			int[] j = new int[2]; // index variable: [0]: notMerged[i], [1]: notMerged[i + 1]
+			int relativeIndexOfSmallerArray = 0;
+			int l = 0;
+			for(int gallopingCounter = 0; j[relativeIndexOfSmallerArray] < notMerged[i + relativeIndexOfSmallerArray].length; ++l) {
+				if(gallopingCounter == 7) { // do galloping if 7 elements in a row came from one array
+					int relativeIndexOfLargerArray = relativeIndexOfSmallerArray  != 0 ? 0 : 1;
+					int found = binarySearch(notMerged[i + relativeIndexOfSmallerArray], notMerged[i + relativeIndexOfLargerArray][j[relativeIndexOfLargerArray]], j[relativeIndexOfSmallerArray], notMerged[i + relativeIndexOfSmallerArray].length - 1); // use binray search to out how many elements can be copied from the same array
+					for(; j[relativeIndexOfSmallerArray] < found; ++j[relativeIndexOfSmallerArray], ++l) { // copy elements
+						temp[l] = notMerged[i + relativeIndexOfSmallerArray][j[relativeIndexOfSmallerArray]];
+					}
+				}
+				int lastRelativeIndexOfSmallerArray  = relativeIndexOfSmallerArray;
+				relativeIndexOfSmallerArray  = notMerged[i][j[0]] > notMerged[i + 1][j[1]] ? 1 : 0;
+				temp[l] = notMerged[i + relativeIndexOfSmallerArray][j[relativeIndexOfSmallerArray]]; // copy the element to the output array
+				++j[relativeIndexOfSmallerArray];
+				if(relativeIndexOfSmallerArray  == lastRelativeIndexOfSmallerArray ) ++gallopingCounter;
+				else gallopingCounter = 0;
+			}
+			// after one of the not merged arrays is empty the remaining elements from the other arrays have to be copied
+			int relativeIndexOfLargerArray = relativeIndexOfSmallerArray  != 0 ? 0 : 1;
+			for(int k = j[relativeIndexOfLargerArray]; l < temp.length; ++k, ++l) {
+				temp[l] = notMerged[i + relativeIndexOfLargerArray][k];
+			}
+		}
+		if(notEvenLen == 1) merged[merged.length - 1] = notMerged[notMerged.length - 1]; // copy the last array if input array length is uneven so array could not be merged
+		if(merged.length == 1) return merged; // sorting is finnished
+		return merge(merged); // do merging again
+	}
+}

timsort.md

@@ -0,0 +1,65 @@
+# Timsort
+
+## Wofür braucht man Sortieralgorithmen?
+
+- Wörterbuch
+- Preisvergleich
+
+## Einführung Timsort
+
+- Hybrid aus Insertion und Mergesort
+- weniger als 64 Elemente: Insertionsort
+
+## Insertionsort
+
+- erste Element des unsortierten Arrays in das sortierte Array kopiert
+- Danach wird geschaut, ob das zweite Element größer als das letzte Element im sortierten Array ist. Dann wird es rechts davon einsortiert
+- Ansonsten wird der Index vom zu überprüfenden Element halbiert und von vorne begonnen
+- In der Mitte des eingegrenzten Bereiches wird überprüft, ob das Element größer oder kleiner ist, so wird der mögliche Bereich mit jedem Mal halbiert
+- Nachdem die richtige Stelle gefunden wurde, wird die Zahl dort eingeschoben
+
+## Runs
+
+- mehr als 64 Elemente
+- Das unsortierte Array wird in Runs aufgeteilt
+- jeder Runs hat eine Mindestgröße, den minrun, normlerweise zwischen 32 und 64
+- minrun wird so ausgewählt, dass die Anzahl der Runs etwas weniger als eine 2er-Potenz
+- viele Daten enthalten bereits sortierte Teile
+- Aufsteigende und aufsteigende Reihe werden erkannt
+- absteigende Reihen werden umgekehrt
+- jeder Run wird mit Insertionsort sortiert
+
+## Merge
+
+- jeweiles zwei Arrays werden gemerged
+- Überprüfung am Anfang welches Arrays die Zahl kleiner ist
+- kopieren der Zahl in das sortierte Array und lösche der Zahl im Ursprungsarray
+- nach einem Durchgang nur noch die Hälfte der Arrays
+- wiederholen bis alle Zahlen im einen Array sind
+
+### Galloping
+
+- wenn 7 mal in Folge die kleinere Zahl im selben Array ist
+- wird nach der Zahl des anderen Arrays, welche als nächstes einsortiert wird, im ersten Array gesucht
+- alles von der aktuellen Position bis zur gefundenen Position des ersten Arrays wird in das sortierte Array kopiert
+
+## Quellen
+
+[Erklärvideo](https://www.youtube.com/watch?v=_dlzWEJoU7I),
+[wikipedia](https://en.wikipedia.org/wiki/Timsort),
+[exponential search](https://en.wikipedia.org/wiki/Exponential_search),
+[Beispiel Implementation](https://www.geeksforgeeks.org/timsort/),
+
+### Bilder
+
+[Insertionsort Visuialzion](https://media.geeksforgeeks.org/wp-content/uploads/insertionsort.png),
+[Minrun](https://upload.wikimedia.org/wikipedia/commons/6/63/Selection_of_minrun_by_timsort.png),
+[Merge](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/Merge_sort_algorithm_diagram.svg/1064px-Merge_sort_algorithm_diagram.svg.png),
+[Pferd](https://i.ytimg.com/vi/ZVzd_Y1Gdbg/maxresdefault.jpg),
+[Galloping](https://upload.wikimedia.org/wikipedia/commons/2/2d/Galloping_mode_timsort.png),
+[Regal](https://homepage.univie.ac.at/martina.gajdos/Bilder/WB-Doppels-dt.png),
+[Komplexität](https://hackernoon.com/hn-images/1*1CkG3c4mZGswDShAV9eHbQ.png)
+
+## Code
+
+[Timsort Implementation](https://git.redstoneunion.de/MrGeorgen/timsort)