From 11c50b23c3d861be318015245c868e7cbee368e7 Mon Sep 17 00:00:00 2001 From: Leo <582717189@qq.com> Date: Tue, 5 Jan 2021 16:14:22 +0800 Subject: [PATCH] =?UTF-8?q?04,05=E7=BB=83=E4=B9=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/leo/class04/BiggerThanRightTwice.java | 59 ++++++++++++++++++-- src/leo/class04/MergeSort.java | 43 ++++++++++++++- src/leo/class04/ReversePair.java | 41 +++++++++++++- src/leo/class04/SmallSum.java | 43 ++++++++++++++- src/leo/class05/CountOfRangeSum.java | 65 ++++++++++++++++++++++- src/leo/class05/QuickSort1.java | 49 ++++++++++++++++- src/leo/class17/Hanoi.java | 4 +- 7 files changed, 293 insertions(+), 11 deletions(-) diff --git a/src/leo/class04/BiggerThanRightTwice.java b/src/leo/class04/BiggerThanRightTwice.java index 9677c6d..4b6ae03 100644 --- a/src/leo/class04/BiggerThanRightTwice.java +++ b/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); diff --git a/src/leo/class04/MergeSort.java b/src/leo/class04/MergeSort.java index 0971037..0109579 100644 --- a/src/leo/class04/MergeSort.java +++ b/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; diff --git a/src/leo/class04/ReversePair.java b/src/leo/class04/ReversePair.java index 7ef2bf1..d19626b 100644 --- a/src/leo/class04/ReversePair.java +++ b/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); diff --git a/src/leo/class04/SmallSum.java b/src/leo/class04/SmallSum.java index 94b03e5..b531123 100644 --- a/src/leo/class04/SmallSum.java +++ b/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); diff --git a/src/leo/class05/CountOfRangeSum.java b/src/leo/class05/CountOfRangeSum.java index 4aba67e..ee4354d 100644 --- a/src/leo/class05/CountOfRangeSum.java +++ b/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); diff --git a/src/leo/class05/QuickSort1.java b/src/leo/class05/QuickSort1.java index 76f8aef..01552d2 100644 --- a/src/leo/class05/QuickSort1.java +++ b/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); diff --git a/src/leo/class17/Hanoi.java b/src/leo/class17/Hanoi.java index 090af67..050ecfb 100644 --- a/src/leo/class17/Hanoi.java +++ b/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); }