๊ทธ๋ํ(Graph)๋?
๊ทธ๋ํ๋ ์์๋ค์ด ์๋ก ๋ณต์กํ๊ฒ ์ฐ๊ฒฐ๋์ด ์๋ ๊ด๊ณ๋ฅผ ํํํ๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค.
๊ทธ๋ํ๋ ์ ์ (vertex)๊ณผ ์ ์ ๊ณผ ์ ์ ์ ์ฐ๊ฒฐํ๋ ๊ฐ์ (edge)๋ค์ ์งํฉ์ผ๋ก ๊ตฌ์ฑ๋๋ค.
-> ์ ์ (vertex)๋ ๋ ธ๋(node)๋ผ๊ณ ๋ ํจ
์๋๋ ๋ํ์ ์ธ ๊ทธ๋ํ ์ข ๋ฅ๋ค์ ์์์ด๋ค.
๊ทธ๋ ๋ค๋ฉด ์ด๋ฌํ ๊ทธ๋ํ๋ฅผ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ณด์.
๊ทธ๋ํ ๊ตฌํํ๊ธฐ
์ปดํจํฐ์์ ๊ทธ๋ํ๋ฅผ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์๋ ๋ฐฐ์ด(Array)๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ๊ณผ ์ฐ๊ฒฐ๋ฆฌ์คํธ(Linked List)๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด ์๋ค.
๊ทธ๋ํ ๊ตฌํ - ์ธ์ ํ๋ ฌ(Adjacency Materix)
์ ์ a์ ์ ์ b๋ฅผ ์๋ ๊ฐ์ ์ด ์์ ๊ฒฝ์ฐ, ํ๋ ฌ(a,b)์ 1์ ํ๊ธฐํด์ค๋ค.
๋ง์ฝ ๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ๋ผ๋ฉด 1 ๋์ ๊ฐ์ค์น๋ฅผ ๋ฃ์ ์ ์๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์ ๊ฒฝ์ฐ๋ (a,b) (b,a)์ ๋ชจ๋ ๊ฐ์ ๊ฐ์ ๋ฃ์ง๋ง, ๋ฐฉํฅ ๊ทธ๋ํ๊ฐ์ ๊ฒฝ์ฐ๋ ์์ ํ์ ๊ฐ์ด ๋ฐฉํฅ์ ๋ง๋ ๊ฐ์ ๋ง ํ๊ธฐํ๋ค.
ex) ์ ์ 1๊ณผ 3์ ์๋ ๊ฐ์ ์ด ์กด์ฌํ ๋ : graph[1][3] = 1, graph[3][1] = 1
์์ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ๋ฅผ ์ฝ๋๋ก ํํํด๋ณด์.
public class Main {
public static void print(int[][] graph) {
for (int i = 1; i < graph.length; i++) {
for (int j = 1; j < graph.length; j++)
System.out.print(graph[i][j]+ " ");
System.out.println();
}
}
public static void putEdge(int[][] graph, int x, int y) {
graph[x][y] = 1;
graph[y][x] = 1;
}
public static void main(String[] args) {
int n = 5; //๊ทธ๋ํ ์ ์ ์ ๊ฐ์
int[][] graph = new int[n+1][n+1]; //index๋ฅผ 1๋ถํฐ ๋ง์ถ๊ธฐ ์ํด n+1
putEdge(graph, 1, 2);
putEdge(graph, 1, 3);
putEdge(graph, 1, 4);
putEdge(graph, 2, 3);
putEdge(graph, 2, 5);
putEdge(graph, 3, 4);
putEdge(graph, 4, 5);
print(graph);
}
}
๊ทธ๋ํ ๊ตฌํ - ์ธ์ ๋ฆฌ์คํธ(Adjacency List)
ํด๋น ๋ ธ๋์ ์ฐ๊ฒฐ๋์ด์๋ ๋ ธ๋๋ค์ ๋ฆฌ์คํธ๋ก ์ญ ๋ถ์ด๋ ๋ฐฉ์์ด๋ค.
ArrayList๋ฅผ ์ฌ์ฉํ์ฌ ์ฝ๋๋ก ๊ตฌํํด๋ณด์.
public class Main {
public static void print(ArrayList<ArrayList<Integer>> graph) {
for (int i = 1; i < graph.size(); i++) {
ArrayList<Integer> node = graph.get(i);
System.out.print("node"+"["+i+"] : ");
for (int j = 0; j < node.size(); j++)
System.out.print(node.get(j)+ "->");
System.out.println();
}
}
public static void putEdge(ArrayList<ArrayList<Integer>> graph, int x, int y) {
graph.get(x).add(y);
graph.get(y).add(x);
}
public static void main(String[] args) {
int n = 5; //๊ทธ๋ํ ์ ์ ์ ๊ฐ์
ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
for (int i = 0; i <= n; i++)
graph.add(new ArrayList<>()); //๊ฐ ๋
ธ๋ ๋ณ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด์ค๋ค.
putEdge(graph, 1, 2);
putEdge(graph, 1, 3);
putEdge(graph, 1, 4);
putEdge(graph, 2, 3);
putEdge(graph, 2, 5);
putEdge(graph, 3, 4);
putEdge(graph, 4, 5);
print(graph);
}
}
์ธ์ ํ๋ ฌ๊ณผ ์ธ์ ๋ฆฌ์คํธ์ ์ฅ๋จ์
๊ทธ๋ ๋ค๋ฉด ๋ ๋ฐฉ์์ ์ฅ๋จ์ ์ ๋ํด ์์๋ณด์.
์ธ์ ํ๋ ฌ | ์ธ์ ๋ฆฌ์คํธ | |
์๊ฐ ๋ณต์ก๋ | O(N^2) ์ ์ N * N๋งํผ ํ์ | O(N) N : ๊ฐ์ ์ ๊ฐ์ |
๊ณต๊ฐ ๋ณต์ก๋ | O(V^2) V๊ฐ์ ๋ ธ๋ ํํ์ ์ํด V^2 ๋งํผ์ ๊ณต๊ฐ์ด ํ์ | O(V+E) V๊ฐ์ ๋ฆฌ์คํธ์ ๊ฐ์ (E)๋ง ํผ ์์๊ฐ ๋ค์ด์์ |
๋ ์ ์ ์ ์ฐ๊ฒฐ ์ฌ๋ถ | graph[x][y] ์ ๊ฐ์ผ๋ก ํ๋ฒ์ ํ์ธ | graph<x> ์ ์์์์ y๊ฐ ๋์ฌ๋๊น์ง ํ์ |
์ธ์ ๋ ธ๋ ํ์ ์ฌ๋ถ | N * N๋งํผ ๋ฐ๋ณต๋ฌธ์ ๋์ ํ์ธํ๋ค. | ๊ฐ ๋ฆฌ์คํธ์ ๋ด๊ฒจ์๋ ์์๋ฅผ ํ์ธํ๋ค. |
๋ ๋ค ์ฅ๋จ์ ์ด ์์ผ๋ฏ๋ก, ์๋ ์ํฉ์ ๋ง๊ฒ ์ฌ์ฉํ๋ฉด ๋๋ค.
- ์ธ์ ํ๋ ฌ : ๊ทธ๋ํ์ ๊ฐ์ ์ด ๋ง์ด ์กด์ฌํ๋ ๋ฐ์ง ๊ทธ๋ํ์ ๋น ๋ฅด๊ฒ ์ฐ๊ฒฐ ์ฌ๋ถ ํ์ธ
- ์ธ์ ๋ฆฌ์คํธ : ๊ทธ๋ํ์ ๊ฐ์ ์ด ์ ๊ฒ ์กด์ฌํ๋ ํฌ์ ๊ทธ๋ํ์ ๊ฒฝ์ฐ์ ์ธ์ ๋ ธ๋ ๋น ๋ฅด๊ฒ ํ์ธ
๐์ฐธ๊ณ ์ฌ์ดํธ
[JAVA] ๊ทธ๋ํ ๊ตฌํํ๊ธฐ (์ธ์ ํ๋ ฌ, ์ธ์ ๋ฆฌ์คํธ)
'Algorithm > KBro Study' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ๋ฒจ๋งํฌ๋ ์๊ณ ๋ฆฌ์ฆ (Bellman-Ford) (0) | 2023.03.02 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ๊ทธ๋ฆฌ๋ - ์ต์ ์คํจ๋ ํธ๋ฆฌ(Minimum Spanning Tree) (0) | 2023.02.19 |
[์๊ณ ๋ฆฌ์ฆ] Brute Force(๋ธ๋ฃจํธ ํฌ์ค) (0) | 2023.01.08 |
[์๋ฃ๊ตฌ์กฐ] B-tree, B+tree ์ด๋ก ์ ๋ฆฌ (0) | 2022.12.28 |
[์๋ฃ๊ตฌ์กฐ] Java - ํด์ํ ์ด๋ธ(HashTable) ์ด๋ก ์ ๋ฆฌ (0) | 2022.12.23 |