diff --git a/10/beom/Heap.md b/10/beom/Heap.md
new file mode 100644
index 0000000..5b08127
--- /dev/null
+++ b/10/beom/Heap.md
@@ -0,0 +1,46 @@
+# Heap
+
+## 자료구조 Heap이란?
+- **완전 이진 트리의 일종**으로 우선순위 큐를 위하여 만들어진 자료구조
+- **여러 개의 값들 중에서 최대값이나 최솟값을 빠르게 찾아내도록 만들어진 자료구조이다.**
+- 힙은 형제노드 간의 우선순위를 고려하지 않고 부모 노드와 자식 노드의 키 값만 고려한다. 이러한 정렬 상태를 **반정렬 상태** 혹은 **느슨한 정렬 상태** 또는 **약한 힙**이라고 불린다.
+- 힙 트리에서는 중복된 값을 허용한다.
+
+## Heap의 종류
+- 최대 힙(max heap)
+  - 부모 노드의 키값이 자식 노드의 키 값보다 크거나 같은 완전 이진 트리
+  - key(부모 노드) >= key(자식 노드)
+- 최소 힙(min heap)
+  - 부모 노드의 키 값이 자삭 노드의 키 값보다 작거나 같은 완전 이진 트리
+  - key(부모 노드) <= key(자식 노드)
+
+![heap](asset/heap.PNG)
+
+## Heap의 구현
+- 힙을 저장하는 표준적인 자료구조는 **배열**이다.
+- 구현을 쉽게 하기 위하여 배열의 첫 번째 인덱스인 0은 사용되지 않는다. = 시작 인덱스(root)는 1부터 시작한다.
+- 특정 위치의 노드 번호(인덱스)는 새로운 노드가 추가되어도 변하지 않는다.(불변)
+  - 예를 들어 루트 노드의 오른쪽 노드의 번호는 항상 3이다.
+- 배열 힙의 성질
+  1. 왼쪽 자식 노드 인덱스 = 부모 노드의 인덱스 * 2
+  2. 오른쪽 자식의 노드 인덱스 = 부모 노드의 인덱스 * 2 + 1
+  3. 부모 노드의 인덱스 = 자식 노드 인덱스 / 2
+![heap구현 예시](asset/heap_index.PNG)
+
+## Heap의 삽입
+1. 힙에 새로운 요소가 들어오면, 일단 새로운 노드를 힙의 마지막 노드에 이어서 삽입힌다.
+2. 새로운 노드를 부모 노드들과 교환해서 힙의 성질을 만족시킨다.
+
+ex) 아래의 최대 힙에 새로운 요소 8을 삽입 해보자
+
+![heap삽입구현 예시](asset/add_heap.PNG)
+
+## Heap의 삭제
+1. 최대 힙에서 최댓값이 루트 노드이므로 루트 노드가 삭제된다.
+   - 최대 힙에서 삭제 연산은 최대값을 가진 요소를 삭제하는 것이다.
+2. 삭제된 루트 노드에서 힙의 마지막 노드를 가져온다.
+3. 힙을 재구성한다.
+
+ex) 아래의 최대 힙에서 최대값을 삭제해보자
+
+![heap삭제구현 예시](asset/delete_heap.PNG)
diff --git a/10/beom/Heap.pptx b/10/beom/Heap.pptx
new file mode 100644
index 0000000..da141cf
Binary files /dev/null and b/10/beom/Heap.pptx differ
diff --git a/10/beom/Leetcode.md b/10/beom/Leetcode.md
new file mode 100644
index 0000000..0ebd4af
--- /dev/null
+++ b/10/beom/Leetcode.md
@@ -0,0 +1,147 @@
+## 목차
+- 506. Relative Ranks
+- 1337. The K Weakest Rows in a Matrix
+
+
+
+
+## 506. Relative Ranks
+### 문제 요약
+score의 수가 가장 높은 순서대로 등수이다.
+
+1등에게는 Gold Medal
+
+2등에게는 Silver Medal
+
+3등에게는 Bronze Medal
+
+4등에게는 4
+
+이런식으로 문자열을 넣어서 반환해라
+
+### 시간 복잡도 공간복잡도
+| time | space |
+|------|-------|
+| O(n log n) | O(1)  |
+
+
+### 코드
+```java
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.PriorityQueue;
+
+class Solution {
+    public String[] findRelativeRanks(int[] score) {
+        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(Collections.reverseOrder());
+
+        for(int i:score){
+            priorityQueue.add(i);
+        }
+
+        HashMap<Integer,String> map = new HashMap<>();
+        int index =1;
+        while(!priorityQueue.isEmpty()){
+            if(index==1){
+                map.put(priorityQueue.poll(),"Gold Medal");
+            }else if(index ==2){
+                map.put(priorityQueue.poll(),"Silver Medal");
+            } else if (index == 3) {
+                map.put(priorityQueue.poll(),"Bronze Medal");
+            }else{
+                map.put(priorityQueue.poll(),Integer.toString(index));
+            }
+            index++;
+        }
+        
+        String[] result = new String[score.length];
+        for(int i=0;i< score.length;i++){
+            result[i] = map.get(score[i]);
+        }
+        return result;
+    }
+}
+```
+
+
+
+## 1337. The K Weakest Rows in a Matrix
+### 문제 요약
+2차원 배열에서 1은 군인이고 0은 사람이다. 군인은 가장 앞에 있어야 한다.
+
+군인이 가장 적은 배열이 있는 인덱스를 반환하자.
+
+k개 까지만 인덱스를 반환하면 된다.
+
+### 시간 복잡도 공간복잡도
+| time | space |
+|------|-------|
+| O(n^2) | O(1)  |
+
+
+### 내가 푼 코드(틀림)
+
+> 해당 코드는 key값을 배열에 넣어야하는데 value값으로 ke값을 조회해야하는 문제로 막힘....
+
+
+```java
+import java.util.HashMap;
+import java.util.PriorityQueue;
+
+class Solution {
+    public int[] kWeakestRows(int[][] mat, int k) {
+        HashMap<Integer, Integer> map = new HashMap<>();
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        int total =0;
+        int[] result = new int[k];
+
+        for(int i=0;i<mat.length;i++){
+            for(int j=0;j<mat[i].length;j++){
+                total += mat[i][j];
+            }
+            map.put(i,total);
+            total = 0;
+        }
+
+        for(int i : map.keySet()){
+            pq.add(map.get(i));
+
+        }
+
+        for(int i=0;i<k;i++){
+            int a = pq.remove();
+            result[i] = map.get(a);
+        }
+        return result;
+    }
+}
+```
+
+### 다른 사람의 잘푼 코드
+```java
+public int[] kWeakestRows(int[][] mat, int k) {
+        
+        Queue<Integer> queue = new PriorityQueue<>();
+            
+        int count = 0;
+        for(int i=0;i<mat.length;i++){
+            count = 0;
+            for(;count<mat[0].length;count++){
+                if(mat[i][count] == 0){
+                    break;
+                }
+            }
+            
+			//since max length of array is 100
+            queue.add(count * 100000 + i);
+        }
+        
+        int[] ans = new int[k];
+        
+        for(int i=0;i<k;i++){
+            ans[i] = queue.remove() % 100000;
+        }
+        
+        return ans;
+    }
+```
diff --git a/10/beom/Priority_Queue.md b/10/beom/Priority_Queue.md
new file mode 100644
index 0000000..af46e3d
--- /dev/null
+++ b/10/beom/Priority_Queue.md
@@ -0,0 +1,52 @@
+# Priority Queue
+
+## Priority Queue의 정의
+- 먼저 들어온 순서대로 나가는 것이 아닌 우선순위를 먼저 결정하고 그 순위가 높은 엘리먼트가 먼저 나가는 자료구조
+- array, LinkedList, Heap으로 구현이 가능하나 Heap으로 구현하는 것이 일반적이다.
+- 내부 구조가 힙으로 구성되어 이진트리 구조를 가진다.
+- 삽입 시 -> 마지막 노드에 삽입 후 부모 노드와 비교하여 Swap
+- 삭제 시 -> 우선 순위가 가장 높은 루트 노드를 삭제 후 마지막 노드를 루트 노드에 올린 후 자식 노드들과 비교하며 Swap
+
+## JAVA PriorityQueue 클래스 특징
+- null 값을 허용하지 않는다.
+- 비교할 수 없는 객체를 허용하지 않는다.
+- Threa-safe 하지 않는다.
+  - 멀티스레드 환경에서는 Prioriy Blocking Queue를 사용하면 된다.
+- iterator() 메소드로 순회했을 때 순서를 보장하지 않는다.
+- DEFAULT_INITINAL_CAPACITY = 11 이다.(기본 초기 용량)
+
+
+## Priority Queue의 시간복잡도
+| offer | peek | poll | size |
+|------|-------|---|---|
+| O(log n) | O(1)  | O(log n)  | O(1)  |
+
+
+## LinkedList Queue vs Priority Queue
+자바에서 Queue를 구현할 경우에 LinkedList를 사용하여 구현할 수 있고 Priority Queue를 사용하여 구현할 수 있다.
+
+> 여기서 큐는 FIFO 방식의 자료구조이다.</br>
+> 그래프의 넓이 우선 탐색(BFS)에서 사용된다.
+
+**< LinkedList 구현 특징 >**
+
+- add             : O(1)
+- remove          : O(1)
+- get             : O(n)
+- Contains        : O(n)
+- iterator.remove : O(1)
+- java 1.2에 추가, thread-safe 보장 안함
+- 특징 : 데이터를 저장하는 각 노드가 이전 노드와 다음 노드의 상태만 알고 있다.
+   - 데이터 추가/삭제시 빠름
+   - 데이터 검색시 처음부터 노드를 순화해야 되기 때문에 느림
+
+**< priorityQueue 구현 특징 >**
+
+- offer(입력)   : O(log n)
+- peek(get)     : O(1)
+- poll(반환)    : O(log n)
+- size          : O(1)
+- natural order : JVM에서 제공하는 일반적인거와 다를수 있음 순서 ex) 문자는 ASCII 순서로 정렬
+- java 1.5 에서 나옴
+- 특징 : 일반적은 큐는 FIFO의 구조를 가지지만 자연 네추럴 오더에 따라 정렬
+  - Null을 허용하지 않는다.
\ No newline at end of file
diff --git a/10/beom/asset/add_heap.PNG b/10/beom/asset/add_heap.PNG
new file mode 100644
index 0000000..54f2020
Binary files /dev/null and b/10/beom/asset/add_heap.PNG differ
diff --git a/10/beom/asset/delete_heap.PNG b/10/beom/asset/delete_heap.PNG
new file mode 100644
index 0000000..bd7e108
Binary files /dev/null and b/10/beom/asset/delete_heap.PNG differ
diff --git a/10/beom/asset/heap.PNG b/10/beom/asset/heap.PNG
new file mode 100644
index 0000000..4e4a1ec
Binary files /dev/null and b/10/beom/asset/heap.PNG differ
diff --git a/10/beom/asset/heap_index.PNG b/10/beom/asset/heap_index.PNG
new file mode 100644
index 0000000..8227a1e
Binary files /dev/null and b/10/beom/asset/heap_index.PNG differ