QuickSort on Kotlin

QSort.java

@@ -1,29 +1,33 @@
-public class QuickSort
-{   public static void main(String args[])
-    {   int a[]={5,7,4,3,6,8,9,1,2,0};
-        QuickSort obj=new QuickSort();
-        for(int i=0; i<a.length; i++) System.out.print(a[i]+" "); System.out.println();
-        obj.quickSort(a,0,a.length-1);
-        for(int i=0; i<a.length; i++) System.out.print(a[i]+" "); System.out.println();
-    }
-    void quickSort(int array[], int start, int end)
-    {   int i = start;                          
-        int k = end;                         
-        if (end - start >= 1)
-        {   int pivot = array[start];       
-            while (k > i)
-            {   while (array[i] <= pivot && i <= end && k > i) i++;      
-                while (array[k] > pivot && k >= start && k >= i) k--;                                        
-                if (k > i) swap(array, i, k);    
-           } 
-           swap(array, start, k);  
-           quickSort(array, start, k - 1); // quicksort the left partition
-           quickSort(array, k + 1, end);   // quicksort the right partition
-        }
-    }//quickSort()
-    void swap(int array[], int index1, int index2) 
-    {   int temp = array[index1];           
-        array[index1] = array[index2];      
-        array[index2] = temp;        
-    }//swap()
+public class QuickSort {
+    public static void main(String args[]) {
+        int a[] = {5, 7, 4, 3, 6, 8, 9, 1, 2, 0};
+        QuickSort obj = new QuickSort();
+        for (int i = 0; i < a.length; i++) System.out.print(a[i] + " ");
+        System.out.println();
+        obj.quickSort(a, 0, a.length - 1);
+        for (int i = 0; i < a.length; i++) System.out.print(a[i] + " ");
+        System.out.println();
+    }
+
+    void quickSort(int array[], int start, int end) {
+        int i = start;
+        int k = end;
+        if (end - start >= 1) {
+            int pivot = array[start];
+            while (k > i) {
+                while (array[i] <= pivot && i <= end && k > i) i++;
+                while (array[k] > pivot && k >= start && k >= i) k--;
+                if (k > i) swap(array, i, k);
+            }
+            swap(array, start, k);
+            quickSort(array, start, k - 1); // quicksort the left partition
+            quickSort(array, k + 1, end);   // quicksort the right partition
+        }
+    }//quickSort()
+
+    void swap(int array[], int index1, int index2) {
+        int temp = array[index1];
+        array[index1] = array[index2];
+        array[index2] = temp;
+    }//swap()
 }//class

QuickSort.c

@@ -1,51 +1,51 @@
-#include<stdio.h>
-
-void swap(int *x,int *y)
-{
-	int temp;
-	temp=*x;
-	*x=*y;
-	*y=temp;
-}
-
-int part(int a[],int l,int r)
-{
-	if(l>=r)
-		return -1;
-	int i=l,j=r-1;
-	while(i<=j)
-	{
-		if(i<=j && a[i]>=a[r]){
-			swap(&a[i],&a[j]);
-			j--;}
-		else i++;
-	}
-	swap(&a[i],&a[r]);
-	return i;
-}
-
-void sort(int a[],int l,int r)
-{
-	int x;
-	if(l>r)return;
-	x=part(a,l,r);
-	if(x==-1)return;
-	sort(a,l,x-1);
-	sort(a,x+1,r);
-	return ;
-}
-
-int main()
-{
-	int n,a[100],i;
-	scanf("%d",&n);
-	for(i=0;i<n;i++)
-		scanf("%d",&a[i]);
-	sort(a,0,n-1);
-	for(i=0;i<n;i++)
-	printf("%d ",a[i]);
-	return 0;
-}
-
-
-
+#include<stdio.h>
+
+void swap(int *x,int *y)
+{
+	int temp;
+	temp=*x;
+	*x=*y;
+	*y=temp;
+}
+
+int part(int a[],int l,int r)
+{
+	if(l>=r)
+		return -1;
+	int i=l,j=r-1;
+	while(i<=j)
+	{
+		if(i<=j && a[i]>=a[r]){
+			swap(&a[i],&a[j]);
+			j--;}
+		else i++;
+	}
+	swap(&a[i],&a[r]);
+	return i;
+}
+
+void sort(int a[],int l,int r)
+{
+	int x;
+	if(l>r)return;
+	x=part(a,l,r);
+	if(x==-1)return;
+	sort(a,l,x-1);
+	sort(a,x+1,r);
+	return ;
+}
+
+int main()
+{
+	int n,a[100],i;
+	scanf("%d",&n);
+	for(i=0;i<n;i++)
+		scanf("%d",&a[i]);
+	sort(a,0,n-1);
+	for(i=0;i<n;i++)
+	printf("%d ",a[i]);
+	return 0;
+}
+
+
+

QuickSort.go

@@ -1,39 +1,39 @@
-//Code snippet of user vderyagin
-
-package qsort
-
-import "math/rand"
-
-func QuickSort(slice []int) []int {
-	length := len(slice)
-
-	if length <= 1 {
-		sliceCopy := make([]int, length)
-		copy(sliceCopy, slice)
-		return sliceCopy
-	}
-
-	m := slice[rand.Intn(length)]
-
-	less := make([]int, 0, length)
-	middle := make([]int, 0, length)
-	more := make([]int, 0, length)
-
-	for _, item := range slice {
-		switch {
-		case item < m:
-			less = append(less, item)
-		case item == m:
-			middle = append(middle, item)
-		case item > m:
-			more = append(more, item)
-		}
-	}
-
-	less, more = QuickSort(less), QuickSort(more)
-
-	less = append(less, middle...)
-	less = append(less, more...)
-
-	return less
+//Code snippet of user vderyagin
+
+package qsort
+
+import "math/rand"
+
+func QuickSort(slice []int) []int {
+	length := len(slice)
+
+	if length <= 1 {
+		sliceCopy := make([]int, length)
+		copy(sliceCopy, slice)
+		return sliceCopy
+	}
+
+	m := slice[rand.Intn(length)]
+
+	less := make([]int, 0, length)
+	middle := make([]int, 0, length)
+	more := make([]int, 0, length)
+
+	for _, item := range slice {
+		switch {
+		case item < m:
+			less = append(less, item)
+		case item == m:
+			middle = append(middle, item)
+		case item > m:
+			more = append(more, item)
+		}
+	}
+
+	less, more = QuickSort(less), QuickSort(more)
+
+	less = append(less, middle...)
+	less = append(less, more...)
+
+	return less
 }

QuickSort.java

@@ -1,13 +1,20 @@
-class QuickSort
-{
+/**Comments by SpaceDigi
+ * Please refactor this code
+ * Please change view for your codestyle
+ * Please change your codestyle(for ksklee)
+ * This code aren't working, it's can't be compiling
+ * You have two name of classes and there are equals. So, it's must not be in one file or one directory
+ * Please read again java naming classes, packaging, etc.
+ * With love, by SpaceDigi
+ */
+
+class QuickSort {
 
-    int partition(int arr[], int low, int high)
-    {
+    int partition(int arr[], int low, int high) {
         int pivot = arr[high]; 
         int i = (low-1); // index of smaller element
-        for (int j=low; j<high; j++)
-        {
-
+        for (int j=low; j<high; j++) {
+
             if (arr[j] <= pivot)
             {
                 i++;
@@ -32,7 +39,7 @@ int partition(int arr[], int low, int high)
       arr[] --> Array to be sorted,
       low  --> Starting index,
       high  --> Ending index */
-    void sort(int arr[], int low, int high)
+   public void sort(int arr[], int low, int high)
     {
         if (low < high)
         {
@@ -69,7 +76,6 @@ public static void main(String args[])
         printArray(arr);
     }
 }
-=======
 
 /**
  * @author ksklee
@@ -87,18 +93,18 @@ int partition(int arr[], int low, int high){
 				arr[j] = temp;
 			}
 		}
-		
+
 		int temp = arr[i+1];
 		arr[i+1] = arr[high];
 		arr[high] = temp;
-			
+
 		return i+1;
 	}
 
 	void sort(int arr[], int low, int high){
 		if (low < high){
 			int pi = partition(arr, low, high);
-		
+
 			sort(arr, low, pi-1);
 			sort(arr, pi+1, high);
 		}
@@ -114,17 +120,17 @@ static void printArray(int arr[]){
 	public static void main(String[] args) {
 		int arr[] = {90, 57, 68, 89, 11, 35};
 		int n = arr.length;
-		
+
 		System.out.println("Before:");
 		printArray(arr);
-		
+
 		QuickSort quicksort = new QuickSort();
 		quicksort.sort(arr,  0, n-1);
-		
+
 		System.out.println("After:");
 		printArray(arr);
 	}
-	
+
 
 }
 

QuickSortKotlin.kt

@@ -0,0 +1,54 @@
+/**
+ * Code written by SpaceDigi
+ * Implementation quicksort algorithm on Kotlin
+ * This object can be used from Kotlin and Java classes
+ */
+object QuickSortKotlin {
+    fun quickSort(lowerIndex: Int, higherIndex: Int, inputArr: IntArray) {
+        var i = lowerIndex
+        var j = higherIndex
+        // calculate pivot number, I am taking pivot as middle index number
+        val pivot = inputArr[lowerIndex + (higherIndex - lowerIndex) / 2]
+        // Divide into two arrays
+        while (i <= j) {
+            while (inputArr[i] < pivot) {
+                i++
+            }
+            while (inputArr[j] > pivot) {
+                j--
+            }
+            if (i <= j) {
+                exchangeNumbers(i, j,inputArr);
+                //move index to next position on both sides
+                i++
+                j--
+            }
+        }
+        // call quickSort() method recursively
+        if (lowerIndex < j)
+            quickSort(lowerIndex, j,inputArr)
+        if (i < higherIndex)
+            quickSort(i, higherIndex,inputArr)
+    }
+
+   private fun exchangeNumbers(i:Int, j:Int, inputArr: IntArray) {
+        val temp = inputArr [i]
+        inputArr[i] = inputArr[j]
+        inputArr[j] = temp
+    }
+}
+
+fun main(args:Array<String>){
+    System.out.println("So, the main description you can read in header of this file." +
+            "\nArray send to method(sorting) by reference, so method has access to array by reference to object and works with that" +
+            " \nWe are creating array, fill by random numbers, printing before and after sorting")
+    System.out.println("Before sorting")
+    val size = 25
+    val arr = IntArray(size,{_->(Math.random()*size).toInt()})
+    for(k in arr)
+        System.out.print("$k ")
+    QuickSortKotlin.quickSort(0,size-1,arr)
+    System.out.println("\nAfter sorting")
+    for(k in arr)
+        System.out.print("$k ")
+}

README.md

@@ -1,2 +1,2 @@
-# Quick-Sort
-Add your code of Quick Sort in any language of your choice!
+# Quick-Sort
+Add your code of Quick Sort in any language of your choice!