diff --git "a/DataStructure/\352\267\270\353\236\230\355\224\204/\352\267\270\353\236\230\355\224\204_\354\230\210\354\247\200.md" "b/DataStructure/\352\267\270\353\236\230\355\224\204/\352\267\270\353\236\230\355\224\204_\354\230\210\354\247\200.md"
new file mode 100644
index 0000000..42636c1
--- /dev/null
+++ "b/DataStructure/\352\267\270\353\236\230\355\224\204/\352\267\270\353\236\230\355\224\204_\354\230\210\354\247\200.md"
@@ -0,0 +1,157 @@
+## 📖 학습 주제
+
+- **주제**: 그래프
+- **날짜**: 2024.10.21 - 2024.10.27
+
+---
+
+## 📌 학습 내용 요약
+
+### [그래프]
+
+- `그래프`: 정점이라 불리는 데이터를 간선 혹은 링크로 연결한 형태의 자료구조
+  - 트리와의 차이점
+    - 트리는 사이클을 형성하지 않고 연결된 노드 간에 상하 관계를 가짐
+    - 그래프는 사이클을 형성할 수 있고, 정점끼리 상하 관계를 갖지 않음
+  - 그래프의 유형
+    - `연결/비연결 그래프`
+    - `방향/무방향 그래프`
+    - `가중치 그래프`
+    - `서브그래프`
+
+---
+
+### 그래프의 유형
+
+- `연결 그래프` : 그래프 상에 있는 임의의 두 정점 사이의 경로가 존재하는 그래프
+  - 2개의 아무 정점이나 골라 간선으로 이을 수 있으면 `연결 그래프`
+- `비연결 그래프` : 어떤 정점 사이에는 경로가 존재하지 않을 수도 있는 그래프
+
+  ![](https://velog.velcdn.com/images/yjlee0006/post/bc18eb16-75ba-40a8-bada-08ddf4d1ccce/image.png)
+
+- `방향그래프` : 간선에 방향이 있는 그래프
+- `무방향그래프` : 간선에 방향이 없는 그래프
+
+![](https://velog.velcdn.com/images/yjlee0006/post/bc2e8585-5aa1-497a-884c-3675e47632aa/image.png)
+
+- `가중치 그래프` : 간선에 가중치가 부여된 그래프
+  - 간선에 부여된 값 = 가중치 = 비용
+
+![](https://velog.velcdn.com/images/yjlee0006/post/a6aa0a61-6602-403a-987b-3e1ca9d7b416/image.png)
+
+- `서브 그래프` : 특정 그래프의 정점과 간선의 일부분으로 이루어진 그래프
+
+![](https://velog.velcdn.com/images/yjlee0006/post/2406e7ab-5836-43a9-b2fe-11c7be1d60d3/image.png)
+
+---
+
+### 그래프의 표현
+
+- **인접 행렬 기반 그래프 표현** : N x N 크기의 행렬로 그래프를 표현하는 방법
+
+  - N은 정점의 개수
+  - <행, 열> 값은 <출발정점, 도착정점>
+
+- **인접 리스트 기반 그래프 표현** : 그래프의 특정 정점과 연결된 정점들을 연결 리스트로 표현하는 방법
+
+![](https://velog.velcdn.com/images/yjlee0006/post/05b047c7-8d77-4451-9f29-e6b93bc193fd/image.png)
+
+---
+
+### 탐색 알고리즘
+
+-**깊이 우선 탐색(DFS)** : 더 이상 방문 가능한 정점이 없을 때까지 최대한 깊이 탐색하기를 반복하는 탐색방법
+
+![](https://velog.velcdn.com/images/yjlee0006/post/d459f4c0-998c-4b3e-b455-89cd56ce0667/image.png)
+
+- **너비 우선 탐색(BFS)** : 최대한 넓게 탐색하기를 반복하는 방법, 인접한 모든 정점들을 방문하고, 방문한 정점들과 연결된 모든 정점을 방문, 방문한 정점들과 연결된 모든 정점들을 방문하기를 반복하는 탐색 방법
+
+- DFS -> 배열 / 스택 사용
+  - 배열 : 특정정점의 방문 여부 확인
+  - 스택 : 방문 중 뒤로가기가 필요한 경우
+- BFS -> 배열 / 큐 사용
+
+  - 배열 : 특정정점의 방문 여부 확인
+  - 큐 : 연결된 정점들을 저장하기 위해 사용
+
+### 최단 경로 알고리즘
+
+- 한 정점에서 목적지 정점까지이르는 가중치의 합이 최소가 되는 경로
+
+  - 활용
+
+    - 지도 서비스(목적지까지 이르는 최단거리)
+
+  - 종류
+    - **다익스트라 알고리즘** : 가중치가 음이 아닌 수라는 가정하에 사용가능. 특정 정점에서 다른 모든 정점까지의 최단 거리를 구해 주는 알고리즘.
+
+---
+
+## 📈 추가 학습 필요
+
+알고리즘 구현에 자주 나오는 DFS에 대해 조금 더 자세히 공부해 보았다.
+
+### DFS
+
+- **장점**
+  - 현 경로상의 노드들만 기억하면 되므로 저장공간 수요가 비교적 적다.
+  - 목표 노드가 깊은 단계에 있을 경우 해를 빨리 구할 수 있다.
+
+<br>
+
+- **단점**
+  - 해가 없는 경로가 깊을 경우 탐색시간이 오래 걸릴 수 있다.
+  - 얻어진 해가 최단 경로가 된다는 보장이 없다.
+  - 깊이가 무한히 깊어지면 스택오버플로우가 날 위험이 있다. (깊이 제한을 두는 방법으로 해결가능)
+
+<br>
+
+- DFS의 구현
+
+  - 방법에 따른 구현 차이
+
+    - 인접 행렬로 구현
+
+    ```python
+    def dfs(now, adjacent, visited):
+    visited[now] = True
+    N = len(adjacent)
+
+    for i in range(N):
+        if adjacent[now][i] == 0:
+            continue
+
+        if not visited[i]:
+            dfs(i, adjacent, visited)
+
+    # 사용 예시
+    # adjacent = [[0, 1, 0], [1, 0, 1], [0, 1, 0]]  # 인접 행렬 예시
+    # visited = [False] * len(adjacent)  # 방문 여부 리스트 초기화
+    # dfs(0, adjacent, visited)  # 정점 0에서 DFS 시작
+    ```
+
+    > DFS 하나당 N번의 loop를 돌게 되므로 O(n)의 시간복잡도를 가진다. 그런데 N개의 정점을 모두 방문 해야하므로 n\*O(n)이므로 O(n^2)의 시간복잡도를 가지게 된다.
+
+    - 인접 리스트로 구현
+
+    ```python
+    def dfs(now, adjacent, visited):
+    visited[now] = True
+
+    for next in adjacent[now]:
+        if not visited[next]:
+            dfs(next, adjacent, visited)
+
+    # 사용 예시
+    # adjacent = [[1, 2], [0, 2], [0, 1]]  # 인접 리스트 예시
+    # visited = [False] * len(adjacent)  # 방문 여부 리스트 초기화
+    # dfs(0, adjacent, visited)  # 정점 0에서 DFS 시작
+    ```
+
+    > DFS가 총 N번 호출되긴 인접 리스트로 구현하게 되면 DFS하나당 각 정점에 연결되어 있는 간선의 개수만큼 탐색을 하게 되므로 예측이 불가능 하다. 모든 정점을 한번씩 다 방문하고, 모든 간선을 한번씩 모두 검사했다고 할 수 있으므로 O(n+e)의 시간 복잡도를 가지게 된다.
+
+---
+
+## 💡 참고 자료
+
+- https://currygamedev.tistory.com/10
diff --git "a/DataStructure/\353\260\260\354\227\264\352\263\274 \354\227\260\352\262\260 \353\246\254\354\212\244\355\212\270/\353\260\260\354\227\264\352\263\274 \354\227\260\352\262\260 \353\246\254\354\212\244\355\212\270_\354\230\210\354\247\200.md" "b/DataStructure/\353\260\260\354\227\264\352\263\274 \354\227\260\352\262\260 \353\246\254\354\212\244\355\212\270/\353\260\260\354\227\264\352\263\274 \354\227\260\352\262\260 \353\246\254\354\212\244\355\212\270_\354\230\210\354\247\200.md"
new file mode 100644
index 0000000..e79a58b
--- /dev/null
+++ "b/DataStructure/\353\260\260\354\227\264\352\263\274 \354\227\260\352\262\260 \353\246\254\354\212\244\355\212\270/\353\260\260\354\227\264\352\263\274 \354\227\260\352\262\260 \353\246\254\354\212\244\355\212\270_\354\230\210\354\247\200.md"	
@@ -0,0 +1,110 @@
+## 📖 학습 주제
+
+- **주제**: 배열과 연결리스트
+- **날짜**: 2024.10.21 - 2024.10.27
+
+---
+
+## 📌 학습 내용 요약
+
+### <span style='background-color: #ede6b1'>[배열]</span>
+- **`배열(array)`** : 일정한 메모리 공간을 차지하는 여러 요소들이 순차적으로 나열된 자료구조
+  - 배열의 종류 
+    - 일차원 배열 : 한 쪽 방향으로 요소가 나열
+    - 이차원 배열 : 배열 속에 배열이 포함된 경우
+    - 삼차원 배열 : 배열 속에 배열 속에 배열이 포함된 경우
+    - 정적 배열 : 프로그램을 실행하기 전에 크기가 고정되어 있는 배열
+    - 동적 배열 : 실행 과정에서 크기가 변할 수 있는 배열
+  - 활용도
+    - 관련 있는 데이터를 일렬로 나열하여 관리하고자 할 때
+    - 다른 자료구조나 알고리즘을 구현하고자 할 때
+
+<br>
+
+- **`인덱스(index)`** : 0부터 시작하는 고유한 순서 번호
+  - 빅 오 표기법으로 표현
+    - 인덱스를 바탕으로 배열의 특정요소에 접근/수정하는 시간 : **`O(1)`**
+    - 앞에서 부터 차례대로 특정 요소가 있는지 찾는 연산 : **`O(n)`**
+    -> 요소의 갯수와 무관하게 일정하다.
+    - 특정 요소를 추가하거나 삭제하는 경우 : **`O(n)`**
+    -> 추가 혹은 삭제된 요소로 인해 이후의 요소들이 이동되어야 하기 때문!
+
+---
+
+### <span style='background-color: #ede6b1'>[연결 리스트]</span>
+- **`연결 리스트(linked list)`** : 노드의 모음으로 구성된 자료구조
+  - 연결 리스트의 특징 : 모든 노드는 반드시 메모리 내에 순차적으로 저장되어 있을 필요 X 
+-> 연속적으로 구성되어 있는 데이터를 불연속적으로 저장할 떄 유용
+  - 연결 리스트의 종류
+    - `싱글 연결 리스트` : 노드 내 다음 노드의 위치 정보가 저장되어 한쪽 방향으로 꼬리를 무는 형태(데이터 + 다음노드)
+      - 단점 : 다음노드의 위치만 알 수 있으며, 이전노드의 위치는 알기 어려움
+    - `이중 연결 리스트` : 이전노드 + 데이터 + 다음노드
+      - 장점 : 양방향 탐색이 가능함
+      - 단점 : 저장공간이 더 필요함, 한 노드에 2개의 위치정보를 저장해야하기 때문
+      <img src = https://velog.velcdn.com/images/yjlee0006/post/16491f65-620a-4277-8d49-97ed167172a7/image.png width="600" height="100">
+    - `환형 연결 리스트(원형 연결 리스트)` : 꼬리노드가 헤드노드를 가리켜 노드들이 원형으로 구성된 연결리스트
+    - `이중 연결리스트 + 환형 연결 리스트` : 헤드노드의 이전 노드가 꼬리노드 가리킴/ 꼬리노드의 다음노드가 헤드노드를 가리킴
+      - 장점 : 모든 노드데이터를 여러 차례 순회해야할 때 유용하게 활용할 수 있음
+      <img src = https://velog.velcdn.com/images/yjlee0006/post/4fd7335c-61d1-4ee0-a8c2-e5c2dafacbcd/image.png width="600" height="100">
+    
+<br>
+
+- **`노드(node)`** : 저장하고자 하는 데이터와 다음 노드의 위치(메모리 상의 주소) 정보를 포함하는 연결 리스트의 구성 단위
+<img src="https://velog.velcdn.com/images/yjlee0006/post/6286213c-791e-45e5-986a-719ccfb7bb1c/image.png" width="200" height="100">
+
+  - 연결리스트의 형태
+    - `헤드(head)` : 연결리스트의 첫 번째 노드
+    - `꼬리(tail)` : 연결리스트의 마지막 노드
+
+<br>
+
+- 빅 오 표현법으로 표현
+  - 데이터가 몇 번째 노드에 있는지 알고, 특정 요소에 접근할 때 : **`O(n)`**
+  -> 앞에서부터 순차적으로 접근할 수 밖에 없기 때문
+  
+  <img src = "https://velog.velcdn.com/images/yjlee0006/post/16e4e8d9-c187-4702-afdc-b555be658ee4/image.png" width="600" height = "100">
+
+  - 중간에 요소를 추가하거나 삭제할 때 : **`O(1)`**
+  -> 노드의 위치만 바꿔서 저장, 재정렬이 불필요하기 때문
+  -> 삽입/삭제할 위치만 주어지면 노드에 접근하는 시간이 동일
+
+  <img src = "https://velog.velcdn.com/images/yjlee0006/post/1dac9a1a-aded-46bf-a1c6-087a7aff9d79/image.png" width="600" height = "300">
+
+
+
+---
+
+## 📈 추가 학습 필요
+연결리스트와 배열을 어떤 상황에서 사용해야하는지, 그리고 각각 사용했을 때의 장점과 단점을 잘 모르겠다.
+
+### [연결 리스트]
+  - 👍 효율적인 상황
+    - 데이터의 동적 추가/삭제가 필요한 경우. 재정렬이 필요없기 때문.
+  - 👎🏻 비효율적인 상황
+    - **데이터 검색에 비효율적**
+    -> 특정 위치의 노드를 검색하기 위해서 처음부터 차례대로 접근해야하기 때문
+    - **메모리 오버헤드가 발생할 수 있다.**
+    -> 각 노드는 데이터 필드와 함께 메모리 주소 필드(링크필드)를 가지고 있어야 한다. 이 링크 필드는 추가적인 메모리를 사용하므로, 연결 리스트는 배열에 비해 메모리 오버헤드가 크다고 볼 수 있다.
+    - **역방향 탐색의 어려움**
+    -> 이중 연결 리스트를 통해 해소할 수 있지만, 또다른 메모리 오버헤드를 발생시킬 수 있다. 
+    - **복잡한 구현**
+    -> 배열에 비해 복잡하다. 노드의 삽입, 삭제 시에 링크를 정확히 관리해야 하므로 버그가 발생할 가능성이 더 높다.
+
+### [배열]
+- 👍 효율적인 상황
+
+  - 빠른 데이터 접근: 인덱스를 통해 특정 요소에 즉시 접근할 수 있어, 접근 시간이 𝑂(1)로 매우 빠르다.
+  - 메모리 연속성: 배열은 메모리 내에서 연속적으로 저장되므로, 캐시 효율성이 높아 성능이 좋다.
+  - 간단한 구현: 배열은 구조가 단순하여 구현이 쉽고, 기본적인 데이터 구조로 많이 사용된다.
+- 👎🏻 비효율적인 상황
+
+  - 고정된 크기: 정적 배열의 경우, 크기가 고정되어 있어 실행 중에 크기를 변경할 수 없다. 이로 인해 메모리 낭비가 발생할 수 있다.
+  - 데이터 추가/삭제의 비효율성: 배열의 중간에 요소를 추가하거나 삭제할 경우, 이후의 요소들을 이동해야 하므로 시간 복잡도가 𝑂(𝑛)이 된다.
+  - 메모리 낭비: 동적 배열을 사용할 경우, 배열의 크기를 늘리기 위해 추가 메모리를 할당해야 하며, 이 과정에서 메모리 낭비가 발생할 수 있다.
+
+
+---
+
+## 💡 참고 자료
+
+- https://velog.io/@hyhy9501/5-1-Linked-List-%EC%97%B0%EA%B2%B0-%EB%A6%AC%EC%8A%A4
diff --git "a/DataStructure/\354\212\244\355\203\235\352\263\274 \355\201\220/\354\212\244\355\203\235\352\263\274 \355\201\220_\354\230\210\354\247\200.md" "b/DataStructure/\354\212\244\355\203\235\352\263\274 \355\201\220/\354\212\244\355\203\235\352\263\274 \355\201\220_\354\230\210\354\247\200.md"
new file mode 100644
index 0000000..3de1335
--- /dev/null
+++ "b/DataStructure/\354\212\244\355\203\235\352\263\274 \355\201\220/\354\212\244\355\203\235\352\263\274 \355\201\220_\354\230\210\354\247\200.md"	
@@ -0,0 +1,70 @@
+## 📖 학습 주제
+
+- **주제**: 스택과 큐
+- **날짜**: 2024.10.21 - 2024.10.27
+
+---
+
+## 📌 학습 내용 요약
+
+### <span style='background-color: #ede6b1'>[스택]</span>
+- **`스택(stack)`** : 한쪽에서만 데이터의 삽입 및 삭제가 가능한 자료구조
+  - 스택 연산
+    - `푸시(push)` : 데이터를 저장하는 연산
+    - `팝(pop)` : 데이터를 빼네는 연산
+
+    > ✅ **후입선출(LIFO)**
+    최근에 호출된 함수의 매개변수가 가장 먼저 활용되고, 가장 먼저 메모리에서 삭제됨
+
+  - 활용
+    - 최근에 임시 저장한 데이터를 가장 먼저 활용해야하는 경우(뒤로가기)
+    - undo
+    - 후위 표기법 계산
+---
+
+### <span style='background-color: #ede6b1'>[큐]</span>
+- **`큐(queue)`** : 한쪽으로 데이터를 삽입하고, 다른 한쪽으로 데이터를 삭제할 수 있는 자료구조
+  - 큐 연산
+    - `인큐(enqueue)` : 큐의 한쪽 끝에 데이터를 삽입하는 연산
+    - `디큐(dequeue)` : 다른 한쪽 끝으로 데이터를 빼내는(삭제) 연산
+
+    ![](https://velog.velcdn.com/images/yjlee0006/post/248172de-2e3c-4c0e-955e-4feea17a6982/image.png)
+
+    > ✅ **선입선출(FIFO)**
+    가장 먼저 삽입된 데이터가 가장 먼저 삭제됨
+  - 활용
+    - 임시 저장된 데이터를 차례차례 내보내거나 꺼내와야하는 `버퍼`(줄세우기)
+    - 은행업무
+    - 대기열
+  - 변형된 큐의 형태
+    - `원형 큐` : 데이터를 삽입하는 쪽과 삭제하는 쪽 - 양쪽을 하나로 연결해 원형으로 사용
+    - `덱(Double-Ended Queue)` : 양쪽으로 데이터를 삽입/삭제 할 수 있는 큐
+    - `우선순위 큐` : 요소의 저장 순서와 무관하게 우선순위가 높은 순서대로 빠져나가는 큐
+   
+---
+
+## 📈 추가 학습 필요
+스택은 여러 알고리즘 구현에서 활용되는데 어떤 유형에서 주로 활용되는지 궁금해서 찾아보았다.
+또한 기술면접에서 큐의 경우 우선순위 큐에 대해 많이 물어보기 때문에 조금 더 학습했다.
+
+### stack 
+- 대표유형 : 미로찾기
+DFS 알고리즘을 수행하는데 `Stack`을 사용할 수 있음
+DFS는 `stack`을 이용해 경로를 관리함. 
+1. 현재 위치에서 가능한 방향의 좌표를 `stack`에 추가
+2. `stack`의 가장 위 좌표로 이동(반복)
+3. 더 이상 갈 곳이 없으면 `stack`에서 마지막 경로를 제거하고 이전 위치로 이동
+4. 탐색 중 출구를 만나면 종료 - `stack`이 비어 있으면 더 이상 갈 곳이 없다는 의미로, 출구를 찾지 못한 상황
+
+### 우선순위 큐
+- 구현방식
+  - 배열, 연결 리스트, 힙
+- 효율적인 구현방식
+  - `힙 방식`
+  worst case라도 시간 복잡도 O(logN)을 보장하기 때문에 일반적으로 완전 이진트리 형태의 힙을 이용해 구현
+
+---
+
+## 💡 참고 자료
+- https://velog.io/@kangdev/%EA%B8%B0%EC%88%A0%EB%A9%B4%EC%A0%91%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-Stack-Queue
+- https://dev-coco.tistory.com/159
\ No newline at end of file
diff --git "a/DataStructure/\354\236\220\353\243\214\352\265\254\354\241\260\354\235\230 \355\201\260 \352\267\270\353\246\274/\354\236\220\353\243\214\352\265\254\354\241\260\354\235\230 \355\201\260 \352\267\270\353\246\274_\354\230\210\354\247\200.md" "b/DataStructure/\354\236\220\353\243\214\352\265\254\354\241\260\354\235\230 \355\201\260 \352\267\270\353\246\274/\354\236\220\353\243\214\352\265\254\354\241\260\354\235\230 \355\201\260 \352\267\270\353\246\274_\354\230\210\354\247\200.md"
new file mode 100644
index 0000000..8ba2577
--- /dev/null
+++ "b/DataStructure/\354\236\220\353\243\214\352\265\254\354\241\260\354\235\230 \355\201\260 \352\267\270\353\246\274/\354\236\220\353\243\214\352\265\254\354\241\260\354\235\230 \355\201\260 \352\267\270\353\246\274_\354\230\210\354\247\200.md"	
@@ -0,0 +1,153 @@
+## 📖 학습 주제
+
+- **주제**: 자료구조의 큰그림
+- **날짜**: 2024.10.21 - 2024.10.24
+
+---
+
+## 📌 학습 내용 요약
+
+### <span style='background-color: #ede6b1'>[자료구조]</span>
+
+- 어떠한 구조로 데이터를 다룰지 학습하는 과목
+- 데이터를 효율적으로 저장하고 관리하기 위한 방법이나 형식
+
+---
+
+### <span style='background-color: #ede6b1'>[시간복잡도와 공간복잡도]</span>
+
+#### <span style='background-color: #e7b5bf'>시간복잡도</span>
+
+- `시간복잡도(time complexity)` : 입력에 크기에 따른 프로그램 실행시간의 관계
+
+```python
+for _ in range(n):
+    1+1
+```
+
+> 실행시간은 `연산횟수`와 비례하다.
+> 위와 같은 코드는 **n번의 연산**이 필요하다.
+
+```python
+for _ in range(n):
+    for _ in range(n):
+        1+1
+```
+
+> 2개의 반복문이 겹쳐져 있으니 $$n^2$$번의 연산이 필요하다.
+
+---
+
+#### <span style='background-color: #e7b5bf'>표기법</span>
+
+**1. 빅 오 표기법(big O notation)**
+함수의 점근적 상한을 표기하는 방법, 입력에 따른 실행시간의 점근적 상한
+
+- `점근적 상한` : 입력하는 n이 점점 증가(무한대로 커진다고 가정) -> n에 따라 실행시간 증가 -> 실행시간이 증가하는데에 한계 존재(한계 == 점근적 상한)
+
+- **O(상한(n))** : 실행시간이 커지더라도 상한선 이상 커지지 않을 것
+  > ex) **O($$n^2$$)** : 입력값 n이 증가하더라도 실행시간의 증가율이 $$n^2$$보다는 작다.
+  > ❗단, 점근적 상한을 표현할 때에는 **최고차항의 차수**만 고려해야 함❗
+
+<br>
+
+**2. 빅 세타 표기법(big $$\theta$$ notation)**
+입력에 대한 평균적인 실행 시간
+
+> ex) **$$\theta$$($$n^2$$)** : 입력값 n이 증가하더라도 실행시간의 증가율이 $$n^2$$과 같다.
+
+<br>
+
+**3. 빅 오메가 표기법(big $$\omega$$ notation)**
+입력에 대한 실행 시간의 점근적 하한
+
+> ex) **$$\omega$$($$n^2$$)** : 입력값 n이 증가하더라도 실행시간의 증가율이 $$n^2$$보다는 크다.
+
+---
+
+#### <span style='background-color: #e7b5bf'>공간복잡도</span>
+
+- `공간복잡도(space complexity)` : 프로그램이 실행되었을 때 필요한 메모리 자원의 양
+
+  > 많은 메모리가 필요한 경우 : 공간 복잡도가 크다.
+  > 그렇지 않은 경우 : 공간 복잡도가 작다.
+
+- 공간 복잡도는 빅오 표기법으로 표현
+  - 입력에 따라 필요한 메모리 자원의 양에 대한 점근적 상한을 표현
+
+---
+
+## 📈 추가 학습 필요
+
+개념은 이해했으나 코드를 봤을 때 시간복잡도를 파악하는 것이 어려웠다.
+
+### ✅자주 언급되는 빅 오 표기들의 예제
+
+#### <span style='background-color: #e7b5bf'>1. O(1)</span>
+
+```python
+def get_element(arr, index):
+    return arr[index]
+
+numbers = [10, 20, 30, 40, 50]
+result = get_element(numbers, 2)
+print(result)  # 출력 30
+
+```
+
+> 예제는 리스트의 크기와 상관없이 인덱스를 통해 직접 접근하므로, 실행 시간은 항상 일정함
+> 입력값의 크기에 상관없이 실행시간이 일정한 경우 O(1)
+
+#### <span style='background-color: #e7b5bf'>2. O($$n$$)</span>
+
+```python
+def sum_of_elements(arr):
+    total = 0
+    for element in arr:
+        total += element
+    return total
+
+numbers = [1, 2, 3, 4, 5]
+result = sum_of_elements(numbers)
+print(result)  # 출력 15
+```
+
+> 리스트의 길이가 n일 때, 각 요소에 대해 한 번씩 연산을 수행하므로 총 n번의 연산이 필요함
+
+#### <span style='background-color: #e7b5bf'>3. O($$n^2$$)</span>
+
+```python
+def print_pairs(arr):
+    n = len(arr)
+    for i in range(n):
+        for j in range(n):
+            print(arr[i], arr[j])
+
+numbers = [1, 2, 3]
+print_pairs(numbers)
+```
+
+> 리스트의 크기가 N일 때, 첫 번째 루프가 N번 실행되고, 각 실행마다 두 번째 루프가 N번 실행되므로 총 실행 횟수는 N \* N = N²
+
+#### <span style='background-color: #e7b5bf'>4. O($$nlogn$$)</span>
+
+```python
+def nlogn(n):
+    for i in range(1, n):  # n번 반복
+        j = 1  # 초기값 설정
+        while j < n:  # log n + 1
+            print(i, j)  # log n
+            j *= 2  # j를 2배로 증가
+```
+
+> for문과 while문이 중첩되어 while문은 log n에 곱하기 n번 한 만큼 반복
+> for문이 while내에 중첩되든, while문이 for문 내에 중첩되든 상관없이 반복횟수는 각각 반복문의 곱셈임
+
+$$n+n+(n*(log n+1+log n+log n)) = 2n+3n log n+n = 3n + 3n log n$$
+= **O($$n log n$$)**
+
+---
+
+## 💡 참고 자료
+
+- https://velog.io/@gogori6565/%EC%8B%9C%EA%B0%84-%EB%B3%B5%EC%9E%A1%EB%8F%84-%EB%8C%80%ED%91%9C-%EC%98%88%EC%A0%9C-%EB%AC%B8%EC%A0%9C
diff --git "a/DataStructure/\355\212\270\353\246\254/\355\212\270\353\246\254_\354\230\210\354\247\200.md" "b/DataStructure/\355\212\270\353\246\254/\355\212\270\353\246\254_\354\230\210\354\247\200.md"
new file mode 100644
index 0000000..5cc1a03
--- /dev/null
+++ "b/DataStructure/\355\212\270\353\246\254/\355\212\270\353\246\254_\354\230\210\354\247\200.md"
@@ -0,0 +1,202 @@
+## 📖 학습 주제
+
+- **주제**: 트리
+- **날짜**: 2024.10.21 - 2024.10.27
+
+---
+
+## 📌 학습 내용 요약
+
+### <span style='background-color: #ede6b1'>[트리]</span>
+- **`트리(tree)`** : 계층적인 구조를 표현하기 위한 자료구조
+  - 트리의 핵심 구성요소
+    - `노드(node)` : 데이터를 저장하는 구성요소
+    - `간선(edge)=링크(link)` : 노드와 노드를 연결하는 구성요소
+      
+    ![](https://velog.velcdn.com/images/yjlee0006/post/90b5f703-29f6-47c2-a83c-86046f9c5c38/image.png)
+
+| **용어** | **설명** |
+| --- | --- |
+| **형제 노드(sibling node)** | 같은 부모를 공유하는 노드 |
+| **조상 노드(ancestor node)** | 부모노드와 그 부모 노드들 |
+| **자손 노드(descendant node)** | 자식노드와 그 자식 노드의 자식 노드들 |
+| **노드(node)** | 트리 자료구조에서 데이터를 저장하는 구성 요소 |
+| **간선(edge)** | 트리 자료구조에서 노드를 연결하는 구성 요소 |
+| **부모 노드(parent node)** | 어떤 노드의 상위에 연결된 노드 |
+| **자식 노드(child node)** | 어떤 노드의 하위에 연결된 노드 |
+| **루트 노드(root node)** | 트리의 최상단 노드, 부모 노드가 없는 노드 |
+| **리프 노드(leaf node)** | 트리의 최하단 노드, 자식 노드가 없는 노드 |
+| **차수(degree)** | 어떤 노드가 가지고 있는 자식 노드의 수 |
+| **레벨(level)** | 루트 노드에서 시작해 특정 노드에 이르기까지 거치게 되는 간선의 수 |
+| **서브트리(subtree)** | 트리에 포함되어 있는 부분 트리 |
+
+- 서브트리 + 간선 + 레벨
+![](https://velog.velcdn.com/images/yjlee0006/post/e4308b8a-e254-4199-9982-dbbe3694aaa3/image.png)
+
+- 트리의 구현
+  - 연결리스트처럼 하나의 노드를 `데이터를 저장할 공간`과 `자식노드의 위치정보(메모리상의 주소)`를 저장할 공간들의 모음으로 간주하여 구현
+    
+![](https://velog.velcdn.com/images/yjlee0006/post/f9c379cb-9dab-4669-abe0-1bcac8179a80/image.png)
+
+![](https://velog.velcdn.com/images/yjlee0006/post/1fce05cb-0e9d-4889-95f7-79c60635a3df/image.png)
+
+---
+
+### <span style='background-color: #ede6b1'>[트리의 순회]</span>
+-**`트리의 순회(tree traversal)`** : 트리의 모든 노드를 한번씩 방문하는 순회
+  - 순회의 종류
+    - `전위 순회` : 루트 노드부터 시작해 왼쪽 서브트리를 전위 순회하고, 이후 오른쪽 서브트리를 전위 순회하는 방법
+      
+    ![](https://velog.velcdn.com/images/yjlee0006/post/a5882820-a899-408e-b52e-eb8b559aa8fb/image.png)
+
+    - `중위 순회` : 루트 노드 기준 왼쪽 서브트리를 중위 순회한 다음, 루트 노드를 방문하고 오른쪽 서브트리를 중위 순회하는 순서로 노드에 접근하는 순회 방법
+      
+    ![](https://velog.velcdn.com/images/yjlee0006/post/4b200cff-1a77-4420-a281-6f937c0d5975/image.png)
+
+    - `후위 순회` : 루트 노드 기준 왼쪽 서브트리를 후위 순회하고, 오른쪽 서브트리까지 후위순회한 다음, 루트 노드를 방문하는 순서로 노드에 접근하는 순회 방법
+      
+    ![](https://velog.velcdn.com/images/yjlee0006/post/e089192d-83e4-4a0c-b3cf-e3dacdee971c/image.png)
+
+    - `레벨 순서 순회` : 가장 낮은 레벨부터 차례로 노드를 순회하는 방법
+      
+    ![](https://velog.velcdn.com/images/yjlee0006/post/9c59187a-6ec7-4647-a7f5-a8d5b46a1a12/image.png)
+
+---
+
+### <span style='background-color: #ede6b1'>[트리의 종류]</span>
+### 기본적인 트리
+-**`이진트리(binary tree)`** : 자식 노드의 개수가 2개 이하인 트리
+
+![](https://velog.velcdn.com/images/yjlee0006/post/fae03bde-614a-496c-a42d-396f3b8d78a9/image.png)
+
+-**`편향된 이진트리(askewed binary tree)`** : 모든 자식 노드가 한쪽으로 치우친 이진트리
+
+![](https://velog.velcdn.com/images/yjlee0006/post/f556565e-99c5-4873-8ff7-af928a8f2608/image.png)
+
+-**`정 이진 트리(full binary tree)`** : 자식 노드의 개수가 1개가 아닌 이진트리(자식노드 개수가 0이거나 2)
+
+![](https://velog.velcdn.com/images/yjlee0006/post/ba2ac453-57f8-4c35-8823-44169a290bf6/image.png)
+
+-**`포화 이진 트리(perfect binary tree)`** : 리프노드를 제외한 모든 노드들이 자식 노드를 2개씩 가지고 있고, 모든 리프 노드의 레벨이 동일한 이진트리
+
+![](https://velog.velcdn.com/images/yjlee0006/post/120b2145-1769-41bb-9193-dd4cc4be4b2a/image.png)
+
+-**`완전 이진 트리(complete binary tree)`** : 마지막 레벨을 제외한 모든 레벨이 2개의 자식노드를 가지고 있으며, 마지막 레벨의 모든 노드들이 왼쪽부터 존재하는 이진트리
+
+![](https://velog.velcdn.com/images/yjlee0006/post/fbd65e06-c4c5-4df5-8cc8-a70830156b77/image.png)
+
+<br>
+
+### 탐색에 활용되는 트리
+- **이진탐색트리** : 특정 노드의 왼쪽에는 해당 노드보다 작은값, 오른쪽에는 해당 노드보다 큰값 -> O(log n)으로 원하는 값 탐색 가능
+- 
+![](https://velog.velcdn.com/images/yjlee0006/post/6a1a387c-257d-4c1a-a7dc-7753a09a79fc/image.png)
+
+💡 위의 경우 루트노드인 8보다 작은 왼쪽 서브트리의 노드는 볼 필요가 없음
+
+<br>
+- **힙** : 탐색에 특화된 완전 이진 트리의 종류 중 하나이며 최댓값과 최솟값을 빠르게 찾기위해 사용
+  - 힙의 종류
+    - `최대 힙` : 부모 노드가 자식 노드의 값보다 큰 값으로 이루어진 이진 트리
+    - `최소 힙` : 부모 노드가 자식 노드의 값보다 작은 값으로 이루어진 이진 트리
+    
+  ![](https://velog.velcdn.com/images/yjlee0006/post/a4d0c762-7da7-4626-a2fe-2488013d4ac4/image.png)
+    
+  - `최대 힙` 구현 : 최상단 루트 노드는 언제나 우선순위가 가장 높은 값을 가지게 됨
+    
+  <br> 
+  =>  `우선순위 큐`
+  
+  ![](https://velog.velcdn.com/images/yjlee0006/post/fe8bcf52-1345-48a7-a52f-26a40ec4fe7c/image.png)
+  
+  💡 데이터를 빼낼 때 어떤 순서로 저장되었든 우선순위가 높은 데이터 순으로 얻어낼 수 있음
+
+<br>
+
+### 균형을 맞추는 트리
+- 이진탐색트리의 문제점인 편향된 트리를 개선하기 위해 사용할 수 있는 특별한 이진 탐색 트리
+  - `자가 균형 이진 탐색 트리`
+  - `AVL 트리`
+  - `RB 트리(자주 사용됨)`
+  <br>
+- RB 노드의 구성요소
+  - `NIL(null leaf) 노드` : 실질적인 데이터가 저장되어 있지 않은 노드(리프노드)
+    
+![](https://velog.velcdn.com/images/yjlee0006/post/b8574688-57f6-4448-8df5-b9407eef6421/image.png)
+
+<br>
+- RB 트리의 규칙
+<br>
+  1) 루트 노드는 블랙 노드
+  <br>
+  2) 리프 노드는 블랙 노드
+  <br>
+  3) 레드 노드의 자식 노드는 블랙 노드
+  <br>
+  4) 루트 노드에서 임의의 리프 노드에 이르는 경로의 블랙 노드 수는 같음
+  <br>
+  +) 새 노드를 삽입 할 때는 삽입할 노드를 레드로 간주
+  <br>
+  -> 삽입 이후에도 RB트리가 유지되어야 하므로 4가지 조건에 부합할 때 까지 트리를 `회전` / `색상 재지정` 해야함
+  <br>
+  - `트리의 회전` : 양쪽 서브트리의 높이의 균형을 맞추기 위해 부모 노드와 자식 노드의 관계를 재 지정하는 것
+  <br>
+    - 왼쪽 회전
+    
+  ![](https://velog.velcdn.com/images/yjlee0006/post/cfa501e8-4e8e-436e-b7ae-845541a1a5f0/image.png)
+  <br>
+  
+  - 오른쪽 회전
+    
+  ![](https://velog.velcdn.com/images/yjlee0006/post/8780c1b4-54de-477f-b6fd-15e631f695c6/image.png)
+    
+   - `색상 재지정` : 삽입노드를 레드로 간주할 경우 간혹 아래처럼 '레드노드의 자식노드가 블랙노드'라는 조건에 부합하지 않는 경우가 있음
+     
+     ![](https://velog.velcdn.com/images/yjlee0006/post/27aed8da-01ce-4a3b-86e8-e5ff4cab4475/image.png)
+     
+     💡 트리를 왼쪽으로 회전하고, 색상을 재지정(12를 15의 자식 노드로 만들고 12를 레드 노드로, 15를 블랙 노드로 변환)
+     
+     ![](https://velog.velcdn.com/images/yjlee0006/post/bb6d9335-ff93-448e-a38c-ef5b5fbc0b68/image.png)
+
+### 대용량 입출력을 위한 트리
+- **B 트리** : `다진 탐색 트리(한 노드가 여러 자식 노드를 가질 수 있는 트리)`의 한 종류
+  - 특징
+    - 한 노드가 가질 수 있는 자식 노드의 수는 최소, 최대 개수가 정해져 있음
+    <br> 
+    -> 최대 자식 노드의 개수가 M개인 B트리 : `M차 B트리`
+    <br>
+    -> `M차 B트리`가 가질 수 있는 최소 자식 노드의 개수 : `M/2(반올림)`
+    <br>
+    - B트리는 모든 리프 노드의 깊이가 같다
+      <br>
+ - **B+ 트리** : B트리와 큰 골격은 유사하지만 아래와 같은 차이점이 있음
+   - B+트리에서는 실질적인 데이터가 모두 최하위 리프 노드에 위치
+   - B+트리에서 실질적 데이터가 저장되는 최하위 리프노드는 연결리스트의 형태를 띄고 있음
+ 
+
+
+---
+
+## 📈 추가 학습 필요
+그림자료에 오류가 있는 것 같아서 B트리에 대해 자세히 찾아보았다.
+
+⬇️ 문제의 그림
+
+![](https://velog.velcdn.com/images/yjlee0006/post/85eedc38-b103-47c8-9c70-fb286e2bc97f/image.png)
+
+B 트리의 각 노드에는 `하나 이상의 키값`이 존재하고 각 키들이 `오름차순`으로 저장되어 있다.
+루트노드는 위처럼 2개의 키가 존재하고,
+이때, 서브트리 L의 루트인 노드 B는 가장 작은 키값이어야 하므로 -> `서브트리L < key1`
+<br>
+그리고 서브트리 M의 루트인 노드 C는 key1과 key2 값의 사이에 위치 하므로 `key1 < 서브트리 M < key 2`
+<br>
+마지막으로 노드 D의 경우 key2보다 큰 값을 가져야한다.
+따라서 그림 아래의 주석은 `key2 < 서브트리 R`  이렇게 바껴야한다.
+
+
+---
+
+## 💡 참고 자료
+- https://velog.io/@chanyoung1998/B%ED%8A%B8%EB%A6%AC
+- https://matice.tistory.com/8
+
diff --git "a/DataStructure/\355\225\264\354\213\234 \355\205\214\354\235\264\353\270\224/\355\225\264\354\213\234 \355\205\214\354\235\264\353\270\224_\354\230\210\354\247\200.md" "b/DataStructure/\355\225\264\354\213\234 \355\205\214\354\235\264\353\270\224/\355\225\264\354\213\234 \355\205\214\354\235\264\353\270\224_\354\230\210\354\247\200.md"
new file mode 100644
index 0000000..8b834fa
--- /dev/null
+++ "b/DataStructure/\355\225\264\354\213\234 \355\205\214\354\235\264\353\270\224/\355\225\264\354\213\234 \355\205\214\354\235\264\353\270\224_\354\230\210\354\247\200.md"	
@@ -0,0 +1,115 @@
+## 📖 학습 주제
+
+- **주제**: 해시테이블
+- **날짜**: 2024.10.21 - 2024.10.27
+
+---
+
+## 📌 학습 내용 요약
+
+### <span style='background-color: #ede6b1'>[해시테이블]</span>
+- **`해시테이블(hash table)`** : `키(key)`와 `값(value)`의 대응으로 이루어진 표와 같은 형태의 자료구조
+  - 해시 테이블 구조
+    - `키(key)` : 해시 테이블에 대한 입력
+    - `값(value)` : 키를 통해 얻고자 하는 데이터
+      - 값의 저장위치 : `버킷(bucket)`
+      - 저장된 데이터의 수 / 버킷의 수 : `로드팩터(load factor)`
+      <br>
+      -> 해시 테이블이 얼마나 가득 차있는지에 대한 지표
+      <br>
+      -> 로드 팩터가 클수록 해시 테이블의 성능이 떨어진다
+    - `해시 함수` : 키를 인자로 활용해 인덱스를 반환(해시함수에 키를 통과 시켜 원하는 버킷에 접근)
+    
+  - 삽입/삭제/검색 연산의 시간복잡도 : **`O(1)`**
+  <br>
+  -> 실행과 무관하게 항상 일정한 속도 보장
+  
+  - 단점
+    - 속도가 빠르지만, 상대적으로 많은 메모리 공간 소모됨
+    <br>
+    -> 데이터가 많을 수록 공간 복잡도가 시간복잡도만큼 우수하지 않다.
+
+---
+
+### [해시 함수]
+- **`해시 함수(hash function)`** : 임의의 길이를 지닌 데이터를 고정된 길이로 변환하는 단방향 함수
+-> 특정 입력 데이터를 고정된 길이의 해시값으로 변환 O
+-> 해시값을 토대로 어떤 데이터가 입력되었는지 도출 X
+
+  - 해시 함수의 연산방법
+    - `해시 알고리즘` : MD5, SHA-1, SHA-256, SHA-512, HMAC 등
+    <br>
+    -> sha-1의 경우 `해시 충돌`이 발생할 수 있어 역사속으로 사라짐
+  
+  - 활용
+    - 무작위 값을 만들거나 단방향 암호를 만들 때
+    - 데이터의 무결성을 검증할 때
+    
+  - 단순 구현
+    > ✅ **모듈러 연산** 
+    'A mod B' - A를 B로 나눈 나머지
+    <br>
+    ex) 10 mod 3 = 1
+    ❗ 단, 이렇게 구현할 경우 `해시 충돌`의 우려가 있다.
+    
+---
+
+### [해시 충돌]
+-**`해시 충돌`** 서로 다른 키에 대해 같은 해시 값이 대응되는 상황
+ex) 다른 이름에 같은 전화번호가 대응된 상황
+
+- 대표 case 
+  - SHA-1
+  
+  > 파일1.pdf와 파일2.pdf는 서로 다른 pdf파일이다. 그러나 해시값을 구할 경우 sha-1 알고리즘에서만 동일한 해시값이 도출된다.(충돌발생)
+  
+    - 해결방안
+      1) `체이닝(chaining)` : 충돌이 발생한 데이터를 연결리스트로 추가하는 방법
+        <br>
+      -> 서로 다른 키가 같은 위치로 해시되어도 단순히 연결리스트의 노드만 추가됨.
+      
+      > ❗ 단, 충돌이 발생할 때마다 노드가 추가된다면 빠른속도라는 장점이 사라짐
+      
+      ![](https://velog.velcdn.com/images/yjlee0006/post/d9e8c024-03a7-4c85-97e2-b618a90e0025/image.png)
+
+      2) `개방주소법(open addressing)` : 충돌이 발생한 버킷의 인덱스가 아닌 다른 인덱스에 데이터를 저장하는 방법
+        - `조사(다른 버킷의 인덱스를 찾는 과정)`방법에 따른 구분
+          - `선형 조사법` : 충돌이 발생했을 때, 충돌이 발생한 인덱스의 다음 인덱스부터 순차적으로 가용한 인덱스를 찾아 나서는 방법
+          ![](https://velog.velcdn.com/images/yjlee0006/post/b30a3c5e-8c9b-445c-9924-f343507f2bab/image.png)
+
+          > ❗ 충돌이 발생하는 인덱스 인근에 데이터가 몰려 저장될 수 있음(군집화)
+          
+          - `이차 조사법` : 충돌이 발생한 인덱스에서 제곱수만큼 떨어진 거리에 위치한 인덱스를 찾는 방법
+          
+          ex) bucket의 크기는 7, key값 8에 대해 해시 값 10(h(8) = 10)이라고 가정
+          
+            (1) h(8) mod 7 = 10 mod 7 = 3         // 1차 충돌 발생 가정
+            <br>
+            (2) (h(8) + 1^2) mod 7 = 11 mod 7 = 4  // 2차 충돌 발생 가정
+            <br>
+            (3) (h(8) + 2^2) mod 7 = 14 mod 7 = 0 // 3차 충돌 발생 가정
+            <br>
+            (4) (h(8) + 3^2) mod 7 = 19 mod 7 =  5 // 저장
+            <br>
+	> ❗ but 제곱수의 규칙성으로 인해 근본적인 해결 X
+        
+        
+---
+    
+    
+    
+## 📈 추가 학습 필요
+데이터가 많아질 경우 다른 데이터가 같은 해시 값으로 충돌이 발생하는 현상을 감수하면서도 해시 테이블을 사용하는 이유가 궁금해서 찾아보았다.
+
+- 적은 자원으로 많은 데이터를 효율적으로 관리하기 위함
+- 하드디스크나 클라우드에 존재하는 무한한 데이터들을 유한한 개수의 해시값으로 매핑
+- 언제나 동일한 해시값 리턴 : index를 알면 빠른 데이터 검색이 가능해짐
+<br>
+-> 해시테이블의 시간복잡도 O(1) - (이진탐색트리 O(logN))
+
+
+---
+
+## 💡 참고 자료
+- https://you88.tistory.com/36
+- https://lealea.tistory.com/251
\ No newline at end of file