第三节完成

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

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<Student>{
+
+        @Override
+        public int compare(Student o1, Student o2) {
+            return 0;
+        }
+    }
+}

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

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");
+
+    }
+
+}

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<Integer> 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!");
+
+
+    }
+
+
+}

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

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<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 {
+
+
+    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<Integer> 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];
+    }
+}