quick sort

Author: genkimaru

src/main/java/com/leetcode/recursion/QuickSort.java

@@ -0,0 +1,61 @@
+package com.leetcode.recursion;
+import java.util.Random;
+
+/**
+ * pivot  :   either using a random number of the array , or using a high
+ */
+public class QuickSort {
+
+    void quickSort(int[] arr, int low, int high) {
+        if (low < high) {
+            int split = partition(arr, low, high);
+            quickSort(arr, 0, split - 1);
+            quickSort(arr, split, high);
+        }
+    }
+
+    private static int partition(int[] arr, int low, int high) {
+        // choose  pivot
+        int randomInt = new Random().nextInt(high-low);
+        int pivot = arr[low + randomInt];
+
+        // init double point left , right
+        int left = low - 1;
+        int right = high + 1;
+
+        // ensure the all number on left be less than pivot
+        // ensuer the all number on right be greater than pivot
+        // if not , swap the number on the both sides
+        while (true) {
+            while (true) {
+                left += 1;
+                if (left > high || arr[left] >= pivot) {
+                    break;
+                }
+            }
+            while (true) {
+                right -= 1;
+                if (right < low || arr[right] <= pivot) {
+                    break;
+                }
+            }
+            if (left > right) {
+                break;
+            }
+            // swap
+            int tmp = arr[left];
+            arr[left] = arr[right];
+            arr[right] = tmp;
+        }
+        // return the split position.
+        return left;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = new int[]{4, 3, 7, 8, 5, 6, 1, 2, 9};
+        new QuickSort().quickSort(arr, 0, arr.length - 1);
+        for (int i : arr) {
+            System.out.println(i);
+        }
+    }
+}

src/main/java/com/leetcode/recursion/QuickSortS.java

@@ -0,0 +1,37 @@
+package com.leetcode.recursion;
+
+public class QuickSortS {
+    public static void main(String[] args) {
+        int[] arr = {12, 4, 7, 9, 2, 5};
+        quickSort(arr, 0, arr.length - 1);
+        System.out.println("Sorted array:");
+        for (int num : arr) {
+            System.out.print(num + " ");
+        }
+    }
+
+    public static void quickSort(int[] arr, int low, int high) {
+        if (low < high) {
+            int pivotIndex = partition(arr, low, high);
+            quickSort(arr, low, pivotIndex - 1);
+            quickSort(arr, pivotIndex + 1, high);
+        }
+    }
+
+    public static int partition(int[] arr, int low, int high) {
+        int pivot = arr[high];
+        int i = low - 1;
+        for (int j = low; j < high; j++) {
+            if (arr[j] < pivot) {
+                i++;
+                int temp = arr[i];
+                arr[i] = arr[j];
+                arr[j] = temp;
+            }
+        }
+        int temp = arr[i + 1];
+        arr[i + 1] = arr[high];
+        arr[high] = temp;
+        return i + 1;
+    }
+}

src/main/java/com/leetcode/stack/StackOne.java

@@ -8,6 +8,7 @@
 public class StackOne {
 
 
+
     public static void main(String[] args) {
 
     }

src/main/java/com/leetcode/stack/StackTwo.java

@@ -0,0 +1,55 @@
+package com.leetcode.stack;
+
+
+import java.util.Stack;
+
+/**
+ *   Kth Largest Element in an Array
+ */
+public class StackTwo {
+
+    public static int partition(int[] nums, int low, int high) {
+        int pivot = nums[high];
+        int i = low - 1;
+        for (int j = low; j < high; j++) {
+            if (nums[j] <= pivot) {
+                i++;
+                int temp = nums[i];
+                nums[i] = nums[j];
+                nums[j] = temp;
+            }
+        }
+        int temp = nums[i + 1];
+        nums[i + 1] = nums[high];
+        nums[high] = temp;
+        return i + 1;
+    }
+
+    public static int findKthLargest(int[] nums, int k) {
+        Stack<int[]> stack = new Stack<>();
+        stack.push(new int[] {0, nums.length - 1});
+        while (!stack.isEmpty()) {
+            int[] bounds = stack.pop();
+            int low = bounds[0];
+            int high = bounds[1];
+            int pivotIndex = partition(nums, low, high);
+            if (pivotIndex == nums.length - k) {
+                return nums[pivotIndex];
+            } else if (pivotIndex < nums.length - k) {
+                stack.push(new int[] {pivotIndex + 1, high});
+            } else {
+                stack.push(new int[] {low, pivotIndex - 1});
+            }
+        }
+        // It's assumed that k is always valid and nums has at least k elements
+        return -1; // Should never reach here
+    }
+
+    public static void main(String[] args) {
+
+        int[] nums = new int[]{9,8,7,6,5,4,3,2,1};
+        int k = 2;
+        int kthLargest = new StackTwo().findKthLargest(nums, k);
+        System.out.println(kthLargest);
+    }
+}

src/test/java/com/recursion/ArrangementTest.java renamed to src/test/java/com/leetcode/recursion/RecursionOneTest.java

@@ -1,6 +1,5 @@
-package com.recursion;
+package com.leetcode.recursion;
 
-import com.leetcode.recursion.RecursionOne;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 

src/test/java/com/leetcode/stack/StackTwoTest.java

@@ -0,0 +1,17 @@
+package com.leetcode.stack;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class StackTwoTest {
+
+    @Test
+    public void partitionTest(){
+        int[] nums = new int[]{1,2,3,4,5,6,7,8,9};
+        int pivotIndex = StackTwo.partition(nums, 0, nums.length - 1);
+        Assertions.assertEquals(pivotIndex , 8);
+    }
+
+}