练习,快排

src/leo/class01/BSExist.java

@@ -193,6 +193,25 @@ public class BSExist {
         return arr[L] == value;
     }
 
+    public static boolean exist9(int[] arr, int value) {
+        if (arr.length == 0 || arr == null) {
+            return false;
+        }
+        int l = 0;
+        int r = arr.length - 1;
+        while (l < r) {
+            int mid = l + ((r - l) >> 1);
+            if (arr[mid] > value) {
+                r = mid - 1;
+            } else if (arr[mid] < value) {
+                l = mid + 1;
+            }else{
+                return true;
+            }
+        }
+        return arr[l] == value;
+    }
+
     /**
      * 功能描述 : test
      * @author Leo
@@ -221,7 +240,7 @@ public class BSExist {
             int[] sortArr = ArrayUtil.randomSortArray(maxSize, range);
             int value = (int) ((range + 1) * Math.random() - (range + 1) * Math.random());
 
-            if (exist8(sortArr, value) != exist(sortArr, value)) {
+            if (exist9(sortArr, value) != exist(sortArr, value)) {
                 succeed = false;
                 ArrayUtil.printArr(sortArr);
                 break;

src/leo/class01/BSNear.java

@@ -231,6 +231,27 @@ public class BSNear {
 
     }
 
+    public static int BsNearLeft11(int[] arr, int value) {
+        if (arr.length == 0 || arr == null) {
+            return -1;
+        }
+        int l = 0;
+        int r = arr.length - 1;
+        int index = -1;
+        while (l <= r) {
+            int mid = l + ((r - l) >> 1);
+            if (arr[mid] >= value) {
+                index = mid;
+                r = mid - 1;
+            }else{
+                l = mid + 1;
+            }
+        }
+        return index;
+    }
+
+
+
     /**
      * 功能描述 : 在有序数组中找出>=某个数最左侧的位置(for test)
      * @author Leo
@@ -433,6 +454,25 @@ public class BSNear {
         return index;
     }
 
+    public static int BSNearRight9(int[] arr, int value) {
+        if (arr.length == 0 || arr == null) {
+            return -1;
+        }
+        int l = 0;
+        int r = arr.length - 1;
+        int index = -1;
+        while (l <= r) {
+            int mid = l + ((r - l) >> 1);
+            if (arr[mid] <= value) {
+                index = mid;
+                l = mid + 1;
+            }else{
+                r = mid - 1;
+            }
+        }
+        return index;
+    }
+
 
     public static int forTestBSNearRight(int[] arr, int value) {
         int index = -1;
@@ -456,7 +496,7 @@ public class BSNear {
         for (int i = 0; i < testTime; i++) {
             int[] sortArr = randomArray(maxSize, range);
             int value = (int) ((range + 1) * Math.random() - (range + 1) * Math.random());
-            /*int res1 = BSNearLeft10(sortArr, value);
+            int res1 = BSNearLeft10(sortArr, value);
             int res2 = forTestBSNearLeft(sortArr, value);
             if (res1 != res2) {
                 success = false;
@@ -464,9 +504,9 @@ public class BSNear {
                 System.out.println("BSNearLeft=" + res1);
                 System.out.println("forTestBSNearLeft=" + res2);
                 break;
-            }*/
+            }
 
-            int res3 = BSNearRight8(sortArr, value);
+            /*int res3 = BSNearRight9(sortArr, value);
             int res4 = forTestBSNearRight(sortArr, value);
             if (res3 != res4) {
                 success = false;
@@ -474,7 +514,7 @@ public class BSNear {
                 System.out.println("BSNearRight=" + res3);
                 System.out.println("forTestBSNearRight=" + res4);
                 break;
-            }
+            }*/
         }
         System.out.println(success ? "Nice!!" : "Fucking Fucked!");
     }

src/leo/class01/BubbleSort.java

@@ -168,6 +168,18 @@ public class BubbleSort {
     }
 
 
