Hyewon

DataStructure/그래프/그래프_혜원.md

@@ -0,0 +1,248 @@
+## 📖 학습 주제
+
+- **주제**: 그래프
+- **날짜**: 2024-10-28
+
+---
+
+## 📌 학습 내용 요약
+
+### [그래프의 종류와 구현]
+
+**그래프**
+
+- `그래프(Graph)` : 정점이라 불리는 데이터를 간선 혹은 링크로 연결한 형태
+    - 데이터 간의 연결 관계를 표현
+- `연결 그래프(connected graph)` : 임의의 두 정점 사이의 경로가 존재하는 그래프
+- `비연결 그래프(disconnected graph)` : 정점 사이에 경로가 존재하지 않을 수 있는 그래프
+- `방향 그래프(directed graph)` : 간선에 방향이 있는 그래프
+- `무방향 그래프(undirected graph)` : 간선에 방향이 없는 그래프
+- `가중치 그래프(weighted graph)` : 간선에 가중치가 부여된 그래프
+    - 비용(cost) : 간선에 부여된 값
+- `서브 그래프(subgraph)` : 특정 그래프의 정점과 간선의 일부분으로 이루어진 그래프
+
+**인접 행렬 기반 그래프 표현**
+
+- N X N 크기의 행렬로 그래프 표현하는 방법
+    - 무방향 그래프
+
+      ![image (11)](https://github.com/user-attachments/assets/ee80e131-4410-4a3c-b45f-ba96ac09b5e8)
+
+    - 방향 그래프
+
+      ![image (10)](https://github.com/user-attachments/assets/f88c9048-5e2e-4c20-bded-b9a638f7c421)
+
+
+**인접 리스트 기반 그래프 표현**
+
+- 그래프의 특정 정점과 연결된 정점들을 연결 리스트로 표현하는 방법
+
+  ![image (9)](https://github.com/user-attachments/assets/a4b5345f-3662-4cfe-bbaa-588081a8a52f)
+
+
+---
+
+### [깊이 우선 탐색과 너비 우선 탐색]
+
+**깊이 우선 탐색**
+
+- `DFS(Depth-First Search)` : 그래프에서 더 이상 방문 가능한 정점이 없을 때까지 최대한 깊이 탐색하기를 반복하는 탐색 방법
+
+    ```java
+    import java.util.*;
+
+    public class DFSExample {
+        private static void dfs(int node, boolean[] visited, List<List<Integer>> graph) {
+            // 현재 노드를 방문 처리
+            visited[node] = true;
+            System.out.print(node + " ");
+
+            // 인접한 노드를 재귀적으로 방문
+            for (int neighbor : graph.get(node)) {
+                if (!visited[neighbor]) {
+                    dfs(neighbor, visited, graph);
+                }
+            }
+        }
+
+        public static void main(String[] args) {
+            int n = 5; // 노드 개수
+            List<List<Integer>> graph = new ArrayList<>();
+            for (int i = 0; i <= n; i++) {
+                graph.add(new ArrayList<>());
+            }
+
+            // 그래프 연결 정보 설정
+            graph.get(1).add(2);
+            graph.get(1).add(3);
+            graph.get(2).add(4);
+            graph.get(3).add(5);
+
+            boolean[] visited = new boolean[n + 1];
+            System.out.print("DFS: ");
+            dfs(1, visited, graph);
+        }
+    }
+
+    ```
+
+
+**너비 우선 탐색**
+
+- BFS(Breadth-First Search) : 그래프에서 더 이상 방문 가능한 정점이 없을 때까지 최대한 넓게 탐색하기를 반복하는 탐색 방법
+
+    ```java
+    import java.util.*;
+
+    public class BFSExample {
+        private static void bfs(int start, List<List<Integer>> graph) {
+            Queue<Integer> queue = new LinkedList<>();
+            boolean[] visited = new boolean[graph.size()];
+
+            queue.add(start);
+            visited[start] = true;
+
+            while (!queue.isEmpty()) {
+                int node = queue.poll();
+                System.out.print(node + " ");
+
+                for (int neighbor : graph.get(node)) {
+                    if (!visited[neighbor]) {
+                        queue.add(neighbor);
+                        visited[neighbor] = true;
+                    }
+                }
+            }
+        }
+
+        public static void main(String[] args) {
+            int n = 5; // 노드 개수
+            List<List<Integer>> graph = new ArrayList<>();
+            for (int i = 0; i <= n; i++) {
+                graph.add(new ArrayList<>());
+            }
+
+            // 그래프 연결 정보 설정
+            graph.get(1).add(2);
+            graph.get(1).add(3);
+            graph.get(2).add(4);
+            graph.get(3).add(5);
+
+            System.out.print("BFS: ");
+            bfs(1, graph);
+        }
+    }
+
+    ```
+
+
+---
+
+### [최단 경로 알고리즘]
+
+**최단 경로 알고리즘**
+
+- `최단 경로 알고리즘` : 한 정점에서 목적지 정점까지 이르는 가중치의 합이 최소가 되는 경로를 결정하는 알고리즘
+- **실생활 예**
+    - 지도 서비스 (원하는 목적지까지의 최단 거리)
+    - 컴퓨터 네트워크
+
+
+**다익스트라 알고리즘**
+
+- `Dijkstra’s Algorithm` : 간선의 가중치가 음이 아닌 수라는 가정 하에 사용 가능한 최단 경로 알고리즘
+- **동작 방식**
+    - 시작 정점 제외한 정점 초기화
+    - (시작) 정점 방문
+    - 경로 상 가중치 합과 최단 거리 테이블 상 값 비교
+    - 최단 거리 테이블 갱신 가능하면 갱신
+    - 방문하지 않은 정점 중 최단 거리가 가장 작은 정점 방문
+    - 더 이상 방문할 정점이 없을 때까지 반복
+
+    ```java
+    import java.util.*;
+
+    public class DijkstraExample {
+        static class Node implements Comparable<Node> {
+            int vertex;
+            int distance;
+
+            public Node(int vertex, int distance) {
+                this.vertex = vertex;
+                this.distance = distance;
+            }
+
+            // 우선순위 큐에서 거리 오름차순으로 정렬하기 위한 비교 함수
+            @Override
+            public int compareTo(Node other) {
+                return Integer.compare(this.distance, other.distance);
+            }
+        }
+
+        public static int[] dijkstra(int start, List<List<Node>> graph, int n) {
+            PriorityQueue<Node> pq = new PriorityQueue<>();
+            int[] distances = new int[n + 1];
+            Arrays.fill(distances, Integer.MAX_VALUE);
+            distances[start] = 0;
+
+            pq.add(new Node(start, 0));
+
+            while (!pq.isEmpty()) {
+                Node current = pq.poll();
+                int currentVertex = current.vertex;
+                int currentDistance = current.distance;
+
+                // 이미 처리된 노드의 최단 경로보다 큰 경우 무시
+                if (currentDistance > distances[currentVertex]) continue;
+
+                // 인접 노드 확인
+                for (Node neighbor : graph.get(currentVertex)) {
+                    int newDist = distances[currentVertex] + neighbor.distance;
+
+                    // 더 짧은 경로가 발견되면 갱신
+                    if (newDist < distances[neighbor.vertex]) {
+                        distances[neighbor.vertex] = newDist;
+                        pq.add(new Node(neighbor.vertex, newDist));
+                    }
+                }
+            }
+
+            return distances;
+        }
+
+        public static void main(String[] args) {
+            int n = 5; // 노드 개수
+            List<List<Node>> graph = new ArrayList<>();
+            for (int i = 0; i <= n; i++) {
+                graph.add(new ArrayList<>());
+            }
+
+            // 그래프 연결 설정 (노드, 가중치)
+            graph.get(1).add(new Node(2, 2));
+            graph.get(1).add(new Node(3, 5));
+            graph.get(2).add(new Node(3, 3));
+            graph.get(2).add(new Node(4, 1));
+            graph.get(3).add(new Node(4, 2));
+            graph.get(4).add(new Node(5, 1));
+
+            int start = 1; // 시작 노드
+            int[] distances = dijkstra(start, graph, n);
+
+            System.out.println("노드 " + start + "에서 각 노드까지의 최단 거리:");
+            for (int i = 1; i <= n; i++) {
+                System.out.println("노드 " + i + " : " + distances[i]);
+            }
+        }
+    }
+    ```
+
+
+---
+
+## 💡 참고 자료
+
+- [adjacency matrix of a graph](https://www.geeksforgeeks.org/adjacency-matrix-meaning-and-definition-in-dsa/)
+- [adjacency list of a graph](https://www.geeksforgeeks.org/adjacency-list-meaning-definition-in-dsa/)
+- [DFS](https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/)
+- [BFS](https://www.geeksforgeeks.org/breadth-first-search-or-bfs-for-a-graph/)
+- [Dijkstra Algorithm](https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/)

DataStructure/배열과 연결 리스트/배열과 연결 리스트-혜원.md

@@ -0,0 +1,91 @@
+## 📖 학습 주제
+
+- **주제**: 배열과 연결 리스트
+- **날짜**: 2024-10-25
+
+---
+
+## 📌 학습 내용 요약
+
+### [배열]
+
+**배열**
+
+- `배열` : 일정한 메모리 공간을 차지하는 여러 요소들이 순차적으로 나열된 자료구조
+- 각 요소는 0부터 시작하는 고유한 순서 번호인 `인덱스`를 매김
+- 인덱스가 주어졌을 때 특정 요소에 접근하는 연산 : O(1)
+- 서로 다른 N개의 데이터에서 특정 데이터를 찾는 연산 : O(N)
+- 특정 인덱스의 요소를 추가하는 연산 : O(N)
+- 특정 인덱스의 요소를 삭제하는 연산 : O(N)
+
+**정적 배열**
+
+- 프로그램을 실행하기 전 크기가 고정되어 있는 배열
+- 프로그램 도중 변경 X
+
+**동적 배열**
+
+- 실행 과정에서 크기가 변할 수 있는 배열
+- 배열의 크기를 알기 어려운 경우, 유연하게 요소 개수를 조정해야 하는 경우 사용
+- 동적 배열을 `벡터`라는 이름으로 구현한 프로그래밍 언어도 존재
+
+---
+
+### [연결 리스트]
+
+**연결 리스트**
+
+- `노드` : 데이터와 다음 노드의 위치(메모리 상의 주소) 정보를 포함하는 연결 리스트 구성 단위
+- `연결 리스트(Linked list)` : 노드의 모음으로 구성된 자료구조
+- 모든 노드들이 한 쪽 방향으로 꼬리에 꼬리를 무는 형태로 구성
+  - 첫 번째 노드 : 헤드(Head)
+  - 마지막 노드 : 꼬리(Tail)
+- 연속적으로 구성되어 있는 데이터를 불연속적으로 저장할 때 유용
+- 연결 리스트에서 특정 요소에 접근하는 연산 : O(N) → 순차적 접근이 필요하기 때문
+- 새로운 요소 추가 및 삭제 연산 : O(1) → 재정렬이 불필요하기 때문
+
+**싱글 연결 리스트**
+![image (4)](https://github.com/user-attachments/assets/50242e50-cd31-4e46-a94b-35a7d905ec0d)
+
+- `싱글 연결 리스트(singly linked list)` : 노드 내에 다음 노드의 위치 정보가 저장되어, 한 쪽 방향으로 꼬리에 꼬리를 무는 형태 (단방향 탐색만 가능)
+- **단점**
+  - 특정 노드를 통해 `다음 노드` 위치 확인 가능
+  - `이전 노드` 위치 알기 어려움
+
+
+**이중 연결 리스트**
+![image (4)](https://github.com/user-attachments/assets/50242e50-cd31-4e46-a94b-35a7d905ec0d)
+
+- `이중 연결 리스트(doubly linked list)` : 노드 내에 다음 노드의 위치 정보뿐만 아니라 이전 노드의 위치 정보도 포함하고 있는 형태 (양방향 탐색 가능)
+- **장점**
+  - 싱글 연결 리스트 탐색 성능 완화
+- **단점**
+  - 한 노드에 2개의 위치 정보(메모리 주소)를 저장 → 저장 공간 필요 多
+
+**환형 연결 리스트**
+![image (5)](https://github.com/user-attachments/assets/cc58b057-274b-4b41-ba2c-b8d75102163e)
+
+- `환형 연결 리스트(circular linked list)` : 꼬리 노드가 헤드 노드를 가리켜 노드들이 원형으로 구성된 형태
+- 환형 연결 리스트는 `원형 연결 리스트` 라고도 부름
+- 이중 연결 리스트로도 구현 가능
+  ![image (6)](https://github.com/user-attachments/assets/b52521ce-dc01-4516-b33d-78c512b122de)
+
+- 모든 노드 데이터 여러 차례 순회할 때 유용
+
+---
+
+## 📈 추가 학습 필요
+
+- **해시 테이블**: 해시 함수, 충돌 해결 방법(체이닝, 오픈 어드레싱 등), 해시 테이블의 장단점.
+- **스택과 큐**: 각각의 정의, 사용 사례, 구현 방법.
+- **트리 구조**: 이진 트리, 이진 탐색 트리, AVL 트리 등의 개념과 특징.
+- **그래프 이론**: 그래프의 정의, 그래프 탐색 알고리즘(DFS, BFS), 가중치 그래프, 최단 경로 알고리즘(Dijkstra, Bellman-Ford).
+- **시간 복잡도 및 공간 복잡도**: 다양한 자료구조의 성능 분석 및 최적화.
+
+---
+
+## 💡 참고 자료
+
+- [Singly Linked List](https://www.geeksforgeeks.org/singly-linked-list-tutorial/)
+- [Doubly Linked List](https://www.geeksforgeeks.org/doubly-linked-list/)
+- [Circular Linked List](https://www.geeksforgeeks.org/circular-linked-list/)