练习,加强堆

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<Integer> data;
+        private Stack<Integer> 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<Integer> data;
+        private Stack<Integer> 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) {

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<Node> 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<DoubleNode> doubleNodeList = DoubleNodeToList(doubleNodeHead);
-            DoubleNode doubleNode = reverseDoubleNode5(doubleNodeHead);
+            DoubleNode doubleNode = reverseDoubleNode6(doubleNodeHead);
             if (!verifyReverseListAndDoubleNode(doubleNodeList, doubleNode)) {
                 System.out.println("doubleNodeFuck!!");
                 break;

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;

src/leo/class02/ReversePair.java

@@ -263,6 +263,8 @@ class ReversePair5{
     }
 }
 
+
+
 class TestReversePair{
     public static int reversePairNumber(int[] arr) {
         int res = 0;

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<Integer> queue = new LinkedList<>();
             for (int j = 0; j < length; j++) {
                 int value = randomInt(range);

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);

src/leo/class02/TwoQueueImplementStack.java

@@ -104,10 +104,52 @@ public class TwoQueueImplementStack {
 
     }
 
+    public static class MyStack2<T>{
+        private Queue<T> stack;
+        private Queue<T> 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<T> 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<T> 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<Integer> myStack = new MyStack1<>();
+        MyStack2<Integer> myStack = new MyStack2<>();
         Stack<Integer> stack = new Stack<>();
         System.out.println("Start!");
         for (int i = 0; i < testTime; i++) {

src/leo/class02/TwoStacksImplementQueue.java

@@ -56,6 +56,51 @@ public class TwoStacksImplementQueue {
 
     }
 
+    public static class MyQueue1{
+
+        private Stack<Integer> push;
+        private Stack<Integer> 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<Integer> 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);

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);

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 {
 
 

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<Integer> 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));

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);

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<Integer> 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);

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<Line>{
+
+        /**
+         * 正数第二在前
+         * 负数第一个在前
+         */
+        @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<Integer> 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;
+    }
+
+
+}

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 {
+}

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<T> {
+
+    //堆容器
+    private ArrayList<T> heap ;
+    //反向索引
+    private HashMap<T, Integer> indexMap;
+    //堆大小
+    private int heapSize;
+    //堆比较器
+    private final Comparator<? super T> com;
+
+    public HeapGreater(Comparator com) {
+        this.com = com;
+        heap = new ArrayList<T>();
+        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<T> getAllElements() {
+        List<T> 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);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}