+    public static void bubbleSort12(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return;
+        }
+        for (int i = arr.length - 1; i >= 0; i--) {
+            for (int j = 0; j < i; j++) {
+                if (arr[j] > arr[i]) {
+                    swap(arr, j, i);
+                }
+            }
+        }
+    }
 
 
     /**
@@ -200,7 +212,7 @@ public class BubbleSort {
         for (int i = 0; i < testOfTime; i++) {
             int[] arr = ArrayUtil.randomArray(maxSize, range);
             int[] anotherArr = ArrayUtil.copyArray(arr);
-            bubbleSort11(arr);
+            bubbleSort12(arr);
             Arrays.sort(anotherArr);
             if (!ArrayUtil.isEqual(arr, anotherArr)) {
                 succeed = false;

src/leo/class01/EvenTimesOddTimes.java

@@ -79,6 +79,14 @@ public class EvenTimesOddTimes {
         System.out.println(eor);
     }
 
+    public static void printOdd7(int[] arr) {
+        int eor = 0;
+        for (int num : arr) {
+            eor ^= num;
+        }
+        System.out.println(eor);
+    }
+
 
     /**
      * 功能描述 : 有两种数出现了奇数次,找出他
@@ -206,12 +214,27 @@ public class EvenTimesOddTimes {
         System.out.println(eorOther+"   "+(eor^eorOther));
     }
 
+    public static void printOddTwo8(int[] arr) {
+        int eor = 0;
+        for (int num : arr) {
+            eor ^= num;
+        }
+        int rightOne = eor & (-eor);
+        int anotherEor = 0;
+        for (int num : arr) {
+            if ((rightOne & num) != 0) {
+                anotherEor ^= num;
+            }
+        }
+        System.out.println(anotherEor + "  " + (eor ^ anotherEor));
+    }
+
     public static void main(String[] args){
         int[] arrOne = {1, 1, 5, 5, 8, 1, 8, 5, 5};
 
-        printOdd6(arrOne);
+        printOdd7(arrOne);
         int[] arrTwo = {1, 1, 9, 5, 5, 8, 1, 8, 9, 5, 5, 5};
-        printOddTwo7(arrTwo);
+        printOddTwo8(arrTwo);
 
     }
 

src/leo/class01/KM.java

@@ -153,6 +153,44 @@ public class KM {
         return ans;
     }
 
+    public static int onlyKTime6(int[] arr,int k,int m){
+        int[] t = new int[32];
+        for (int num : arr) {
+            for (int i = 0; i < t.length; i++) {
+                t[i] += (num >> i) & 1;
+            }
+        }
+        int ans = 0;
+        for (int i = 0; i < t.length; i++) {
+            if (t[i] % m != 0) {
+                if (t[i] % m == k) {
+                    ans |= (1 << i);
+                }else{
+                    return -1;
+                }
+            }
+        }
+
+        if (ans == 0) {
+            int count = 0;
+            for (int num : arr) {
+                if (num == 0) {
+                    count++;
+                }
+            }
+            if (count == k) {
+                return ans;
+            } else {
+                return  -1;
+            }
+        }
+
+
+        return ans;
+
+    }
+
+
     public static void main(String[] args) {
         int maxKinds = 20;
         int range = 50;
@@ -169,7 +207,7 @@ public class KM {
             }
             int[] arr = randomArray(maxKinds, range, k, m);
 
-            int ans = onlyKTime5(arr, k, m);
+            int ans = onlyKTime6(arr, k, m);
             int ans2 = testForOnlyKTimes(arr, k, m);
             if (ans != ans2) {
                 System.out.println(ans);

src/leo/class02/BiggerThanRightTwice.java

@@ -126,7 +126,7 @@ class BiggerThanRightTwice2 {
         int windowR = m + 1;
         int res = 0;
         for (int i = l; i <= m; i++) {
-            while (windowR <= r && arr[i] > (arr[windowR]) << 1) {
+            while (windowR <= r && arr[i] > (arr[windowR] << 1)) {
                 windowR++;
             }
             res += windowR - m - 1;
@@ -154,6 +154,53 @@ class BiggerThanRightTwice2 {
 
 }
 
+class BiggerThanRightTwice3 {
+
+    public static int biggerTwice(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+        if (l == r) {
+            return 0;
+        }
+        int m = l + ((r - l) >> 1);
+        return process(arr, l, m) + process(arr, m + 1, r) + merge(arr, l, m, r);
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+        int res = 0;
+        int windowR = m + 1;
+        for (int i = l; i <= m; i++) {
+            while (windowR <= r && arr[i] > (arr[windowR] << 1)) {
+                windowR++;
+            }
+            res += windowR - m-1;
+        }
+
+        int p1 = l;
+        int p2 = m + 1;
+        int i = 0;
+        int[] help = new int[r - l + 1];
+        while (p1 <= m && p2 <= r) {
+            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
+        }
+        while (p1 <= m) {
+            help[i++] = arr[p1++];
+        }
+        while (p2 <= r) {
+            help[i++] = arr[p2++];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return res;
+    }
+}
+
 
 class TestBiggerThanRightTwice {
     public static int biggerTwice(int[] arr) {
@@ -179,7 +226,7 @@ class Main{
         for (int i = 0; i < testTime; i++) {
             int[] arr = generateRandomArray(sizeMax, range);
             int[] copyArray = copyArray(arr);
-            int res = BiggerThanRightTwice2.biggerTwice(arr);
+            int res = BiggerThanRightTwice3.biggerTwice(arr);
             int res1 = TestBiggerThanRightTwice.biggerTwice(copyArray);
             if (res != res1) {
                 System.out.println("res : " + res + " " + " res1: " + res1);

src/leo/class02/ReversePair.java

@@ -8,6 +8,8 @@ import leo.util.ArrayUtil;
  * @DATE 2020/11/23 9:48 下午
  * @Description 在一段数组中 返回有多少逆序对
  * 合并的时候 两侧下标--
+ * 任何一个前面的数a，和任何一个后面的数b，
+ * 如果(a,b)是降序的
  */
 public class ReversePair {
 
@@ -178,6 +180,47 @@ class ReversePair3 {
     }
 }
 
