From 503cc2b69f5fd83bfca9e8b17596dfc415bfe2ea Mon Sep 17 00:00:00 2001 From: Leo <582717189@qq.com> Date: Fri, 27 Nov 2020 19:39:08 +0800 Subject: [PATCH] =?UTF-8?q?=E7=AC=AC=E4=B8=89=E8=8A=82=E5=AE=8C=E6=88=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/leo/class02/ReversePair.java | 44 +++- src/leo/class03/Comparator.java | 36 +++ src/leo/class03/CountOfRangeSum.java | 69 ++++- src/leo/class03/HeapSort.java | 101 ++++++++ src/leo/class03/MyMaxHeap.java | 272 ++++++++++++++++++++ src/leo/class03/QuickSort1.java | 59 ++++- src/leo/class03/SortArrayDistanceLessK.java | 99 +++++++ 7 files changed, 673 insertions(+), 7 deletions(-) create mode 100644 src/leo/class03/Comparator.java create mode 100644 src/leo/class03/HeapSort.java create mode 100644 src/leo/class03/MyMaxHeap.java create mode 100644 src/leo/class03/SortArrayDistanceLessK.java diff --git a/src/leo/class02/ReversePair.java b/src/leo/class02/ReversePair.java index 49d3d6d..487dede 100644 --- a/src/leo/class02/ReversePair.java +++ b/src/leo/class02/ReversePair.java @@ -221,6 +221,48 @@ class ReversePair4{ } } +class ReversePair5{ + 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 p1 = m; + int p2 = r; + 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; @@ -259,7 +301,7 @@ class TestReversePair{ for (int i = 0; i < testTime; i++) { int[] arr = randomArray(sizeMax, range); int[] copyArr = copyArray(arr); - int num = ReversePair4.reversePairNumber(arr); + int num = ReversePair5.reversePairNumber(arr); int copyNum = reversePairNumber(copyArr); if (num != copyNum) { System.out.println("num : "+num); diff --git a/src/leo/class03/Comparator.java b/src/leo/class03/Comparator.java new file mode 100644 index 0000000..079f952 --- /dev/null +++ b/src/leo/class03/Comparator.java @@ -0,0 +1,36 @@ +package leo.class03; + +/** + * @author Leo + * @ClassName Comparator + * @DATE 2020/11/27 10:22 上午 + * @Description 比较器 + * 实现comparator中的compare方法 + * 两个参数 + * 返回负数 第一个参数排在前面 + * 返回0,谁都可以, + * 返回正数,第二个参数排在前面. + * arrays[数组] TreeSet,TreeMap[有序表] + * TreeMap 如果k两个对象一样,无法加入,不覆盖,[不加重复的K的] + * 如果想都留着,用hashCode() + * 优先级队列可以添加重复的K + * + */ +public class Comparator { + + public static class Student{ + String name; + Integer age; + Integer id; + + } + + + public static class MyComparator implements java.util.Comparator{ + + @Override + public int compare(Student o1, Student o2) { + return 0; + } + } +} diff --git a/src/leo/class03/CountOfRangeSum.java b/src/leo/class03/CountOfRangeSum.java index a75afec..b6c14c7 100644 --- a/src/leo/class03/CountOfRangeSum.java +++ b/src/leo/class03/CountOfRangeSum.java @@ -159,7 +159,7 @@ class CountOfRangeSum2 { 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); + 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) { @@ -197,6 +197,71 @@ class CountOfRangeSum2 { } } + +class CountOfRangeSum3{ + + public static int countRangeSum(int[] nums, int lower, int upper) { + if (nums.length == 0 || nums == null) { + return 0; + } + int[] sum = new int[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(int[] 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(int[] 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++) { + int max = sum[i] - lower; + int min = sum[i] - upper; + while (windowR <= m && sum[windowR] <= max) { + windowR++; + } + while (windowL <= m && sum[windowL] < min) { + windowL++; + } + res += windowR - windowL; + } + + + int[] help = new int[r - l + 1]; + int i = 0; + int p1 = l; + int p2 = m + 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 res; + } +} + class MainTest{ public static int countRangeSum(int[] nums, int lower, int upper) { @@ -226,7 +291,7 @@ class MainTest{ do { upper = (int) ((range * Math.random() + 1) - (range * Math.random() + 1)); } while (upper <= lower); - int sumCount = CountOfRangeSum2.countRangeSum(arr, lower, upper); + int sumCount = CountOfRangeSum3.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/class03/HeapSort.java b/src/leo/class03/HeapSort.java new file mode 100644 index 0000000..f88190f --- /dev/null +++ b/src/leo/class03/HeapSort.java @@ -0,0 +1,101 @@ +package leo.class03; + +import leo.util.ArrayUtil; + +import java.lang.reflect.Array; +import java.util.Arrays; + +/** + * @author Leo + * @ClassName HeapSort + * @DATE 2020/11/27 4:20 下午 + * @Description 堆排序 + * 最差时间复杂度为O(N*logN) + * 数据量扩倍法推算 堆排序的时间复杂度下限是O(N*logN) + * 上限和下限一样 所以时间复杂度为O(N*logN) + * 建堆的时间复杂度是O(N*logN) + * 每个数据插入的时间复杂度是O(logN) + * + * 从上往下建堆:O(N*logN) 一个一个数据插入只能从上往下建堆 + * 从下往上建堆:O(N) [错位相减]所有的数据都有,可以从下往上建堆 + * 堆结构要从上往下建堆 + * 堆排序要从下往上建堆 + * 堆排序额外空间复杂度O(1) + * + */ +public class HeapSort { + + + public static void heapSort(int[] arr) { + if (arr.length < 2 || arr == null) { + return; + } + for (int i = arr.length - 1; i >= 0; i--) { + heapify(arr, i, arr.length); + } + int heapSize = arr.length; + + while (heapSize > 0) { + swap(arr, 0, --heapSize); + heapify(arr, 0, heapSize); + } + swap(arr, 0, heapSize); + + } + + private static void heapify(int[] arr, int i, int heapSize) { + int left = i << 1 | 1; + while (left < heapSize) { + int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left; + largest = arr[largest] > arr[i] ? largest : i; + if (largest == i) { + break; + } + swap(arr, i, largest); + i = largest; + left = i << 1 | 1; + } + } + + + 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 MainHeapSort { + + + public static void main(String[] args){ + int testTime = 10000; + int sizeMax = 70; + 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); + Arrays.sort(copyArray); + HeapSort.heapSort(arr); + if (!ArrayUtil.isEqual(arr, copyArray)) { + ArrayUtil.printArr(arr); + ArrayUtil.printArr(copyArray); + + System.out.println("fuck!"); + break; + + } + } + System.out.println("end"); + + } + +} diff --git a/src/leo/class03/MyMaxHeap.java b/src/leo/class03/MyMaxHeap.java new file mode 100644 index 0000000..7bbf1d7 --- /dev/null +++ b/src/leo/class03/MyMaxHeap.java @@ -0,0 +1,272 @@ +package leo.class03; + +import java.util.PriorityQueue; + +/** + * @author Leo + * @ClassName MyMaxHeap + * @DATE 2020/11/27 11:01 上午 + * @Description 堆结构 + * 堆结构比堆排序重要 + * 优先级队列[PriorityQueue,默认是小根堆]结构就是堆结构. + * 完全二叉树:如果一个树是满的就是完全二叉树,如果一棵树不满,也是最后一层,也在变满的路上,如果一个树是从左到右变满的就是完全二叉树. + * 堆结构:用数组实现的完全二叉树结构, + * 大根堆:在完全二叉树中,每棵子树的最大值都在顶部 + * 小根堆:在完全二叉树中,每棵子树的最小值都在顶部 + * 堆结构操作: + * heapInsert 向上调整 + * heapify 向下调整 + * i 左子节点的位置:2*i+1 + * i 右子节点的位置:2*i+2 + * i 父节点的位置:(i-1)/2 + * + * + + */ +public class MyMaxHeap { + private final int limit; + private int heapSize; + private int[] arr; + + public MyMaxHeap(int limit) { + this.limit = limit; + this.heapSize = 0; + this.arr = new int[limit]; + } + + public void push(int value) { + if (this.heapSize >= this.limit) { + throw new RuntimeException("heap is full"); + } + this.arr[this.heapSize] = value; + heapInsert(arr, this.heapSize++); + } + + public int pop() { + if (heapSize == 0) { + throw new RuntimeException("heap is empty"); + } + int value = this.arr[0]; + this.swap(arr, 0, --heapSize); + heapify(arr, 0, heapSize); + return value; + } + + public boolean isEmpty() { + return heapSize == 0; + } + + + /** + * 将index向上调整 + */ + private void heapInsert(int[] arr, int index) { + + while (arr[index] > arr[(index - 1) / 2]) { + this.swap(arr, index, (index - 1) / 2); + index = (index - 1) / 2; + } + } + + private void heapify(int[] arr, int index, int heapSize) { + int left = index << 1 | 1; + while (left < heapSize) { + //选择左右哪个子节点,哪个大选择那个 + int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left; + largest = arr[largest] > arr[index] ? largest : index; + if (largest == index) { + break; + } + swap(arr, index, largest); + index = largest; + left = index << 1 | 1; + } + } + + + private 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 MyMaxHeap1 { + + private int size; + private final int limit; + private int[] arr; + + + MyMaxHeap1(int limit) { + this.limit = limit; + this.arr = new int[limit]; + this.size = 0; + } + + public boolean isEmpty() { + return size == 0; + } + + public void push(int value) { + if (size == limit) { + throw new RuntimeException("heap is full"); + } + arr[size] = value; + heapInsert(arr, size++); + } + + public int pop() { + if (size == 0) { + throw new RuntimeException("heap is empty!"); + } + int value = this.arr[0]; + this.swap(arr, 0, --size); + heapify(arr, 0, size); + return value; + } + + private void heapify(int[] arr, int i, int size) { + int left = i << 1 | 1; + while (left < size) { + int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left; + largest = arr[i] >= arr[largest] ? i : largest; + if (largest == i) { + break; + } + swap(arr, largest, i); + i = largest; + left = i << 1 | 1; + } + + + + } + + + private void heapInsert(int[] arr, int i) { + while (arr[i] > arr[(i - 1) / 2]) { + swap(arr, i, (i - 1) / 2); + i = (i - 1) / 2; + } + + } + + private 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 MyMaxHeap2{ + + private int size; + private int[] arr; + private final int limit; + + MyMaxHeap2(int limit) { + this.limit = limit; + this.size = 0; + this.arr = new int[limit]; + } + + + public boolean isEmpty() { + return size == 0; + } + + public void push(int value) { + if (size == limit) { + throw new RuntimeException("heap is full"); + } + this.arr[size] = value; + this.heapInsert(arr, size++); + } + + public int pop() { + int value = this.arr[0]; + swap(this.arr, 0, --this.size); + heapify(arr, 0, this.size); + return value; + } + + private void heapify(int[] arr, int i, int size) { + int left = i << 1 | 1; + while (left < size) { + int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left; + largest = arr[largest] > arr[i] ? largest : i; + if (largest == i) { + break; + } + swap(arr, largest, i); + i = largest; + left = i << 1 | 1; + } + } + + private void heapInsert(int[] arr, int i) { + while (arr[i] > arr[(i - 1) / 2]) { + swap(arr, i, (i - 1) / 2); + i = (i - 1) / 2; + } + } + + + private 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 Main{ + + public static void main(String[] args){ + + int testTimes = 1000; + int range = 50; + System.out.println("start!"); + PriorityQueue queue = new PriorityQueue<>((a,b)-> {return b-a;}); + MyMaxHeap2 heap = new MyMaxHeap2(testTimes); + for (int i = 0; i < testTimes; i++) { + if (heap.isEmpty()) { + int num = (int) ((range * Math.random() + 1) - (range * Math.random() + 1)); + queue.add(num); + heap.push(num); + }else { + if (Math.random() < 0.5) { + int num = (int) ((range * Math.random() + 1) - (range * Math.random() + 1)); + queue.add(num); + heap.push(num); + }else{ + Integer poll = queue.poll(); + int pop = heap.pop(); + if (poll != pop) { + System.out.println(poll); + System.out.println(pop); + System.out.println("fuck!"); + return; + } + + } + } + } + System.out.println("end!"); + + + } + + +} diff --git a/src/leo/class03/QuickSort1.java b/src/leo/class03/QuickSort1.java index 65320fb..36097a6 100644 --- a/src/leo/class03/QuickSort1.java +++ b/src/leo/class03/QuickSort1.java @@ -6,6 +6,7 @@ import leo.util.ArrayUtil; import java.util.Arrays; import java.util.Stack; +import java.util.function.IntPredicate; /** * @author Leo @@ -224,9 +225,6 @@ class QuickSort3_1{ } 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}; } @@ -262,6 +260,59 @@ class QuickSort3_1{ } +class QuickSort3_2{ + + 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 + ((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[]{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}; + + + } + + + 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{ @@ -352,7 +403,7 @@ class TestMain { for (int i = 0; i < testTimes; i++) { int[] arr = ArrayUtil.randomArray(sizeMax, range); int[] copyArray = ArrayUtil.copyArray(arr); - QuickSort3_1.quickSort(arr); + QuickSort3_2.quickSort(arr); Arrays.sort(copyArray); if (!ArrayUtil.isEqual(arr, copyArray)) { ArrayUtil.printArr(arr); diff --git a/src/leo/class03/SortArrayDistanceLessK.java b/src/leo/class03/SortArrayDistanceLessK.java new file mode 100644 index 0000000..c49b96e --- /dev/null +++ b/src/leo/class03/SortArrayDistanceLessK.java @@ -0,0 +1,99 @@ +package leo.class03; + +import leo.util.ArrayUtil; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.PriorityQueue; +import java.util.Set; + +/** + * @author Leo + * @ClassName SortArrayDistanceLessK + * @DATE 2020/11/27 6:28 下午 + * @Description + * 已知一个几乎有序的数组。几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离一定不超过k，并且k相对于数组长度来说是比较小的 + */ +public class SortArrayDistanceLessK { + + + public static void sortArrayDistanceLessK(int[] arr, int k) { + if (arr.length < 2 || arr == null || k == 0) { + return; + } + //默认是小根堆 + PriorityQueue queue = new PriorityQueue<>(); + int index = 0; + for (; index < Math.min(arr.length - 1, k - 1); index++) { + queue.add(arr[index]); + } + int i = 0; + for (; index < arr.length; i++, index++) { + queue.add(arr[index]); + arr[i] = queue.poll(); + } + while (!queue.isEmpty()) { + arr[i++] = queue.poll(); + } + } + +} + + +class MainK { + + + public static void main(String[] args){ + int testTime = 1000; + int sizeMax = 30; + int range = 50; + System.out.println("start!"); + for (int i = 0; i < testTime; i++) { + int[] arr = ArrayUtil.randomSortArray(sizeMax, range); + + int k = (int) (Math.random() * arr.length-1) + 1; + + UpsetArray(arr, k); + int[] copyArray = ArrayUtil.copyArray(arr); + Arrays.sort(copyArray); + SortArrayDistanceLessK.sortArrayDistanceLessK(arr,k); + if (!ArrayUtil.isEqual(arr, copyArray)) { + ArrayUtil.printArr(arr); + ArrayUtil.printArr(copyArray); + System.out.println("fuck"); + break; + } + } + System.out.println("end!"); + + } + + public static void UpsetArray(int[] arr, int k) { + Set indexSet = new HashSet<>(); + for (int i = 0; i < arr.length; i++) { + int indexK = 0; + while (indexK < k && i < arr.length) { + int j; + do { + j = (int) (i + (Math.random() * k)); + } while (j > arr.length - 1); + if (!indexSet.contains(j) && !indexSet.contains(i)) { + indexSet.add(i); + indexSet.add(j); + swap(arr, i, j); + } + i++; + } + i += k; + } + } + + 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]; + } +}