04,05练习

src/leo/class04/BiggerThanRightTwice.java

@@ -250,7 +250,7 @@ class BiggerThanRightTwice4 {
 }
 
 class BiggerThanRightTwice5 {
-    public static int biggerTwice(int[] arr) {
+    public static int reversePairs(int[] arr) {
         if (arr.length < 2 || arr == null) {
             return 0;
         }
@@ -296,13 +296,63 @@ class BiggerThanRightTwice5 {
     }
 }
 
+class BiggerThanRightTwice6 {
+    public static int biggerTwice(int[] arr) {
+        if (arr == null || arr.length == 0) {
+            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[] help = new int[r - l + 1];
+        int res = 0;
+        int windowR = m + 1;
+        int i = l;
+        for (; i <= m; i++) {
+            while (windowR <= r && arr[i] > arr[windowR] * 2L) {
+                windowR++;
+            }
+            res += windowR - m - 1;
+        }
+        int p1 = l;
+        int p2 = m + 1;
+        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 TestBiggerThanRightTwice {
     public static int biggerTwice(int[] arr) {
         int res = 0;
 
         for (int i = 0; i < arr.length; i++) {
             for (int j = i + 1; j < arr.length; j++) {
-                if (arr[i] > arr[j] << 1) {
+                if (arr[i] > arr[j] * 2L) {
                     res++;
                 }
             }
@@ -314,13 +364,14 @@ class TestBiggerThanRightTwice {
 class Main{
     public static void main(String[] args){
         int testTime = 1000;
-        int sizeMax = 10;
+        int sizeMax = 1000;
         int range = 60;
         System.out.println("start");
         for (int i = 0; i < testTime; i++) {
             int[] arr = generateRandomArray(sizeMax, range);
+//            arr = new int[]{2147483647, 2147483647, 2147483647, 2147483647, 2147483647, 2147483647};
             int[] copyArray = copyArray(arr);
-            int res = BiggerThanRightTwice5.biggerTwice(arr);
+            int res = BiggerThanRightTwice6.biggerTwice(arr);
             int res1 = TestBiggerThanRightTwice.biggerTwice(copyArray);
             if (res != res1) {
                 System.out.println("res : " + res + " " + " res1: " + res1);

src/leo/class04/MergeSort.java

@@ -4,6 +4,7 @@ package leo.class04;
 import leo.util.ArrayUtil;
 
 import java.util.Arrays;
+import java.util.function.IntPredicate;
 
 
 /**
@@ -204,6 +205,46 @@ public class MergeSort {
         }
     }
 
+    public static class Recursion4 {
+        public static void mergeSort(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 = l + ((r - l) >> 1);
+            process(arr, l, m);
+            process(arr, m + 1, r);
+            merge(arr, l, m, r);
+
+        }
+
+        private static void merge(int[] arr, int l, int m, int r) {
+            int[] help = new int[r - l + 1];
+            int i = 0;
+            int p1 = l;
+            int p2 = m + 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++];
+            }
+            i = 0;
+            for (; i < help.length; i++) {
+                arr[l + i] = help[i];
+            }
+        }
+    }
+
     /**
      * @author Leo
      * @ClassName MergeSort
@@ -321,7 +362,7 @@ public class MergeSort {
         for (int i = 0; i < testOfTime; i++) {
             int[] arr = ArrayUtil.randomArray(maxSize, range);
             int[] anotherArr = ArrayUtil.copyArray(arr);
-            Recursion3.mergeSort(arr);
+            Recursion4.mergeSort(arr);
             Arrays.sort(anotherArr);
             if (!ArrayUtil.isEqual(arr, anotherArr)) {
                 succeed = false;

src/leo/class04/ReversePair.java

@@ -263,6 +263,45 @@ class ReversePair5{
     }
 }
 
+class ReversePair6 {
+    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[] help = new int[r - l + 1];
+        int i = help.length - 1;
+        int ans = 0;
+        int p1 = m;
+        int p2 = r;
+        while (p1 >= l && p2 > m) {
+            ans += 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--];
+        }
+        i = 0;
+        for (; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return ans;
+    }
+}
 
 
 class TestReversePair{
@@ -303,7 +342,7 @@ class TestReversePair{
         for (int i = 0; i < testTime; i++) {
             int[] arr = randomArray(sizeMax, range);
             int[] copyArr = copyArray(arr);
-            int num = ReversePair5.reversePairNumber(arr);
+            int num = ReversePair6.reversePairNumber(arr);
             int copyNum = reversePairNumber(copyArr);
             if (num != copyNum) {
                 System.out.println("num : "+num);

src/leo/class04/SmallSum.java

@@ -353,6 +353,47 @@ class SmallSum7 {
     }
 }
 
+class SmallSum8 {
+    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[] help = new int[r - l + 1];
+        int ans = 0;
+        int p1 = l;
+        int p2 = m + 1;
+        int i = 0;
+        while (p1 <= m && p2 <= r) {
+            ans += 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++];
+        }
+        i = 0;
+        for (; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return ans;
+
+    }
+}
+
 class TestSmallSum{
     public static int smallSum(int[] arr) {
         if (arr.length < 2 || arr == null) {
@@ -396,7 +437,7 @@ class TestMain {
         for (int i = 0; i < testTime; i++) {
             int[] arr = ArrayUtil.randomArray(maxSize, range);
             int[] copyArray = ArrayUtil.copyArray(arr);
-            int sum = SmallSum7.smallSum(arr);
+            int sum = SmallSum8.smallSum(arr);
             int testSum = TestSmallSum.smallSum(copyArray);
             if (testSum != sum) {
                 System.out.println("sum :" + sum + ", testSum : " + testSum);

src/leo/class05/CountOfRangeSum.java

@@ -1,6 +1,7 @@
 package leo.class05;
 
 import leo.util.ArrayUtil;
+import sun.rmi.runtime.Log;
 
 /**
  * @author Leo
@@ -456,6 +457,68 @@ class CountOfRangeSum6{
     }
 }
 
+class CountOfRangeSum7 {
+    public static int countRangeSum(int[] arr, int lower, int upper) {
+        if (arr.length == 0 || arr == null) {
+            return 0;
+        }
+        long[] sum = new long[arr.length];
+        sum[0] = arr[0];
+        for (int i = 1; i < arr.length; i++) {
+            sum[i] = sum[i - 1] + arr[i];
+        }
+        return process(sum, 0, arr.length - 1,lower,upper);
+    }
+
+    private static int process(long[] sum, int l, int r,int lower,int upper) {
+        if (l > r) {
+            return 0;
+        }
+        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 i = m + 1;
+        int ans = 0;
+        while (i <= r) {
+            long max = sum[i] - lower;
+            long min = sum[i] - upper;
+            while (windowR <= m && sum[windowR] <= max) {
+                windowR++;
+            }
+            while (windowL <= m && sum[windowL] < min) {
+                windowL++;
+            }
+            i++;
+            ans += windowR - windowL;
+        }
+        i = 0;
+        int p1 = l;
+        int p2 = m + 1;
+        long[] help = new long[r - l + 1];
+        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 ans;
+    }
+}
+
 class MainTest{
 
     public static int countRangeSum(int[] nums, int lower, int upper) {
@@ -485,7 +548,7 @@ class MainTest{
             do {
                 upper = (int) ((range * Math.random() + 1) - (range * Math.random() + 1));
             } while (upper <= lower);
-            int sumCount = CountOfRangeSum5.countRangeSum(arr, lower, upper);
+            int sumCount = CountOfRangeSum7.countRangeSum(arr, lower, upper);
             int testSumCount = countRangeSum(copyArray, lower, upper);
             if (sumCount != testSumCount) {
                 System.out.println("sumCount :" + sumCount+" testSumCount : "+testSumCount);

src/leo/class05/QuickSort1.java

@@ -459,6 +459,53 @@ class QuickSort3_5 {
     }
 }
 
+class QuickSort3_6 {
+    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[] equalsArea = partition(arr, l, r);
+        process(arr, l, equalsArea[0]-1);
+        process(arr, equalsArea[1] + 1, r);
+
+
+    }
+
+    private static int[] partition(int[] arr, int l, int r) {
+        int left = l - 1;
+        int right = r;
+        int i = l;
+        while (i < right) {
+            if (arr[i] > arr[r]) {
+                swap(arr, i, --right);
+            } else if (arr[i] < arr[r]) {
+                swap(arr, ++left, i++);
+            }else{
+                i++;
+            }
+        }
+        swap(arr, right, r);
+        return new int[]{left + 1, right};
+    }
+
+    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 QuickSortUnRecursive{
 
     private static class Op {
@@ -548,7 +595,7 @@ class TestMain {
         for (int i = 0; i < testTimes; i++) {
             int[] arr = ArrayUtil.randomArray(sizeMax, range);
             int[] copyArray = ArrayUtil.copyArray(arr);
-            QuickSort3_4.quickSort(arr);
+            QuickSort3_6.quickSort(arr);
             Arrays.sort(copyArray);
             if (!ArrayUtil.isEqual(arr, copyArray)) {
                 ArrayUtil.printArr(arr);

src/leo/class17/Hanoi.java

@@ -1,6 +1,6 @@
 package leo.class17;
 
-import class11_17.Code01_Hanoi;
+import class17.Code02_Hanoi;
 
 /**
  * @author Leo
@@ -31,7 +31,7 @@ public class Hanoi {
         int n = 3;
         hanoi(n);
         System.out.println("-------");
-        Code01_Hanoi.hanoi2(n);
+        Code02_Hanoi.hanoi2(n);
     }