+class ReversePair4{
+    public static int reversePairNumber(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+
+        if (l == r) {
+            return 0;
+        }
+        int m = l + ((r - l) >> 1);
+        return process(arr, l, m) + process(arr, m + 1, r) + merge(arr, l, m, r);
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+        int p1 = m;
+        int p2 = r;
+        int[] help = new int[r - l + 1];
+        int i = help.length - 1;
+        int res = 0;
+        while (p1 >= l && p2 > m) {
+            res += arr[p1] > arr[p2] ? p2 - m : 0;
+            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
+        }
+        while (p1 >= l) {
+            help[i--] = arr[p1--];
+        }
+        while(p2>m){
+            help[i--] = arr[p2--];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return res;
+
+    }
+}
+
 class TestReversePair{
     public static int reversePairNumber(int[] arr) {
         int res = 0;
@@ -216,7 +259,7 @@ class TestReversePair{
         for (int i = 0; i < testTime; i++) {
             int[] arr = randomArray(sizeMax, range);
             int[] copyArr = copyArray(arr);
-            int num = ReversePair3.reversePairNumber(arr);
+            int num = ReversePair4.reversePairNumber(arr);
             int copyNum = reversePairNumber(copyArr);
             if (num != copyNum) {
                 System.out.println("num : "+num);

src/leo/class02/SmallSum.java

@@ -231,6 +231,47 @@ class SmallSum4{
     }
 }
 
+
+class SmallSum5{
+
+    public static int smallSum(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+        if (l == r) {
+            return 0;
+        }
+        int m = l + ((r - l) >> 1);
+        return process(arr, l, m) + process(arr, m + 1, r) + merge(arr, l, m, r);
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+        int res = 0;
+        int p1 = l;
+        int p2 = m + 1;
+        int i = 0;
+        int[] help = new int[r - l + 1];
+        while (p1 <= m && p2 <= r) {
+            res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
+            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
+        }
+        while (p1 <= m) {
+            help[i++] = arr[p1++];
+        }
+        while (p2 <= r) {
+            help[i++] = arr[p2++];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return res;
+    }
+}
+
 class TestSmallSum{
     public static int smallSum(int[] arr) {
         if (arr.length < 2 || arr == null) {
@@ -274,7 +315,7 @@ class TestMain {
         for (int i = 0; i < testTime; i++) {
             int[] arr = ArrayUtil.randomArray(maxSize, range);
             int[] copyArray = ArrayUtil.copyArray(arr);
-            int sum = SmallSum4.smallSum(arr);
+            int sum = SmallSum5.smallSum(arr);
             int testSum = TestSmallSum.smallSum(copyArray);
             if (testSum != sum) {
                 System.out.println("sum :" + sum + ", testSum : " + testSum);

src/leo/class03/CountOfRangeSum.java

@@ -0,0 +1,246 @@
+package leo.class03;
+
+import leo.util.ArrayUtil;
+
+/**
+ * @author Leo
+ * @ClassName CountOfRangeSum
+ * @DATE 2020/11/25 2:54 下午
+ * @Description
+ * 给定一个整数数组 nums，返回区间和在 [lower, upper] 之间的个数，包含 lower 和 upper。
+ * 假设0-i整体累加和是x,求必须以i位置结尾的子数组,目标有多少个在[lower,upper]范围上
+ * 等同于求在i之前的所有累加和中有多少个累加和在[x-upper,x-lower]上.
+ * https://leetcode-cn.com/problems/count-of-range-sum/
+ */
+class CountOfRangeSum {
+
+    public static int countRangeSum(int[] nums, int lower, int upper) {
+        if (nums.length == 0 || nums == null) {
+            return 0;
+        }
+        long[] sum = new long[nums.length];
+        sum[0] = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            sum[i] = sum[i - 1] + nums[i];
+        }
+        return process(sum, 0, nums.length - 1, lower, upper);
+    }
+
+    private static int process(long[] sum, int l, int r, int lower, int upper) {
+        if (l == r) {
+            return sum[l] >= lower && sum[l] <= upper ? 1 : 0;
+        }
+        int m = l + ((r - l) >> 1);
+        return process(sum, l, m, lower, upper) + process(sum, m + 1, r, lower, upper) + merge(sum, l, m, r, lower, upper);
+    }
+
+    private static int merge(long[] arr, int l, int m, int r, int lower, int upper) {
+        int res = 0;
+        int windowL = l;
+        int windowR = l;
+        //左右指针开始对比
+        for (int i = m + 1; i <= r; i++) {
+            long max = arr[i] - lower;
+            long min = arr[i] - upper;
+            //如果左侧的数小于等于右侧数减lower 代表在lower范围,指针前进
+            while (windowR <= m && arr[windowR] <= max) {
+                windowR++;
+            }
+            //如果左侧的数小于右侧书减upper,代表在upper范围之内
+            //条件不是小于等于的原因是不知道有左侧的数有几个等于upper 等于也在upper范围内
+            while (windowL <= m && arr[windowL] < min) {
+                windowL++;
+            }
+            //左侧的两个指针相减,得到一共有个数lower和upper范围内
+            res += windowR - windowL;
+        }
+        int p1 = l;
+        int p2 = m + 1;
+        long[] help = new long[r - l + 1];
+        int i = 0;
+        while (p1 <= m && p2 <= r) {
+            help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
+        }
+        while (p1 <= m) {
+            help[i++] = arr[p1++];
+        }
+        while(p2<=r) {
+            help[i++] = arr[p2++];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return res;
+    }
+
+}
+
+class CountOfRangeSum1 {
+    public static int countRangeSum(int[] nums, int lower, int upper) {
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+        long[] sum = new long[nums.length];
+        sum[0] = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            sum[i] = sum[i - 1] + nums[i];
+        }
+        return process(sum, 0, nums.length - 1, lower, upper);
+    }
+
+    private static int process(long[] sum, int l, int r,int lower,int upper) {
+
+
+        if (l == r) {
+            return sum[l] >= lower && sum[r] <= upper ? 1 : 0;
+        }
+
+        int m = l + ((r - l) >> 1);
+        return process(sum, l, m, lower, upper) + process(sum, m + 1, r, lower, upper) + merge(sum, l, m, r, lower, upper);
+
+    }
+
+    private static int merge(long[] sum, int l, int m, int r, int lower, int upper) {
+
+        int windowR = l;
+        int windowL = l;
+        int res = 0;
+        for (int i = m + 1; i <= r; i++) {
+
+            long min = sum[i] - upper;
+            long max = sum[i] - lower;
+            while (windowR <= m && sum[windowR] <= max) {
+                windowR++;
+            }
+            while (windowL <= m && sum[windowL] < min) {
+                windowL++;
+            }
+            res += windowR - windowL;
+        }
+        int p1 = l;
+        int p2 = m + 1;
+        long[] help = new long[r - l + 1];
+        int i = 0;
+        while (p1 <= m && p2 <= r) {
+            help[i++] = sum[p1] <= sum[p2] ? sum[p1++] : sum[p2++];
+        }
+        while (p1 <= m) {
+            help[i++] = sum[p1++];
+        }
+        while(p2 <= r) {
+            help[i++] = sum[p2++];
+        }
+        for (i = 0; i < help.length; i++) {
+            sum[l + i] = help[i];
+        }
+        return res;
+    }
+
+}
+
+
+class CountOfRangeSum2 {
+
+    public static int countRangeSum(int[] nums, int lower, int upper) {
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+        long[] sum = new long[nums.length];
+        sum[0] = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            sum[i] = sum[i - 1] + nums[i];
+        }
+        return process(sum, 0, sum.length - 1, lower, upper);
+
+    }
+
+    private static int process(long[] sum, int l, int r, int lower, int upper) {
+        if (l == r) {
+            return sum[l] >= lower & sum[l] <= upper ? 1 : 0;
+        }
+        int m = l + ((r - l) >> 1);
+        return process(sum,l,m,lower,upper)+process(sum,m+1,r,lower,upper)+merge(sum,l,m,r,lower,upper);
+    }
+
+    private static int merge(long[] sum, int l, int m, int r, int lower, int upper) {
+        int windowL = l;
+        int windowR = l;
+        int res = 0;
+        for (int i = m + 1; i <= r; i++) {
+            long max = sum[i] - lower;
+            long min = sum[i] - upper;
+            while (windowR <= m && sum[windowR] <= max) {
+                windowR++;
+            }
+            while (windowL <= m && sum[windowL] < min) {
+                windowL++;
+            }
+            res += windowR - windowL;
+        }
+        int p1 = l;
+        int p2 = m + 1;
+        long[] help = new long[r - l + 1];
+        int i = 0;
+        while (p1 <= m && p2 <= r) {
+            help[i++] = sum[p1] <= sum[p2] ? sum[p1++] : sum[p2++];
+        }
+        while (p1 <= m) {
+            help[i++] = sum[p1++];
+        }
+        while (p2 <= r) {
+            help[i++] = sum[p2++];
+        }
+        for (i = 0; i < help.length; i++) {
+            sum[l + i] = help[i];
+        }
+        return res;
+    }
+}
+
+class MainTest{
+
+    public static int countRangeSum(int[] nums, int lower, int upper) {
+        int count = 0;
+        for(int i=0;i<nums.length;i++){
+            long sum = 0;
+            for(int j=i;j<nums.length;j++){
+                sum+=nums[j];
+                if(sum>=lower && sum<=upper) count++;
+            }
+        }
+        return count;
+    }
+
+
+    public static void main(String[] args) {
+        int testTime = 1000;
+        int sizeMax = 80;
+        int range = 50;
+        System.out.println("start!");
+
+        for (int i = 0; i < testTime; i++) {
+            int[] arr = ArrayUtil.randomArray(sizeMax, range);
+            int[] copyArray = ArrayUtil.copyArray(arr);
+            int lower = (int) ((range * Math.random() + 1)-(range * Math.random() + 1));
+            int upper;
+            do {
+                upper = (int) ((range * Math.random() + 1) - (range * Math.random() + 1));
+            } while (upper <= lower);
+            int sumCount = CountOfRangeSum2.countRangeSum(arr, lower, upper);
+            int testSumCount = countRangeSum(copyArray, lower, upper);
+            if (sumCount != testSumCount) {
+                System.out.println("sumCount :" + sumCount+" testSumCount : "+testSumCount);
+                System.out.println("fuck!");
+                break;
+            }
+
+        }
+        System.out.println("end!");
+
+    }
+
+
+
+}
+
+

src/leo/class03/QuickSort1.java

@@ -0,0 +1,368 @@
+package leo.class03;
+
+import com.sun.org.apache.bcel.internal.generic.POP2;
+import com.sun.xml.internal.bind.v2.model.core.ID;
+import leo.util.ArrayUtil;
+
+import java.util.Arrays;
+import java.util.Stack;
+
+/**
+ * @author Leo
+ * @ClassName QuickSort1
+ * @DATE 2020/11/26 11:17 上午
+ * @Description 快排1.0
+ * O(N²) 最差情况
+ * 范围内最后一个数为比较值x,[<=x>],x一定在左侧的最后一个位置,返回比较值得下标
+ * 只记录右侧最小位置下标,如果index的值小于或等于右侧最后位置的数,
+ * index与最小位置的数后一位交换,最小位置下标更新
+ *
+ * T(N) = a * T(N/b) + O(N^d)(其中的a、b、d都是常数)
+ * 的递归函数，可以直接通过Master公式来确定时间复杂度
+ * 如果 log(b,a) < d，复杂度为O(N^d)
+ * 如果 log(b,a) > d，复杂度为O(N^log(b,a))
+ * 如果 log(b,a) == d，复杂度为O(N^d  * logN)
+ *
+ */
+class QuickSort1 {
+    public static void quickSort(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return;
+        }
+        process(arr, 0, arr.length - 1);
+    }
+
+    private static void process(int[] arr, int l, int r) {
+        if (l >= r) {
+            return;
+        }
+        int m = partition(arr, l, r);
+        process(arr, l, m-1);
+        process(arr, m + 1, r);
+    }
+
+    private static int partition(int[] arr, int l, int r) {
+        if (l > r) {
+            return -1;
+        }
+        if (l == r) {
+            return l;
+        }
+        int less = l-1;
+        int index = l;
+        while (index < r) {
+            if (arr[index] <= arr[r]) {
+                swap(arr, index, ++less);
+            }
+            index++;
+        }
+        swap(arr, r, ++less);
+        return less;
+    }
+
+    private static void swap(int[] arr, int i, int j) {
+        if (i == j || arr[i] == arr[j]) {
+            return;
+        }
+        arr[i] = arr[i] ^ arr[j];
+        arr[j] = arr[i] ^ arr[j];
+        arr[i] = arr[i] ^ arr[j];
+    }
+
+}
+
+
+/**
+ * @author Leo
+ * @ClassName QuickSort1
+ * @DATE 2020/11/26 11:17 上午
+ * @Description 快排2.0
+ * O(N²) 最差情况
+ * 中间位置固定,左右两边有序
+ *
+ */
+class QuickSort2 {
+
+    public static void quickSort(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return;
+        }
+        process(arr, 0, arr.length - 1);
+    }
+
+    public static void process(int[] arr, int l, int r) {
+        if (l >= r) {
+            return;
+        }
+        int[] equalsArea = partition(arr, l, r);
+        process(arr, l, equalsArea[0] - 1);
+        process(arr, equalsArea[1] + 1, r);
+    }
+
+    //netherlandsFlag
+    //荷兰国旗问题
+    private static int[] partition(int[] arr, int l, int r) {
+        if (l > r) {
+            return new int[]{-1, -1};
+        }
+        if (l == r) {
+            return new int[]{l, r};
+        }
+
+        int leftIndex = l - 1;
+        int rightIndex = r;
+        int index = l;
+        while (index < rightIndex) {
+            if (arr[index] < arr[r]) {
+                swap(arr, index++, ++leftIndex);
+            } else if (arr[index] > arr[r]) {
+                swap(arr, index, --rightIndex);
+            }else{
+                index++;
+            }
+        }
+        swap(arr, r, rightIndex);
+        return new int[]{leftIndex+1, rightIndex};
+    }
+
+
+    private static void swap(int[] arr, int i, int j) {
+        if (i == j || arr[i] == arr[j]) {
+            return;
+        }
+        arr[i] = arr[i] ^ arr[j];
+        arr[j] = arr[i] ^ arr[j];
+        arr[i] = arr[i] ^ arr[j];
+    }
+}
+
+
+/**
+ * @author Leo
+ * @ClassName QuickSort1
+ * @DATE 2020/11/26 11:17 上午
+ * @Description 快排3.0
+ * O(N*logN)
+ * 额外空间复杂度o(n)
+ *
+ */
+class QuickSort3 {
+
+    public static void quickSort(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return;
+        }
+        process(arr, 0, arr.length - 1);
+    }
+
+    public static void process(int[] arr, int l, int r) {
+        if (l >= r) {
+            return;
+        }
+        swap(arr, (int) (l + (Math.random() * (r - l + 1))), r);
+        int[] equalArea = partition(arr, l, r);
+        process(arr, l, equalArea[0] - 1);
+        process(arr, equalArea[1] + 1, r);
+    }
+
+    public static int[] partition(int[] arr, int l, int r) {
+        if (l > r) {
+            return new int[]{-1, -1};
+        }
+        if (l == r) {
+            return new int[]{l, r};
+        }
+        int leftIndex = l - 1;
+        int rightIndex = r;
+        int index = l;
+        while (index < rightIndex) {
+            if (arr[index] == arr[r]) {
+                index++;
+            } else if (arr[index] < arr[r]) {
+                swap(arr, index++, ++leftIndex);
+            } else if (arr[index] > arr[r]) {
+                swap(arr, index, --rightIndex);
+            }
+        }
+        swap(arr, r, rightIndex);
+
+        return new int[]{leftIndex + 1, rightIndex};
+    }
+
+    public static void swap(int[] arr, int i, int j) {
+        if (arr[i] == arr[j] || i == j) {
+            return;
+        }
+        arr[i] = arr[i] ^ arr[j];
+        arr[j] = arr[i] ^ arr[j];
+        arr[i] = arr[i] ^ arr[j];
+    }
+}
+
+
+class QuickSort3_1{
+
+    public static void quickSort(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return;
+        }
+
+        process(arr, 0, arr.length - 1);
+    }
+
+    private static void process(int[] arr, int l, int r) {
+
+        if (l >= r) {
+            return;
+        }
+
+        swap(arr, (int) (l + ((r - l + 1) * Math.random())), r);
+        int[] equalArea = partition(arr, l, r);
+        process(arr, l, equalArea[0] - 1);
+        process(arr, equalArea[1] + 1, r);
+
+    }
+
+    private static int[] partition(int[] arr, int l, int r) {
+        if (l > r) {
+            return new int[]{-1, -1};
+        }
+        if (l == r) {
+            return new int[]{l, r};
+        }
+        int leftIndex = l - 1;
+        int rightIndex = r;
+        int index = l;
+        while (index < rightIndex) {
+            if (arr[index] == arr[r]) {
+                index++;
+            } else if (arr[index] > arr[r]) {
+                swap(arr, index, --rightIndex);
+            } else if (arr[index] < arr[r]) {
+                swap(arr, index++, ++leftIndex);
+            }
+        }
+        swap(arr, r, rightIndex);
+        return new int[]{leftIndex + 1, rightIndex};
+
+    }
+
+
+    public static void swap(int[] arr, int i, int j) {
+        if (arr[i] == arr[j] || i == j) {
+            return;
+        }
+        arr[i] = arr[i] ^ arr[j];
+        arr[j] = arr[i] ^ arr[j];
+        arr[i] = arr[i] ^ arr[j];
+
+    }
+
+
+}
+
+
+
+class QuickSortUnRecursive{
+
+    private static class Op {
+        public int l;
+        public int r;
+
+        public Op(int l, int r) {
+            this.l = l;
+            this.r = r;
+        }
+    }
+
+    public static void quickSort(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return;
+        }
+        swap(arr, arr.length - 1, (int) (arr.length * Math.random()));
+        int[] equalArea = partition(arr, 0, arr.length - 1);
+        Stack<Op> stack = new Stack<>();
+        int l = equalArea[0] - 1;
+        int r = equalArea[1] + 1;
+        stack.push(new Op(0, l));
+        stack.push(new Op(r, arr.length - 1));
+        while (!stack.isEmpty()) {
+            Op pop = stack.pop();
+            int pl = pop.l;
+            int pr = pop.r;
+            if (pl < pr) {
+                swap(arr, (int) (pl + (Math.random() * (pr - pl + 1))), pr);
+                equalArea = partition(arr, pl, pr);
+                l = equalArea[0] - 1;
+                r = equalArea[1] + 1;
+                stack.push(new Op(pl, l));
+                stack.push(new Op(r, pr));
+            }
+        }
+
+    }
+
+
+
+    public static int[] partition(int[] arr, int l, int r) {
+        if (l > r) {
+            return new int[]{-1, -1};
+        }
+        if (l==r){
+            return new int[]{l, r};
+        }
+        int leftIndex = l - 1;
+        int rightIndex = r;
+        int index = l;
+        while (index < rightIndex) {
+            if (arr[index] == arr[r]) {
+                index++;
+            } else if (arr[index] < arr[r]) {
+                swap(arr, index++, ++leftIndex);
+            } else if (arr[index] > arr[r]) {
+                swap(arr, index, --rightIndex);
+            }
+        }
+        swap(arr, r, rightIndex);
+        return new int[]{leftIndex + 1, rightIndex};
+    }
+
+    private static void swap(int[] arr, int i, int j) {
+        if (i == j || arr[i] == arr[j]) {
+            return;
+        }
+        arr[i] = arr[i] ^ arr[j];
+        arr[j] = arr[i] ^ arr[j];
+        arr[i] = arr[i] ^ arr[j];
+    }
+
+
+}
+
+
+class TestMain {
+
+
+    public static void main(String[] args){
+        int testTimes = 1000;
+        int sizeMax = 50;
+        int range = 50;
+        System.out.println("start");
+
+        for (int i = 0; i < testTimes; i++) {
+            int[] arr = ArrayUtil.randomArray(sizeMax, range);
+            int[] copyArray = ArrayUtil.copyArray(arr);
+            QuickSort3_1.quickSort(arr);
+            Arrays.sort(copyArray);
+            if (!ArrayUtil.isEqual(arr, copyArray)) {
+                ArrayUtil.printArr(arr);
+                ArrayUtil.printArr(copyArray);
+                System.out.println("fuck");
+                break;
+            }
+        }
+        System.out.println("end");
+
+    }
+
+}