diff --git "a/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\240\206\346\216\222\345\272\217/HeapSort.class" "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\240\206\346\216\222\345\272\217/HeapSort.class"
new file mode 100644
index 0000000000000000000000000000000000000000..97f4a41380e60dfb6628ec576a98a0ccf167271b
Binary files /dev/null and "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\240\206\346\216\222\345\272\217/HeapSort.class" differ
diff --git "a/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\240\206\346\216\222\345\272\217/HeapSort.java" "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\240\206\346\216\222\345\272\217/HeapSort.java"
new file mode 100644
index 0000000000000000000000000000000000000000..cd47ba6fdba25267611cc529ef66ae1130206c23
--- /dev/null
+++ "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\240\206\346\216\222\345\272\217/HeapSort.java"
@@ -0,0 +1,45 @@
+public class HeapSort {
+    public static void main(String[] args) {
+        int[] nums = {16,7,3,20,17,8};
+        headSort(nums);
+        for (int num : nums) {
+            System.out.print(num + " ");
+        }
+    }
+
+    /**
+     * 堆排序
+     */
+    public static void headSort(int[] list) {
+        //构造初始堆,从第一个非叶子节点开始调整,左右孩子节点中较大的交换到父节点中
+        for (int i = (list.length) / 2 - 1; i >= 0; i--) {
+            headAdjust(list, list.length, i);
+        }
+        //排序，将最大的节点放在堆尾，然后从根节点重新调整
+        for (int i = list.length - 1; i >= 1; i--) {
+            int temp = list[0];
+            list[0] = list[i];
+            list[i] = temp;
+            headAdjust(list, i, 0);
+        }
+    }
+
+    private static void headAdjust(int[] list, int len, int i) {
+        int k = i, temp = list[i], index = 2 * k + 1;
+        while (index < len) {
+            if (index + 1 < len) {
+                if (list[index] < list[index + 1]) {
+                    index = index + 1;
+                }
+            }
+            if (list[index] > temp) {
+                list[k] = list[index];
+                k = index;
+                index = 2 * k + 1;
+            } else {
+                break;
+            }
+        }
+        list[k] = temp;
+    }
+}
\ No newline at end of file
diff --git "a/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/MaxHeap.class" "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/MaxHeap.class"
new file mode 100644
index 0000000000000000000000000000000000000000..864481dbf40dcb37e2b5505525e412e8e70f3ee7
Binary files /dev/null and "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/MaxHeap.class" differ
diff --git "a/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/MaxHeap.java" "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/MaxHeap.java"
new file mode 100644
index 0000000000000000000000000000000000000000..97ee9717e0af05ddb8d9b2f4a7c8e97edb20c589
--- /dev/null
+++ "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/MaxHeap.java"
@@ -0,0 +1,118 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class MaxHeap <T extends Comparable<T>> {
+    private List<T> mHeap; // 存放元素的动态数组
+
+    public MaxHeap() {
+
+        this.mHeap = new ArrayList<>();
+    }
+
+    protected void filterup(int start) {
+
+        int c = start; // 需要调整的节点的初始位置
+        int p = (c - 1) / 2; // 当前节点的父节点的位置
+        T tmp = mHeap.get(c); // 被调整节点的值
+
+        while (c > 0) {
+            // 父节点的值和被调整节点的值进行比较
+            int cmp = mHeap.get(p).compareTo(tmp);
+            if (cmp >= 0) {
+                // 父节点大
+                break;
+            } else {
+                // 被调整节点的值大，交换
+                mHeap.set(c, mHeap.get(p));
+                c = p;
+                p = (c - 1) / 2;
+            }
+        }
+        // 找到被调整节点的最终位置了
+        mHeap.set(c, tmp);
+    }
+
+
+    protected void filterdown(int start, int end) {
+
+        int c = start; // 被下调节点的初始位置
+        int l = 2 * c + 1; // 左孩子节点的位置
+        T tmp = mHeap.get(c); // 当前节点的值(大小)
+
+        while (l <= end) {
+            // 当前节点的左右节点进行比较
+            int cmp = mHeap.get(l).compareTo(mHeap.get(l + 1));
+            // 取大的
+            if (l < end && cmp < 0) {
+                l++;
+            }
+            // 当前节点和大的那个再比较一下
+            cmp = tmp.compareTo(mHeap.get(l));
+            if (cmp >= 0) {
+                // 当前节点大,不用动
+                break;
+            } else {
+                // 当前节点小,交换
+                mHeap.set(c, mHeap.get(l));
+                c = l; // 更新当前节点的位置
+                l = 2 * c + 1; // 更新当前节点的左孩子位置
+            }
+        }
+        mHeap.set(c, tmp);
+    }
+
+
+    /**
+     * 向大顶堆中插入新元素
+     *
+     * @param data
+     */
+    public void insert(T data) {
+
+        int insertIndex = mHeap.size(); // 获取插入的位置
+        // 将新元素插入到数组尾部
+        mHeap.add(data);
+        // 调用filterup函数，调整大顶堆
+        filterup(insertIndex);
+    }
+
+
+
+    public int remove(T data) {
+
+        // 大顶堆空
+        if (mHeap.isEmpty()) {
+            return -1;
+        }
+
+        // 获取data在数组中的索引
+        int index = mHeap.indexOf(data);
+        if (index == -1) {
+            return -1;
+        }
+
+        // 堆中元素的个数
+        int size = mHeap.size();
+        // 删除了data元素，需要用最后一个元素填补，然后调用filterdown算法进行调整
+        mHeap.set(index, mHeap.get(size - 1)); // 用最后一个元素填补
+        mHeap.remove(size - 1); // 删除最后一个元素
+
+        if (mHeap.size() > 1 && index < mHeap.size()) {
+            // 调整成大顶堆
+            filterdown(index, mHeap.size() - 1);
+        }
+        return 0;
+    }
+
+
+    @Override
+    public String toString() {
+
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < mHeap.size(); i++) {
+            sb.append(mHeap.get(i) + " ");
+        }
+        return sb.toString();
+    }
+
+}
\ No newline at end of file
diff --git "a/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/TestHeap.class" "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/TestHeap.class"
new file mode 100644
index 0000000000000000000000000000000000000000..2f4b192e79a39eddc3ce5cd3ff2295a24f7d78c0
Binary files /dev/null and "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/TestHeap.class" differ
diff --git "a/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/TestHeap.java" "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/TestHeap.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e3438eb531fa1653876f4460305febfaeb159bda
--- /dev/null
+++ "b/20200340930_\345\210\230\347\277\224-lec07-heap/\345\237\272\347\241\200\344\275\234\344\270\232/\345\256\236\347\216\260\345\244\247\351\241\266\345\240\206\357\274\210\345\205\245\345\240\206\343\200\201\345\207\272\345\240\206\357\274\211/TestHeap.java"
@@ -0,0 +1,35 @@
+
+public class TestHeap {
+    public static void main(String[] args) {
+
+        int a[] = {10, 40 ,30, 60, 90, 70, 20, 50 ,80};
+
+        //大顶堆
+        MaxHeap<Integer> maxHeap = new MaxHeap<Integer>();
+
+        //添加元素
+        System.out.print("=== 依次添加元素：");
+        for(int i = 0; i < a.length; i++) {
+            System.out.println(a[i]);
+            maxHeap.insert(a[i]);
+        }
+
+        //生成的大顶堆
+        System.out.println("=== 生成的大顶堆：");
+        System.out.println(maxHeap);
+
+        //添加新元素85
+        int data = 85;
+        maxHeap.insert(data);
+        System.out.println("=== 添加新元素" + data + "之后的大顶堆：");
+        System.out.println(maxHeap);
+
+        //删除元素90
+        data = 90;
+        maxHeap.remove(data);
+        System.out.println("=== 删除元素" + data + "之后的大顶堆：");
+        System.out.println(maxHeap);
+
+    }
+
+}
\ No newline at end of file
diff --git "a/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\344\274\230\345\205\210\347\272\247\351\230\237\345\210\227\345\220\210\345\271\266K\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204/MergeK.class" "b/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\344\274\230\345\205\210\347\272\247\351\230\237\345\210\227\345\220\210\345\271\266K\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204/MergeK.class"
new file mode 100644
index 0000000000000000000000000000000000000000..2e274e110eb775f68b08bfcd454c05f756b55a29
Binary files /dev/null and "b/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\344\274\230\345\205\210\347\272\247\351\230\237\345\210\227\345\220\210\345\271\266K\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204/MergeK.class" differ
diff --git "a/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\344\274\230\345\205\210\347\272\247\351\230\237\345\210\227\345\220\210\345\271\266K\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204/MergeK.java" "b/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\344\274\230\345\205\210\347\272\247\351\230\237\345\210\227\345\220\210\345\271\266K\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204/MergeK.java"
new file mode 100644
index 0000000000000000000000000000000000000000..3f30982de97f5e84e9accf3a258cc4960da9e5c9
--- /dev/null
+++ "b/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\344\274\230\345\205\210\347\272\247\351\230\237\345\210\227\345\220\210\345\271\266K\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204/MergeK.java"
@@ -0,0 +1,50 @@
+import java.util.Arrays;
+
+public class MergeK {
+    public static int[] merge(int[] arr1, int[] arr2){
+        int length1 = arr1.length;
+        int length2 = arr2.length;
+
+        int[] arr = new int[length1 + length2];
+        int j = 0;
+        int k = 0;
+        int i = 0;
+        while (j < length1 && k < length2){
+            if (arr1[j] <= arr2[k]){
+                arr[i] = arr1[j];
+                i++;
+                j++;
+            }else {
+                arr[i] = arr2[k];
+                i++;
+                k++;
+            }
+        }
+
+        //把还没有进行合并的元素直接添加到新数组的后面
+        while (j < length1){
+            arr[i] = arr1[j];
+            i++;
+            j++;
+        }
+        while (k < length2){
+            arr[i] = arr2[k];
+            i++;
+            k++;
+        }
+
+        return arr;
+    }
+
+    public static void main(String[] args) {
+        int[] arr1 = {1,3,5,6};
+        int[] arr2 = {1,2,5,7};
+        int[] arr3 = {3,6,9,11};
+        int[] arr4 = {5,7,13,17};
+
+        int[] merge1 = merge(arr1, arr2);
+        int[] merge2 = merge(arr3, arr4);
+        int[] merge = merge(merge1, merge2);
+        System.out.println(Arrays.toString(merge));
+    }
+}
diff --git "a/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\345\212\250\346\200\201\346\225\260\346\215\256\351\233\206\345\220\210\347\232\204Top K/TOP_K$Heap.class" "b/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\345\212\250\346\200\201\346\225\260\346\215\256\351\233\206\345\220\210\347\232\204Top K/TOP_K$Heap.class"
new file mode 100644
index 0000000000000000000000000000000000000000..b26628f7f83b8c0afe80579239ba9991299e5e0a
Binary files /dev/null and "b/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\345\212\250\346\200\201\346\225\260\346\215\256\351\233\206\345\220\210\347\232\204Top K/TOP_K$Heap.class" differ
diff --git "a/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\345\212\250\346\200\201\346\225\260\346\215\256\351\233\206\345\220\210\347\232\204Top K/TOP_K.class" "b/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\345\212\250\346\200\201\346\225\260\346\215\256\351\233\206\345\220\210\347\232\204Top K/TOP_K.class"
new file mode 100644
index 0000000000000000000000000000000000000000..95e4e833ba2ba16522e6977ad384c77a774cf0f8
Binary files /dev/null and "b/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\345\212\250\346\200\201\346\225\260\346\215\256\351\233\206\345\220\210\347\232\204Top K/TOP_K.class" differ
diff --git "a/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\345\212\250\346\200\201\346\225\260\346\215\256\351\233\206\345\220\210\347\232\204Top K/TOP_K.java" "b/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\345\212\250\346\200\201\346\225\260\346\215\256\351\233\206\345\220\210\347\232\204Top K/TOP_K.java"
new file mode 100644
index 0000000000000000000000000000000000000000..c7a332bbdc3ad77b9864b44aec6d4727e6fe34e0
--- /dev/null
+++ "b/20200340930_\345\210\230\347\277\224-lec07-heap/\350\277\233\351\230\266\344\275\234\344\270\232/\345\212\250\346\200\201\346\225\260\346\215\256\351\233\206\345\220\210\347\232\204Top K/TOP_K.java"	
@@ -0,0 +1,59 @@
+import java.util.Arrays;
+import java.util.Random;
+
+public class TOP_K {
+    public static void main(String[]args){
+        Heap heap = new Heap(10);
+        Random r = new Random();
+        for (int i = 0;i<10000000;i++){
+            heap.add(r.nextInt(1000000000));
+        };
+        heap.sort();
+        System.out.println(Arrays.toString(heap.heap));
+    }
+    //堆根即arr[0] 两子节点arr[2*0+1],arr[2*0+2], 同理 arr[1]的两子节点 arr[1*2+1],arr[1*2+2] ....
+    //小根堆(arr[i]<arr[2i+1] && arr[i]<arr[2i+2])(父节点小于子节点) 用来实现 TOP K 功能
+    //1.维护一个大小为 K 的堆
+    //2.插入元素时,将大于根的元素放入根的位置,并进行一次交换,保持堆的性质
+    static class Heap{
+        int [] heap;//用来存储数据
+        public Heap(int size){//设置堆大小
+            heap = new int[size];//初始化数组
+        }
+        public void add(int data){//添加元素
+            if (data>heap[0]){//由于是小根堆,判断当前元素是否比最小的大
+                heap[0]=data;//如果大替换为
+                minToRoot(heap.length);//在当前数组大小范围内进行交换
+            }
+        }
+        private void minToRoot(int k){//指定数组下标范围内交换
+            if (k<2) return;
+            for (int i = 0; 2*i+1<k; ){//有子节点
+                //有右节点,且右节点小于左节点 和 父节点
+                if (2*i+2<k && heap[2*i+2]<heap[2*i+1] && heap[2*i+2]<heap[i]){
+                    swap(i,2*i+2);//交换
+                    i = 2*i+2;
+                }else if (heap[2*i+1]<heap[i]){//左节点小于父节点
+                    swap(i,2*i+1);//交换
+                    i = 2*i+1;
+                }else{ //当前节点就是最小的,不用向下进行比较了
+                    break;
+                }
+
+            }
+        }
+        private void swap(int a,int b){//交换数组中两个下标的值
+            int t = heap[a];
+            heap[a] = heap[b];
+            heap[b] = t;
+        }
+        public void  sort(){//堆排序  1.最小值->arr[len-1] 2.排序 3.最小值->arr[len-2] .....
+            int k = heap.length;
+            while (k-1>0){
+                swap(0,k-1);//当前堆根最小 将堆根与(k的范围内)最后的元素交换
+                k--;
+                minToRoot(k);//在下标k的返回内 保持堆性质
+            }
+        }
+    }
+}