diff --git a/13/JiYongKim/binarySearch.md b/13/JiYongKim/binarySearch.md
new file mode 100644
index 00000000..87ff51fb
--- /dev/null
+++ b/13/JiYongKim/binarySearch.md
@@ -0,0 +1,93 @@
+## 탐색 알고리즘의 종류
+
+- 선형 탐색
+- 이진 탐색
+- 해시
+
+
+
+## 선형 탐색(Linear Search) 알고리즘
+
+- 정의 : 배열 전체를 하나씩 확인해 가며 탐색하는 알고리즘
+- 시간 복잡도 : O(n)
+- 특징
+ - 모든 데이터 타입에 사용 가능 (문자열, 숫자,…etc)
+ - 데이터의 양 n만큼의 저장 공간이 필요
+
+
+
+## 이진 탐색 (Binary Search) 알고리즘
+
+- 정의 : 전체 배열의 중앙을 비교하여 찾으려 하는 값이 작으면 왼쪽 크면 오른쪽 에서 부터 다시 탐색하는 방법으로 , 탐색양을 절반씩 줄여가며 찾는 탐색 알고리즘
+- 시간 복잡도 : O(log n)
+
+
+
+- 특징
+ - 전제 조건
+ - 정렬이 미리 되어있어야 한다
+ - 입력시마다 재정렬을 필요로 한다
+ - 데이터의 비교가 가능해야 한다.
+ - [ 출력 < 입력 ]의 상황시 입력시 마다 재정렬을 해야하기 때문에 느려질 수 있다.
+ - 분할 정복 기법 중 하나이다.
+
+
+
+ ```java
+ public class BinarySearch {
+ public static void main(String[] args) {
+ int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+ binarySearch(2, arr);
+ }
+
+ public static void binarySearch(int iKey, int arr[]) {
+ int mid;
+ int left = 0;
+ int right = arr.length - 1;
+
+ while (right >= left) {
+ mid = (right + left) / 2;
+
+ if (iKey == arr[mid]) {
+ System.out.println(iKey + " is in the array with index value: " + mid);
+ break;
+ }
+
+ if (iKey < arr[mid]) {
+ right = mid - 1;
+ } else {
+ left = mid + 1;
+ }
+
+ }
+ }
+ }
+
+ ```
+
+
+
+## 해시
+
+- 정의 : 해싱함수를 통해 얻은 해시값을 저장 위치로 삼아 데이터를 탐색하는 방법
+- 시간 복잡도 : O(1)
+- 특징
+ - HashMap or HashTable 사용
+ - 모든 데이터에 사용이 가능하다
+ - 해시 충돌의 수를 줄이기 위하여 데이터 n 이상의 저장 공간이 필요하다
+ - 해시 충돌이 일어날 경우
+ - 해시충돌을 어떻게 예방 하느냐에 따라 시간복잡도가 변경될 수 있다
+
+ ⇒ 대부분 느려진다라고 할 수 있다.
+
+
+---
+
+
+
+## Search Algorithm 정리
+
+- [ 데이터 삽입 < 데이터 탐색 ] → 이진 탐색이 유리
+- [ 데이터 삽입 > 데이터 탐색 ] → 선형 탐색이 유리
+- 데이터를 저장할 용량이 커도 좋다 → 해시
\ No newline at end of file
diff --git a/13/JiYongKim/leetcode.md b/13/JiYongKim/leetcode.md
new file mode 100644
index 00000000..a3710c1c
--- /dev/null
+++ b/13/JiYongKim/leetcode.md
@@ -0,0 +1,273 @@
+# Binary Search
+
+
+704. Binary Search
+
+- 704. Binary Search
+
+ ```java
+ // 시간 복잡도 : O(log(n)) ... n = nums.length
+ // 공간 복잡도 : O(1)
+ class Solution {
+ public int search(int[] nums, int target) {
+ int result = binarySearch(target, nums);
+ if (nums[result] == target) {
+ return result;
+ }
+ return -1;
+ }
+ public static int binarySearch(int key, int arr[]) {
+ int mid = 0;
+ int left = 0;
+ int right = arr.length - 1;
+
+ while (right >= left) {
+ mid = (right + left) / 2;
+
+ if (key == arr[mid]) {
+ return mid;
+ }
+ if (key < arr[mid]) {
+ right = mid - 1;
+ } else {
+ left = mid + 1;
+ }
+ }
+ return mid;
+ }
+ }
+ ```
+
+
+
+
+
+~~[35. Search Insert Position](https://leetcode.com/problems/search-insert-position/)~~
+
+
+
+
+349. Intersection of Two Arrays
+
+- 349. Intersection of Two Arrays
+
+ ```java
+ // 시간 복잡도 : O( m^2 + n log(m) ) ... m = nums2.length , n = nums1.length
+ // 공간 복잡도 : O( n + m ) ... m = nums1의 set값 변환 값 수 , n = nums1,nums2 중복 값 수
+ class Solution {
+ public int[] intersection(int[] nums1, int[] nums2) {
+ List result = new ArrayList<>();
+
+ Set set = new HashSet<>();
+ for (int i = 0; i < nums1.length; i++) {
+ set.add(nums1[i]);
+ }
+
+ Arrays.sort(nums2);
+
+ for (int i : set) {
+ if(binarySearch(i ,nums2))
+ result.add(i);
+ }
+
+ return result.stream().mapToInt(
+ Integer::intValue).toArray();
+ }
+ public static Boolean binarySearch(int key, int arr[]) {
+ int mid;
+ int left = 0;
+ int right = arr.length -1;
+
+ while(right >= left){
+ mid = (right + left) / 2;
+
+ if (key == arr[mid]) {
+ return true;
+ }
+
+ if(key < arr[mid]){
+ right = mid - 1;
+ }else{
+ left = mid + 1;
+ }
+ }
+ return false;
+ }
+
+ }
+ ```
+
+
+
+
+
+350. Intersection of Two Arrays II
+
+- 350. Intersection of Two Arrays II
+
+ ```java
+ // 시간 복잡도 : O( m^2 + n log(m) ) ... m = nums2.length , n = nums1.length
+ // 공간 복잡도 : O( n ) .... n = nums1 과 nums2의 중복값 갯수
+ class Solution {
+ public int[] intersect(int[] nums1, int[] nums2) {
+
+ List list = new ArrayList<>();
+
+ Arrays.sort(nums2);
+
+ for (int i = 0; i < nums1.length; i++) {
+ if(binarySearch(nums1[i],nums2)){
+ list.add(nums1[i]);
+ Arrays.sort(nums2);
+ }
+ }
+
+ return list.stream().mapToInt(
+ Integer::intValue).toArray();;
+
+ }
+
+ public static Boolean binarySearch(int key, int arr[]) {
+ int mid;
+ int left = 0;
+ int right = arr.length -1;
+
+ while(right >= left){
+ mid = (right + left) / 2;
+
+ if (key == arr[mid]) {
+ arr[mid] = -1;
+ return true;
+ }
+
+ if(key < arr[mid]){
+ right = mid - 1;
+ }else{
+ left = mid + 1;
+ }
+ }
+ return false;
+ }
+ }
+ ```
+
+
+
+
+
+1346. Check If N and Its Double Exist
+
+- 1346. Check If N and Its Double Exist
+
+ ```java
+ // 시간 복잡도 : O(n^2 + n +log(n) ) ... n = arr.length
+ // 공간 복잡도 : O(1)
+ class Solution {
+ public boolean checkIfExist(int[] arr) {
+
+ Arrays.sort(arr); // n^2
+ for (int i = 0; i < arr.length; i++) { //n
+ if(arr[i] == 0){
+ if(arr[i+1] == 0){
+ return true;
+ }
+ continue;
+ }
+
+ if (arr[i] % 2 == 0) {
+ if(binarySearch(arr[i]/2,arr)){ //log n
+ return true;
+ }
+ }
+
+ }
+ return false;
+
+ }
+ public static Boolean binarySearch(int key, int arr[]) {
+ int mid;
+ int left = 0;
+ int right = arr.length -1;
+
+ while(right >= left){
+ mid = (right + left) / 2;
+
+ if (key == arr[mid]) {
+ return true;
+ }
+
+ if(key < arr[mid]){
+ right = mid - 1;
+ }else{
+ left = mid + 1;
+ }
+ }
+ return false;
+ }
+ }
+ ```
+
+
+
+
+
+1608. Special Array With X Elements Greater Than or Equal X
+
+- 1608. Special Array With X Elements Greater Than or Equal X
+
+ ```java
+ //시간 복잡도 : O(n^2 - n) ... n = nums.length
+ //공간 복잡도 : O(1)
+ class Solution {
+ public int specialArray(int[] nums) {
+
+ int n = nums.length;
+ int result = -1;
+
+ for(int i=1; i<=n; i++){
+ int count = 0;
+ for(int j=0; j= i){
+ count++;
+ }
+ }
+ if(count == i){
+ return count;
+ }
+ }
+
+ return result;
+ }
+ }
+ ```
+
+
+
+
+
+2089. Find Target Indices After Sorting Array
+
+- 2089. Find Target Indices After Sorting Array
+ ```java
+ //시간 복잡도 : O(n^2 + n) ... n = nums.length
+ //공간 복잡도 : O(n) ... n = result.length
+ class Solution {
+ public List targetIndices(int[] nums, int target) {
+
+ List result = new ArrayList<>();
+ Arrays.sort(nums);
+
+ for (int i = 0; i < nums.length; i++) {
+ if (nums[i] == target) {
+ result.add(i);
+ }
+ }
+
+
+ return result;
+
+ }
+ }
+ ```
+
+