diff --git a/src/leo/class02/GetMinStack.java b/src/leo/class02/GetMinStack.java index 32e6fdd..a433fbb 100644 --- a/src/leo/class02/GetMinStack.java +++ b/src/leo/class02/GetMinStack.java @@ -72,7 +72,7 @@ public class GetMinStack { data.push(value); } - public Integer pop() { + public int pop() { if (data.isEmpty()) { throw new RuntimeException("Stack is Empty"); } @@ -136,6 +136,49 @@ public class GetMinStack { } + public static class MyStack7 { + private Stack data; + private Stack min; + + public MyStack7() { + data = new Stack<>(); + min = new Stack<>(); + } + + public int getMin() throws Exception { + if (min.isEmpty()) { + throw new Exception("stack is empty"); + } + return min.peek(); + } + + public boolean isEmpty() { + return data.isEmpty(); + } + + public void push(int value) { + try { + if (this.data.isEmpty()||this.getMin() >= value) { + min.push(value); + } + } catch (Exception e) { + min.push(value); + } + data.push(value); + } + + public int pop() throws Exception { + if (data.isEmpty()) { + throw new RuntimeException("stack is empty"); + } + int value = data.pop(); + if (this.getMin() == value) { + min.pop(); + } + return value; + } + } + /** * 只有最小值入栈,最小值重复入栈 */ @@ -257,6 +300,50 @@ public class GetMinStack { } + public static class MyStack8 { + private Stack data; + private Stack min; + + public MyStack8() { + data = new Stack<>(); + min = new Stack<>(); + } + + public int getMin() throws Exception{ + if (min.isEmpty()) { + throw new Exception("stack is empty"); + } + return min.peek(); + } + + public boolean isEmpty() { + return data.isEmpty(); + } + + public void push(int value){ + + try { + if (data.isEmpty() || value < this.getMin()) { + min.push(value); + }else{ + min.push(this.getMin()); + } + } catch (Exception e) { + min.push(value); + } + + data.push(value); + } + + public int pop() throws Exception{ + if (data.isEmpty()) { + throw new Exception("stack is empty"); + } + min.pop(); + return data.pop(); + } + } + /** * 用list实现 只存最小值的索引 */ @@ -347,7 +434,7 @@ public class GetMinStack { System.out.println("Start!"); for (int i = 0; i < testTime; i++) { - MyStack5 myStack = new MyStack5(); + MyStack8 myStack = new MyStack8(); TestMyStack testMyStack = new TestMyStack(); for (int j = 0; j < forTime; j++) { if (Math.random() < 0.5) { diff --git a/src/leo/class02/LinkedList.java b/src/leo/class02/LinkedList.java index b49108a..a44cf98 100644 --- a/src/leo/class02/LinkedList.java +++ b/src/leo/class02/LinkedList.java @@ -166,6 +166,21 @@ public class LinkedList { return pre; } + public static Node reverseNode10(Node head) { + if (head == null) { + return null; + } + Node pre = head; + Node next = null; + while (head != null) { + next = head.next; + head.next = pre; + pre = head; + head = next; + } + return pre; + } + public static DoubleNode reverseDoubleNode(DoubleNode head) { DoubleNode pre = null; DoubleNode next; @@ -245,6 +260,23 @@ public class LinkedList { return pre; } + public static DoubleNode reverseDoubleNode6(DoubleNode head) { + if (head == null) { + return null; + } + DoubleNode pre = head; + DoubleNode next = null; + while (head != null) { + next = head.next; + head.pre = next; + head.next = pre; + pre = head; + head = next; + } + return pre; + + } + /** * 功能描述 : 随机生成单链表 * @author Leo @@ -375,14 +407,14 @@ public class LinkedList { for (int i = 0; i < testTime; i++) { Node head = randomNode(maxSize, range); List nodeList = nodeToList(head); - Node node = reverseNode9(head); + Node node = reverseNode10(head); if (!verifyReverseListAndNode(nodeList, node)) { System.out.println("nodeFuck!!"); break; } DoubleNode doubleNodeHead = randomDoubleNode(maxSize, range); List doubleNodeList = DoubleNodeToList(doubleNodeHead); - DoubleNode doubleNode = reverseDoubleNode5(doubleNodeHead); + DoubleNode doubleNode = reverseDoubleNode6(doubleNodeHead); if (!verifyReverseListAndDoubleNode(doubleNodeList, doubleNode)) { System.out.println("doubleNodeFuck!!"); break; diff --git a/src/leo/class02/MergeSort.java b/src/leo/class02/MergeSort.java index e26d334..5994240 100644 --- a/src/leo/class02/MergeSort.java +++ b/src/leo/class02/MergeSort.java @@ -165,6 +165,45 @@ public class MergeSort { } } + public static class Recursion3 { + public static void mergeSort(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 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 p1 = l; + int p2 = m + 1; + int[] help = new int[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]; + } + + } + } + /** * @author Leo * @ClassName MergeSort @@ -282,7 +321,7 @@ public class MergeSort { for (int i = 0; i < testOfTime; i++) { int[] arr = ArrayUtil.randomArray(maxSize, range); int[] anotherArr = ArrayUtil.copyArray(arr); - Recursion2.mergeSort(arr); + Recursion3.mergeSort(arr); Arrays.sort(anotherArr); if (!ArrayUtil.isEqual(arr, anotherArr)) { succeed = false; diff --git a/src/leo/class02/ReversePair.java b/src/leo/class02/ReversePair.java index 487dede..77345c0 100644 --- a/src/leo/class02/ReversePair.java +++ b/src/leo/class02/ReversePair.java @@ -263,6 +263,8 @@ class ReversePair5{ } } + + class TestReversePair{ public static int reversePairNumber(int[] arr) { int res = 0; diff --git a/src/leo/class02/RingArray.java b/src/leo/class02/RingArray.java index 89266fa..0602b4c 100644 --- a/src/leo/class02/RingArray.java +++ b/src/leo/class02/RingArray.java @@ -183,13 +183,56 @@ public class RingArray { } } + public static class MyQueue4 { + private int size; + private int[] arr; + private int push; + private int poll; + private final int limit; + + public MyQueue4(int limit) { + this.limit = limit; + this.push = 0; + this.poll = 0; + this.arr = new int[limit]; + this.size = 0; + } + + public void push(int value) { + if (this.size == this.limit) { + throw new RuntimeException("queue is full"); + } + arr[push] = value; + size++; + this.push = nextIndex(push); + } + + public int poll() { + if (this.size == 0) { + throw new RuntimeException("queue is empty"); + } + int value = arr[poll]; + size--; + poll = nextIndex(poll); + return value; + } + + public boolean isEmpty() { + return this.size == 0; + } + public int nextIndex(int i) { + return i < this.limit - 1 ? i + 1 : 0; + } + + } + public static void main(String[] args) { int testTime = 10000; int range = 100; int sizeMax = 80; for (int i = 0; i < testTime; i++) { int length = randomInt(sizeMax); - MyQueue3 myQueue = new MyQueue3(length); + MyQueue4 myQueue = new MyQueue4(length); Queue queue = new LinkedList<>(); for (int j = 0; j < length; j++) { int value = randomInt(range); diff --git a/src/leo/class02/SmallSum.java b/src/leo/class02/SmallSum.java index a8d50f4..252da90 100644 --- a/src/leo/class02/SmallSum.java +++ b/src/leo/class02/SmallSum.java @@ -314,6 +314,45 @@ class SmallSum6{ } } +class SmallSum7 { + public static int smallSum(int[] arr) { + if (arr.length < 2 || arr == null) { + return 0; + } + return process(arr, 0, arr.length - 1); + } + + public 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) { @@ -357,7 +396,7 @@ class TestMain { for (int i = 0; i < testTime; i++) { int[] arr = ArrayUtil.randomArray(maxSize, range); int[] copyArray = ArrayUtil.copyArray(arr); - int sum = SmallSum6.smallSum(arr); + int sum = SmallSum7.smallSum(arr); int testSum = TestSmallSum.smallSum(copyArray); if (testSum != sum) { System.out.println("sum :" + sum + ", testSum : " + testSum); diff --git a/src/leo/class02/TwoQueueImplementStack.java b/src/leo/class02/TwoQueueImplementStack.java index 59a6700..da10c32 100644 --- a/src/leo/class02/TwoQueueImplementStack.java +++ b/src/leo/class02/TwoQueueImplementStack.java @@ -104,10 +104,52 @@ public class TwoQueueImplementStack { } + public static class MyStack2{ + private Queue stack; + private Queue help; + + public MyStack2() { + this.stack = new LinkedList<>(); + this.help = new LinkedList<>(); + } + public boolean isEmpty() { + return stack.isEmpty(); + } + + public void push(T value) { + this.stack.offer(value); + } + + public T pop() { + while (stack.size() > 1) { + help.offer(this.stack.poll()); + } + T poll = this.stack.poll(); + Queue temp = stack; + stack = help; + help = temp; + return poll; + } + + public T peek() { + while (this.stack.size() > 1) { + help.offer(stack.poll()); + } + T poll = this.stack.poll(); + Queue temp = stack; + this.stack = this.help; + this.help = temp; + this.stack.offer(poll); + return poll; + } + + } + + public static void main(String[] args){ int testTime = 1000; int range = 500; - MyStack1 myStack = new MyStack1<>(); + MyStack2 myStack = new MyStack2<>(); Stack stack = new Stack<>(); System.out.println("Start!"); for (int i = 0; i < testTime; i++) { diff --git a/src/leo/class02/TwoStacksImplementQueue.java b/src/leo/class02/TwoStacksImplementQueue.java index 038cbd7..627e651 100644 --- a/src/leo/class02/TwoStacksImplementQueue.java +++ b/src/leo/class02/TwoStacksImplementQueue.java @@ -56,6 +56,51 @@ public class TwoStacksImplementQueue { } + public static class MyQueue1{ + + private Stack push; + private Stack pop; + + public MyQueue1() { + this.pop = new Stack<>(); + this.push = new Stack<>(); + } + + public boolean isEmpty() { + return this.push.isEmpty(); + } + + public void push(int value) { + push.push(value); + pushToPop(); + } + + public int poll() throws Exception { + if (pop.isEmpty()) { + throw new Exception("queue is empty"); + } + Integer pop = this.pop.pop(); + pushToPop(); + return pop; + } + + public int peek() throws Exception { + if (this.pop.isEmpty()) { + throw new Exception("queue is empty"); + } + pushToPop(); + return this.pop.peek(); + } + + public void pushToPop() { + + if (this.pop.isEmpty()) { + while (!this.push.isEmpty()) { + this.pop.push(this.push.pop()); + } + } + } + } public static void main(String[] args) { @@ -63,7 +108,7 @@ public class TwoStacksImplementQueue { int testTime = 1000000; int range = 30; Queue queue = new LinkedList<>(); - MyQueue myQueue = new MyQueue(); + MyQueue1 myQueue = new MyQueue1(); for (int i = 0; i < testTime; i++) { if (Math.random() < 0.5) { int value = randomInt(range); diff --git a/src/leo/class03/CountOfRangeSum.java b/src/leo/class03/CountOfRangeSum.java index b6c14c7..a526495 100644 --- a/src/leo/class03/CountOfRangeSum.java +++ b/src/leo/class03/CountOfRangeSum.java @@ -204,7 +204,7 @@ class CountOfRangeSum3{ if (nums.length == 0 || nums == null) { return 0; } - int[] sum = new int[nums.length]; + 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]; @@ -212,7 +212,7 @@ class CountOfRangeSum3{ return process(sum, 0, sum.length - 1, lower, upper); } - private static int process(int[] sum, int l, int r, int lower, int upper) { + private static int process(long[] sum, int l, int r, int lower, int upper) { if (l > r) { return 0; } @@ -224,13 +224,13 @@ class CountOfRangeSum3{ 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) { + 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++) { - int max = sum[i] - lower; - int min = sum[i] - upper; + long max = sum[i] - lower; + long min = sum[i] - upper; while (windowR <= m && sum[windowR] <= max) { windowR++; } @@ -241,7 +241,7 @@ class CountOfRangeSum3{ } - int[] help = new int[r - l + 1]; + long[] help = new long[r - l + 1]; int i = 0; int p1 = l; int p2 = m + 1; @@ -262,6 +262,72 @@ class CountOfRangeSum3{ } } + +class CountOfRangeSum4 { + + 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, sum.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 res = 0; + int windowR = l; + int windowL = l; + 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; + } + + long[] help = new long[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) { @@ -279,7 +345,7 @@ class MainTest{ public static void main(String[] args) { int testTime = 1000; - int sizeMax = 80; + int sizeMax = 5; int range = 50; System.out.println("start!"); @@ -291,7 +357,7 @@ class MainTest{ do { upper = (int) ((range * Math.random() + 1) - (range * Math.random() + 1)); } while (upper <= lower); - int sumCount = CountOfRangeSum3.countRangeSum(arr, lower, upper); + int sumCount = CountOfRangeSum4.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 index f88190f..40ccf7c 100644 --- a/src/leo/class03/HeapSort.java +++ b/src/leo/class03/HeapSort.java @@ -57,7 +57,6 @@ public class HeapSort { } } - private static void swap(int[] arr, int i, int j) { if (i == j || arr[i] == arr[j]) { return; @@ -67,10 +66,11 @@ public class HeapSort { arr[i] = arr[i] ^ arr[j]; } - } + + class MainHeapSort { diff --git a/src/leo/class03/MyMaxHeap.java b/src/leo/class03/MyMaxHeap.java index 7bbf1d7..9614579 100644 --- a/src/leo/class03/MyMaxHeap.java +++ b/src/leo/class03/MyMaxHeap.java @@ -230,6 +230,74 @@ class MyMaxHeap2{ } } +class MyMaxHeap3 { + private int size; + private int[] arr; + private final int limit; + + public MyMaxHeap3(int limit) { + this.limit = limit; + this.size = 0; + this.arr = new int[limit]; + } + + 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 = arr[0]; + swap(arr, 0, --size); + heapify(arr, 0, size); + return value; + } + + private 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; + } + this.swap(arr, largest, i); + i = largest; + left = i << 1 | 1; + } + } + + private void heapInsert(int[] arr, int index) { + while (arr[index] > arr[(index - 1) / 2]) { + swap(arr, index, (index - 1) / 2); + index = (index - 1) / 2; + } + } + + public boolean isEmpty() { + return size == 0; + } + + public 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{ @@ -239,7 +307,7 @@ class Main{ int range = 50; System.out.println("start!"); PriorityQueue queue = new PriorityQueue<>((a,b)-> {return b-a;}); - MyMaxHeap2 heap = new MyMaxHeap2(testTimes); + MyMaxHeap3 heap = new MyMaxHeap3(testTimes); for (int i = 0; i < testTimes; i++) { if (heap.isEmpty()) { int num = (int) ((range * Math.random() + 1) - (range * Math.random() + 1)); diff --git a/src/leo/class03/QuickSort1.java b/src/leo/class03/QuickSort1.java index 36097a6..594d2ce 100644 --- a/src/leo/class03/QuickSort1.java +++ b/src/leo/class03/QuickSort1.java @@ -301,7 +301,6 @@ class QuickSort3_2{ } - private static void swap(int[] arr, int i, int j) { if (i == j || arr[i] == arr[j]) { return; @@ -313,6 +312,56 @@ class QuickSort3_2{ } +class QuickSort3_3{ + + 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[] 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, --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 (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{ @@ -403,7 +452,7 @@ class TestMain { for (int i = 0; i < testTimes; i++) { int[] arr = ArrayUtil.randomArray(sizeMax, range); int[] copyArray = ArrayUtil.copyArray(arr); - QuickSort3_2.quickSort(arr); + QuickSort3_3.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 index c49b96e..f290fd8 100644 --- a/src/leo/class03/SortArrayDistanceLessK.java +++ b/src/leo/class03/SortArrayDistanceLessK.java @@ -2,10 +2,7 @@ package leo.class03; import leo.util.ArrayUtil; -import java.util.Arrays; -import java.util.HashSet; -import java.util.PriorityQueue; -import java.util.Set; +import java.util.*; /** * @author Leo @@ -39,6 +36,30 @@ public class SortArrayDistanceLessK { } +class SortArrayDistanceLessK1 { + + public static void sortArrayDistanceLessK(int[] arr, int k) { + if (k <= 0 || arr.length < 2) { + 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 { @@ -56,7 +77,7 @@ class MainK { UpsetArray(arr, k); int[] copyArray = ArrayUtil.copyArray(arr); Arrays.sort(copyArray); - SortArrayDistanceLessK.sortArrayDistanceLessK(arr,k); + SortArrayDistanceLessK1.sortArrayDistanceLessK(arr,k); if (!ArrayUtil.isEqual(arr, copyArray)) { ArrayUtil.printArr(arr); ArrayUtil.printArr(copyArray); diff --git a/src/leo/class04/CoverMax.java b/src/leo/class04/CoverMax.java new file mode 100644 index 0000000..e53cfb5 --- /dev/null +++ b/src/leo/class04/CoverMax.java @@ -0,0 +1,134 @@ +package leo.class04; + +import java.util.Arrays; +import java.util.Comparator; +import java.util.PriorityQueue; + +/** + * @author Leo + * @ClassName CoverMax + * @DATE 2020/11/30 4:19 下午 + * @Description 最大线段重合问题 + * 给定很多线段，每个线段都有两个数[start, end]， + * 表示线段开始位置和结束位置，左右都是闭区间 + * 规定： + * 1）线段的开始和结束位置一定都是整数值 + * 2）线段重合区域的长度必须>=1 + * 返回线段最多重合区域中，包含了几条线段 + */ +public class CoverMax { + + /** + * 线段 + */ + public static class Line{ + private int start; + private int end; + + public Line(int start, int end) { + this.start = start; + this.end = end; + } + } + + public static class LineStartComparator implements Comparator{ + + /** + * 正数第二在前 + * 负数第一个在前 + */ + @Override + public int compare(Line o1, Line o2) { + return o1.start - o2.start; + } + } + + public static int maxCover(int[][] arr) { + Line[] lines = new Line[arr.length]; + for (int i = 0; i < arr.length; i++) { + lines[i] = new Line(arr[i][0], arr[i][1]); + } + //根据start排序正序 + Arrays.sort(lines, new LineStartComparator()); + //默认小根堆 + PriorityQueue heap = new PriorityQueue<>(); + int max = 0; + for (int i = 0; i < lines.length; i++) { + while (!heap.isEmpty() && heap.peek() <= lines[i].start) { + heap.poll(); + } + heap.add(lines[i].end); + max = Math.max(max, heap.size()); + } + return max; + } + +} + + +class CoverMaxForTest{ + + public static int maxCover(int[][] arr) { + int min = 0; + int max = 0; + for (int i = 0; i < arr.length; i++) { + min = Math.min(min, arr[i][0]); + max = Math.max(max, arr[i][1]); + } + int cover = 0; + for (double p = min + 0.5; p < max; p += 1) { + int cur = 0; + for (int i = 0; i < arr.length; i++) { + if (arr[i][0] < p && arr[i][1] > p) { + cur++; + } + } + cover = Math.max(cover, cur); + } + + return cover; + } + +} + +class CoverMaxMain { + + public static void main(String[] args) { + int testTime = 1000; + int sizeMax = 50; + int L = 0; + int R = 100; + System.out.println("start"); + + for (int i = 0; i < testTime; i++) { + int[][] lines = generateLines(sizeMax, L, R); + int max = CoverMax.maxCover(lines); + int maxForTest = CoverMaxForTest.maxCover(lines); + if (max != maxForTest) { + System.out.println("max : " + max + " maxForTest : " + maxForTest); + System.out.println("fuck!"); + break; + } + } + System.out.println("end"); + + } + + private static int[][] generateLines(int sizeMax, int L, int R) { + int[][] arr = new int[(int) (sizeMax * Math.random() + 1)][2]; + + for (int i = 0; i < arr.length; i++) { + int a = (int) (L + ((R - L) + 1) * Math.random()); + int b = (int) (L + ((R - L) + 1) * Math.random()); + if (a == b) { + a++; + } + arr[i][0] = Math.min(a, b); + arr[i][1] = Math.max(a, b); + } + + return arr; + } + + +} diff --git a/src/leo/class04/EveryStepShowBoss.java b/src/leo/class04/EveryStepShowBoss.java new file mode 100644 index 0000000..d42b65b --- /dev/null +++ b/src/leo/class04/EveryStepShowBoss.java @@ -0,0 +1,10 @@ +package leo.class04; + +/** + * @author Leo + * @ClassName EveryStepShowBoss + * @DATE 2020/11/30 7:33 下午 + * @Description + */ +public class EveryStepShowBoss { +} diff --git a/src/leo/class04/HeapGreater.java b/src/leo/class04/HeapGreater.java new file mode 100644 index 0000000..8f7a84e --- /dev/null +++ b/src/leo/class04/HeapGreater.java @@ -0,0 +1,159 @@ +package leo.class04; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; + +/** + * @author Leo + * @ClassName HeapGreater + * @DATE 2020/11/30 5:21 下午 + * @Description 加强堆 + * 1 反向索引 + * 2 比较器 + * + */ +public class HeapGreater { + + //堆容器 + private ArrayList heap ; + //反向索引 + private HashMap indexMap; + //堆大小 + private int heapSize; + //堆比较器 + private final Comparator com; + + public HeapGreater(Comparator com) { + this.com = com; + heap = new ArrayList(); + this.indexMap = new HashMap<>(); + this.heapSize = 0; + } + + //push + public void push(T value) { + this.heap.add(value); + this.indexMap.put(value, heapSize); + this.heapInsert(heapSize++); + } + + //peek + public T peek() { + return this.heap.get(0); + } + + //pop + public T pop() { + if (heapSize == 0) { + return null; + } + T value = this.heap.get(0); + this.swap(0, heapSize - 1); + this.indexMap.remove(value); + this.heap.remove(--heapSize); + this.heapify(0); + return value; + } + + //remove + public void remove(T obj) { + T t = this.heap.get(this.heapSize - 1); + int objIndex = this.indexMap.get(obj); + this.indexMap.remove(obj); + this.heap.remove(--this.heapSize); + if (obj != t) { + this.heap.set(objIndex, t); + this.indexMap.put(t, objIndex); + this.resign(objIndex); + } + + } + + //resign + private void resign(int i) { + this.heapify(i); + this.heapInsert(i); + } + + //getAllElements + public List getAllElements() { + List res = new ArrayList<>(); + for (T t : this.heap) { + res.add(t); + } + return res; + } + + + //heapInsert 向上调整 + private void heapInsert(int i) { + while (this.com.compare(this.heap.get(i), this.heap.get((i - 1) / 2)) < 0) { + swap(i, (i - 1) / 2); + i = (i - 1) / 2; + } + } + + + //heapify 向下调整 + private void heapify(int i) { + int left = i << 1 | 1; + while (left < this.heapSize) { + int largest = left + 1 < this.heapSize && com.compare(heap.get(left + 1), heap.get(left)) < 0 ? left + 1 : left; + largest = com.compare(heap.get(largest), heap.get(i)) < 0 ? largest : i; + if (largest == i) { + break; + + } + this.swap(i, largest); + i = largest; + left = i << 1 | 1; + } + } + + //swap + private void swap(int i, int j) { + T t = this.heap.get(i); + T t1 = this.heap.get(j); + this.heap.set(i, t1); + this.heap.set(j, t); + indexMap.put(t1, i); + indexMap.put(t, j); + } + + //size + public int getSize() { + return this.heapSize; + } + + //isEmpty + public boolean isEmpty() { + return this.heapSize == 0; + } + //contains + public boolean contains(T obj) { + return this.indexMap.containsKey(obj); + } + + + + + + + + + + + + + + + + + + + + + +}