diff --git a/src/Heap.java b/src/Heap.java
new file mode 100644
index 0000000000000000000000000000000000000000..e564cdfb55149d9e24ed52b93f78f00b99b655b9
--- /dev/null
+++ b/src/Heap.java
@@ -0,0 +1,117 @@
+import java.util.Arrays;
+
+public class Heap {
+    private int capacity;//设置一个当前容量的带下
+    private int size =0;
+    private int[] array;
+
+
+    //容量
+    public Heap(int capacity){
+        this.capacity = capacity;
+        this.array = new int[capacity];
+    }
+
+    //获取右节点索引的值
+    private int getRightChildIndex(int parentIndex){
+        return 2* parentIndex +2;
+    }
+    //获取左节点索引的值
+    private int getLeftChildIndex(int parentIndex){
+        return 2*parentIndex +1;
+    }
+    //获取父节点索引的值
+    private int getParentIndex(int chilIndex){
+        return (chilIndex -1)/2;
+    }
+    //有没有左子树
+    private boolean hashLeftChild(int index){
+        return getLeftChildIndex(index) < size;
+    }
+    //有没有右子树
+    private boolean hashRighttChild(int index){
+        return getRightChildIndex(index) < size;
+    }
+    //有没有根节点
+    private boolean hashParent(int index){
+        return getParentIndex(index)>=0;
+    }
+
+    //取左节点的值
+    private int leftChild(int parentIndex){
+        return array[getLeftChildIndex(parentIndex)];
+    }
+
+
+    //取右节点的值
+    private int RightChild(int parentIndex){
+        return array[getRightChildIndex(parentIndex)];
+    }
+
+
+    //取父节点的值
+    private int parent(int childIndex){
+        return array[getLeftChildIndex(childIndex)];
+    }
+    //交换函数
+    private void swap(int index1,int index2){
+        int temp = array[index1];
+        array[index1] = array[index2];
+        array[index2] = temp;
+    }
+
+    //插入
+    public void add(int item){
+        if (size == capacity){
+            array = Arrays.copyOf(array,capacity*2);
+            capacity = capacity*2;
+        }
+        array[size] = item;//将要插入的值插入在数组的最后一个
+        size++;
+        heapify();//将要插入的值插入到父节点
+    }
+    private void heapify(){
+        int index = size -1;//索引是最小的放在最右一个
+        while (hashParent(index) && parent(index) <array[index])
+            /*有没有父节点*/       /*当前值放在完全二叉树的最左叶子结点，与他的父节点判断*/
+        {
+            /*如果父节点比他小的话就进行交换*/
+                 swap(getParentIndex(index),index);
+            index = getParentIndex(index);
+
+            //把当前比父节点大的节点与父节点交换
+        }
+    }
+    //去跟节点
+    public void poll(){
+        if(size==0){
+            System.out.println("没有节点");
+        }
+        int element = array[0];   //element是跟节点，就是最大值
+        size--;
+        heapifDown();
+    }
+    public void heapifDown(){
+        int index = 0;
+        while (hashLeftChild(index)){
+            int largeChildIndex = getLeftChildIndex(index);
+            if(hashRighttChild(index)&&RightChild(index) > leftChild(index)){//有没有右节点，右节点的值大于左节点的值
+                 largeChildIndex = RightChild(index);  //当前最大的值就是右子树
+            }
+            //上面那一步只是选择左右孩子那个值大
+            if(array[index] < array [largeChildIndex]){
+                swap(index,largeChildIndex);
+            }else{
+                break;
+            }
+            index = largeChildIndex;//坐标再更新一下
+        }
+    }
+
+    public void printHeap(){
+        for(int i = 0;i<size;i++){
+            System.out.println(array[i]);
+        }
+        System.out.println();
+    }
+}
diff --git a/src/HeapMain.java b/src/HeapMain.java
new file mode 100644
index 0000000000000000000000000000000000000000..8da00e3e598f70a615d725197d3148a1771b470e
--- /dev/null
+++ b/src/HeapMain.java
@@ -0,0 +1,10 @@
+public class HeapMain {
+    public static void main(String[] args) {
+        Heap maxHeap = new Heap(10);
+        maxHeap.add(15);
+        maxHeap.add(11);
+        maxHeap.add(7);
+        maxHeap.add(5);
+        maxHeap.printHeap();
+    }
+}
diff --git a/src/PriorityQueue.java b/src/PriorityQueue.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6a797feed3c8d1465edc09ff2b1ea117e01694d
--- /dev/null
+++ b/src/PriorityQueue.java
@@ -0,0 +1,56 @@
+//优先队列
+
+
+public class PriorityQueue {
+    static class Node{
+        int value;
+        int priority;   //优先级，数值越大优先级越高
+        Node next;
+
+        public Node(int value,int priority){
+            this.value = value;
+            this.priority = priority;
+        }
+    }
+    Node head = null;
+
+    //head永远指向最小的
+    public void insert(int value,int priorty){
+        if(head ==null){
+            head = new Node(value,priorty);
+            return;
+        }
+        Node cur = head;//创建一个当前的节点
+        Node newNode = new Node(value,priorty);
+        if (head.priority < priorty){
+            newNode.next = head;
+            this.head = newNode;
+        }else {//如果插入的优先级比head指向的那个节点小的话，要先与与前面的节点比较优先级
+            while (cur.next !=null&&cur.next.priority > priorty){
+                cur = cur.next;
+            }
+            newNode.next = cur.next;  //当前节点的下一个节指向新节点
+            cur.next = newNode;
+        }
+    }
+
+    public Node peek(){
+        return head;
+    }
+
+    public Node deleteMin(){
+        if(head ==null){
+            return null;
+        }
+        Node temp = head;
+        head = head.next;
+        return temp;
+    }
+
+    public static void main(String[] args) {
+        PriorityQueue priorityQueue = new PriorityQueue();
+        priorityQueue.insert(5,1);
+        priorityQueue.insert(5,5);
+        priorityQueue.insert(5,3);
+    }
+}
diff --git a/src/Sort.java b/src/Sort.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a30a38895eeaa38308204279db4aa91ec1eca31
--- /dev/null
+++ b/src/Sort.java
@@ -0,0 +1,47 @@
+import java.util.Arrays;
+
+public class Sort {
+
+        public static void main(String []args){
+            int []arr = {30,10,4,25,8,5,19,7,16};
+            sort(arr);
+            System.out.println(Arrays.toString(arr));
+        }
+        public static void sort(int []arr){
+
+            for(int i=arr.length/2-1;i>=0;i--){
+                //从第一个非叶子结点从下至上，从右至左调整结构
+                adjustHeap(arr,i,arr.length);
+            }
+            //调整堆结构+交换堆顶元素与末尾元素
+            for(int j=arr.length-1;j>0;j--){
+                swap(arr,0,j);//将堆顶元素与末尾元素进行交换
+                adjustHeap(arr,0,j);//重新对堆进行调整
+            }
+
+        }
+
+
+        public static void adjustHeap(int []arr,int i,int length){
+            int temp = arr[i];//先取出当前元素i
+            for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
+                if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
+                    k++;
+                }
+                if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
+                    arr[i] = arr[k];
+                    i = k;
+                }else{
+                    break;
+                }
+            }
+            arr[i] = temp;//将temp值放到最终的位置
+        }
+
+        public static void swap(int []arr,int a ,int b){
+            int temp=arr[a];
+            arr[a] = arr[b];
+            arr[b] = temp;
+        }
+    }
+