+
+
+
diff --git a/src/controllers.js b/src/controllers.js
new file mode 100644
index 00000000..8706c0ac
--- /dev/null
+++ b/src/controllers.js
@@ -0,0 +1,53 @@
+import { showResult, clearInput } from './views.js';
+import stationValidation from './utils/validation.js';
+
+const checkradioValue = lst => {
+ for (let l of lst) {
+ if (l.checked) return l.value;
+ }
+};
+const departureStationNameInput = document.querySelector(
+ '#departure-station-name-input'
+);
+const arrivalStationNameInput = document.querySelector(
+ '#arrival-station-name-input'
+);
+const searchType = document.getElementsByName('search-type');
+const searchButton = document.querySelector('#search-button');
+const resultDiv = document.querySelector('#result');
+
+export const initListener = subwayPath => {
+ searchButton.addEventListener('click', () => {
+ clickButton(subwayPath);
+ });
+};
+
+const clickButton = subwayPath => {
+ const validationResult = stationValidation(
+ departureStationNameInput.value,
+ arrivalStationNameInput.value,
+ subwayPath.stationList
+ );
+ const findPathResult =
+ checkradioValue(searchType) === 'distance'
+ ? subwayPath.distancePath.findPath(
+ departureStationNameInput.value,
+ arrivalStationNameInput.value
+ )
+ : subwayPath.timePath.findPath(
+ departureStationNameInput.value,
+ arrivalStationNameInput.value
+ );
+ clearInput(departureStationNameInput, arrivalStationNameInput);
+
+ if (validationResult.success) {
+ if (!findPathResult.error) {
+ showResult(findPathResult.route, resultDiv);
+ // findPathResult.distance ๋ก ํ์
์ ๋ง๋ ๊ฒฐ๊ณผ๊ฐ์ ๊ฐ์ ธ์จ๋ค.
+ } else {
+ alert(findPathResult.error);
+ }
+ } else {
+ alert(validationResult.error);
+ }
+};
diff --git a/src/data.js b/src/data.js
new file mode 100644
index 00000000..7704463c
--- /dev/null
+++ b/src/data.js
@@ -0,0 +1,37 @@
+export const lineData = [
+ {
+ name: '2ํธ์ ',
+ distanceInfo: [
+ ['๊ต๋', '๊ฐ๋จ', 2],
+ ['๊ฐ๋จ', '์ญ์ผ', 2],
+ ],
+ timeInfo: [
+ ['๊ต๋', '๊ฐ๋จ', 3],
+ ['๊ฐ๋จ', '์ญ์ผ', 3],
+ ],
+ },
+ {
+ name: '3ํธ์ ',
+ distanceInfo: [
+ ['๊ต๋', '๋จ๋ถํฐ๋ฏธ๋', 3],
+ ['๋จ๋ถํฐ๋ฏธ๋', '์์ฌ', 6],
+ ['์์ฌ', '๋งค๋ด', 1],
+ ],
+ timeInfo: [
+ ['๊ต๋', '๋จ๋ถํฐ๋ฏธ๋', 2],
+ ['๋จ๋ถํฐ๋ฏธ๋', '์์ฌ', 5],
+ ['์์ฌ', '๋งค๋ด', 1],
+ ],
+ },
+ {
+ name: '์ ๋ถ๋น์ ',
+ distanceInfo: [
+ ['๊ฐ๋จ', '์์ฌ', 2],
+ ['์์ฌ', '์์ฌ์๋ฏผ์์ฒ', 10],
+ ],
+ timeInfo: [
+ ['๊ฐ๋จ', '์์ฌ', 8],
+ ['์์ฌ', '์์ฌ์๋ฏผ์์ฒ', 3],
+ ],
+ },
+];
diff --git a/src/index.js b/src/index.js
new file mode 100644
index 00000000..1e33c8b7
--- /dev/null
+++ b/src/index.js
@@ -0,0 +1,11 @@
+import { SubwayDistancePath, SubwayTimePath } from './models.js';
+import { initListener } from './controllers.js';
+
+export default function SubwayPath() {
+ this.distancePath = new SubwayDistancePath();
+ this.timePath = new SubwayTimePath();
+ this.stationList = this.distancePath.stations;
+}
+
+const subwayPath = new SubwayPath();
+initListener(subwayPath);
diff --git a/src/models.js b/src/models.js
new file mode 100644
index 00000000..12548f4f
--- /dev/null
+++ b/src/models.js
@@ -0,0 +1,30 @@
+import { lineData } from './data.js';
+import Dijkstra from './utils/Dijkstra.js';
+
+export function SubwayDistancePath() {
+ this.dijkstra = new Dijkstra();
+ lineData.forEach(data => {
+ data.distanceInfo.forEach(info => {
+ this.dijkstra.addEdge(...info);
+ });
+ });
+ this.stations = Object.keys(this.dijkstra.callAdjacencyList());
+ this.findPath = (start, end) => {
+ console.log('๊ฑฐ๋ฆฌ๋ก ์ฐพ๊ธฐ...');
+ return this.dijkstra.findShortestPath(start, end);
+ };
+}
+
+export function SubwayTimePath() {
+ this.dijkstra = new Dijkstra();
+ lineData.forEach(data => {
+ data.timeInfo.forEach(info => {
+ this.dijkstra.addEdge(...info);
+ });
+ });
+ this.stations = Object.keys(this.dijkstra.callAdjacencyList());
+ this.findPath = (start, end) => {
+ console.log('์๊ฐ์ผ๋ก ์ฐพ๊ธฐ...');
+ return this.dijkstra.findShortestPath(start, end);
+ };
+}
diff --git a/src/utils/Dijkstra.js b/src/utils/Dijkstra.js
new file mode 100644
index 00000000..08407365
--- /dev/null
+++ b/src/utils/Dijkstra.js
@@ -0,0 +1,225 @@
+import { NOT_CONNECTION_ERROR } from '../utils/constants.js';
+
+export default function Dijkstra() {
+ const Node = {
+ init: function (val, priority) {
+ this.val = val;
+ this.priority = priority;
+ },
+ };
+
+ const PriorityQueue = {
+ init: function () {
+ this.values = [];
+ },
+ enqueue: function (val, priority) {
+ const newNode = Object.create(Node);
+ newNode.init(val, priority);
+
+ this.values.push(newNode);
+
+ let idxOfNewNode = this.values.length - 1;
+
+ while (idxOfNewNode > 0) {
+ const idxOfParentNode = Math.floor((idxOfNewNode - 1) / 2);
+
+ const parentNode = this.values[idxOfParentNode];
+
+ if (priority < parentNode.priority) {
+ this.values[idxOfParentNode] = newNode;
+ this.values[idxOfNewNode] = parentNode;
+ idxOfNewNode = idxOfParentNode;
+ continue;
+ }
+ break;
+ }
+ return this.values;
+ },
+ dequeue: function () {
+ if (this.values.length == 0) {
+ return;
+ }
+ const dequeued = this.values.shift();
+ const lastItem = this.values.pop();
+ if (!lastItem) {
+ return dequeued;
+ }
+ this.values.unshift(lastItem);
+
+ let idxOfTarget = 0;
+
+ while (true) {
+ let idxOfLeftChild = idxOfTarget * 2 + 1;
+ let idxOfRightChild = idxOfTarget * 2 + 2;
+ let leftChild = this.values[idxOfLeftChild];
+ let rightChild = this.values[idxOfRightChild];
+
+ function swap(direction) {
+ const idxOfChild =
+ direction == 'left' ? idxOfLeftChild : idxOfRightChild;
+ const child = direction == 'left' ? leftChild : rightChild;
+ this.values[idxOfChild] = this.values[idxOfTarget];
+ this.values[idxOfTarget] = child;
+ idxOfTarget = idxOfChild;
+ }
+
+ if (!leftChild) {
+ return dequeued;
+ }
+
+ if (!rightChild) {
+ if (leftChild.priority < lastItem.priority) {
+ swap.call(this, 'left');
+ continue;
+ }
+ return dequeued;
+ }
+
+ if (leftChild.priority == rightChild.priority) {
+ swap.call(this, 'left');
+ continue;
+ }
+
+ if (
+ leftChild.priority < rightChild.priority &&
+ leftChild.priority < lastItem.priority
+ ) {
+ swap.call(this, 'left');
+ continue;
+ }
+
+ if (
+ rightChild.priority < leftChild.priority &&
+ rightChild.priority < lastItem.priority
+ ) {
+ swap.call(this, 'right');
+ continue;
+ }
+ }
+ },
+ };
+
+ const WeightedGraph = {
+ init: function () {
+ this.adjacencyList = {};
+ this.length = 0;
+ },
+ addVertex: function (vertex) {
+ if (!this.adjacencyList.hasOwnProperty(vertex)) {
+ this.adjacencyList[vertex] = {};
+ this.length++;
+ }
+ },
+ addEdge: function (vertex1, vertex2, weight) {
+ this.addVertex(vertex1);
+ this.addVertex(vertex2);
+ this.adjacencyList[vertex1][vertex2] = weight;
+ this.adjacencyList[vertex2][vertex1] = weight;
+ return this.adjacencyList;
+ },
+ removeEdge: function (vertex1, vertex2) {
+ if (!this.adjacencyList.hasOwnProperty(vertex1)) {
+ return `There's no ${vertex1}`;
+ }
+ if (!this.adjacencyList.hasOwnProperty(vertex2)) {
+ return `There's no ${vertex2}`;
+ }
+
+ function removeHelper(v1, v2) {
+ if (!this.adjacencyList.hasOwnProperty(v1)) {
+ return `There's no edge between ${v1} and ${v2}`;
+ }
+ delete this.adjacencyList[v1][v2];
+ if (Object.keys(this.adjacencyList[v1]).length == 0) {
+ delete this.adjacencyList[v1];
+ }
+ }
+
+ removeHelper.call(this, vertex1, vertex2);
+ removeHelper.call(this, vertex2, vertex1);
+
+ return this.adjacencyList;
+ },
+ removeVertex: function (vertex) {
+ if (!this.adjacencyList.hasOwnProperty(vertex)) {
+ return `There's no ${vertex}`;
+ }
+ const edges = this.adjacencyList[vertex];
+ for (const key in edges) {
+ this.removeEdge(key, vertex);
+ }
+ return this.adjacencyList;
+ },
+ findShortestRoute: function (start, end) {
+ if (!start || !end) {
+ return;
+ }
+ const distance = {};
+ const previous = {};
+ const pq = Object.create(PriorityQueue);
+ pq.init();
+ pq.enqueue(start, 0);
+ const visited = {};
+
+ const hashOfVertex = this.adjacencyList;
+ for (const vertexName in hashOfVertex) {
+ const priority = vertexName == start ? 0 : Infinity;
+ distance[vertexName] = priority;
+ previous[vertexName] = null;
+ }
+
+ while (true) {
+ let current = pq.dequeue();
+ if (!current?.val) {
+ return { error: NOT_CONNECTION_ERROR };
+ }
+ current = current.val;
+ if (current == end) {
+ break;
+ }
+ const neighbors = hashOfVertex[current];
+
+ for (const vertexName in neighbors) {
+ if (visited.hasOwnProperty(vertexName)) {
+ continue;
+ }
+ const distFromStart = distance[current] + neighbors[vertexName];
+
+ if (distFromStart < distance[vertexName]) {
+ pq.enqueue(vertexName, distFromStart);
+ distance[vertexName] = distFromStart;
+ previous[vertexName] = current;
+ }
+ }
+ visited[current] = true;
+ }
+
+ let node = end;
+
+ const route = [];
+ while (node) {
+ route.unshift(node);
+ node = previous[node];
+ }
+ return { route, distance };
+ },
+ };
+
+ this.addEdge = (source, target, weight) => {
+ WeightedGraph.addEdge(source, target, weight);
+ };
+
+ this.findShortestPath = (source, target) => {
+ return WeightedGraph.findShortestRoute(source, target);
+ };
+
+ this.addVertex = vertex => {
+ WeightedGraph.addVertex(vertex);
+ };
+
+ this.callAdjacencyList = () => {
+ return WeightedGraph.adjacencyList;
+ };
+
+ WeightedGraph.init();
+}
diff --git a/src/utils/constants.js b/src/utils/constants.js
new file mode 100644
index 00000000..b4674734
--- /dev/null
+++ b/src/utils/constants.js
@@ -0,0 +1,8 @@
+export const INPUT_ERROR = {
+ NO_INPUT_ERROR: '์ถ๋ฐ์ง์ ๋์ฐฉ์ง๋ฅผ ๋ชจ๋ ์
๋ ฅํด์ผ ํฉ๋๋ค.',
+ LESS_THAN_TWO_ERROR: '์ญ ์ด๋ฆ์ 2๊ธ์ ์ด์ ์
๋๋ค.',
+ NOT_INCLUDES_ERROR: '์กด์ฌํ์ง ์๋ ์ญ์
๋๋ค.',
+ SAME_STATION_ERROR: '์ถ๋ฐ์ญ๊ณผ ๋์ฐฉ์ญ์ด ๋์ผํฉ๋๋ค.',
+};
+
+export const NOT_CONNECTION_ERROR = '์ญ์ด ์ฐ๊ฒฐ๋์ด ์์ง ์์ต๋๋ค.';
diff --git a/src/utils/validation.js b/src/utils/validation.js
new file mode 100644
index 00000000..568e3745
--- /dev/null
+++ b/src/utils/validation.js
@@ -0,0 +1,22 @@
+import { INPUT_ERROR } from './constants.js';
+
+export default function stationValidation(start, end, stations) {
+ if (noInput(start) || noInput(end)) {
+ return { error: INPUT_ERROR.NO_INPUT_ERROR };
+ }
+ if (ltTwo(start) || ltTwo(end)) {
+ return { error: INPUT_ERROR.LESS_THAN_TWO_ERROR };
+ }
+ if (!stations.includes(start) || !stations.includes(start))
+ return { error: INPUT_ERROR.NOT_INCLUDES_ERROR };
+ if (start === end) return { error: INPUT_ERROR.SAME_STATION_ERROR };
+ return { success: true };
+}
+
+const noInput = name => {
+ return name === '';
+};
+
+const ltTwo = name => {
+ return name.length < 2;
+};
diff --git a/src/views.js b/src/views.js
new file mode 100644
index 00000000..f1e96be7
--- /dev/null
+++ b/src/views.js
@@ -0,0 +1,26 @@
+export const showResult = (result, target) => {
+ let path = result.join(' โก');
+ const html = `
+ 
+
+- ์ถ๋ฐ์ญ๊ณผ ๋์ฐฉ์ญ์ ์
๋ ฅ๋ฐ์ ๊ฒฝ๋ก๋ฅผ ์กฐํํ๋ค.
+- ๊ฒฝ๋ก ์กฐํ ์ ์ด ๊ฑฐ๋ฆฌ, ์ด ์์ ์๊ฐ์ ํจ๊ป ์ถ๋ ฅํ๋ค.
+- ๊ฒฝ๋ก ์กฐํ ์ `์ต๋จ ๊ฑฐ๋ฆฌ` ๋๋ `์ต์ ์๊ฐ` ์ต์
์ ์ ํํ ์ ์๋ค.
+
+### ์์ธ ์ฒ๋ฆฌ
+- ์ถ๋ฐ์ญ๊ณผ ๋์ฐฉ์ญ์ 2๊ธ์ ์ด์์ด์ด์ผ ํ๋ค.
+- ์กด์ฌํ์ง ์๋ ์ญ์ ์ถ๋ฐ์ญ ๋๋ ๋์ฐฉ์ญ์ผ๋ก ์
๋ ฅํ ์ ์๋ค.
+- ๊ฒฝ๋ก ์กฐํ ์ ์ถ๋ฐ์ญ๊ณผ ๋์ฐฉ์ญ์ด ๊ฐ์ ์ ์๋ค.
+- ๊ฒฝ๋ก ์กฐํ ์ ์ถ๋ฐ์ญ๊ณผ ๋์ฐฉ์ญ์ด ์ฐ๊ฒฐ๋์ง ์์ผ๋ฉด ๊ฒฝ๋ก๋ฅผ ์กฐํํ ์ ์๋ค.
+- ๊ทธ ์ธ ์ ์์ ์ผ๋ก ํ๋ก๊ทธ๋จ์ด ์ํ๋์ง ์์ ๊ฒฝ์ฐ `alert`์ผ๋ก ์๋ฌ๋ฅผ ์ถ๋ ฅํ๋ค.
+
+
+
+
+## โ
ํ๋ก๊ทธ๋๋ฐ ์๊ตฌ์ฌํญ
+### ๊ธธ์ฐพ๊ธฐ ๊ด๋ จ ๊ธฐ๋ฅ
+- ์ถ๋ฐ์ญ์ ์
๋ ฅํ๋ input ํ๊ทธ๋ `departure-station-name-input` id ์์ฑ๊ฐ์ ๊ฐ์ง๋ค.
+- ๋์ฐฉ์ญ์ ์
๋ ฅํ๋ input ํ๊ทธ๋ `arrival-station-name-input` id ์์ฑ๊ฐ์ ๊ฐ์ง๋ค.
+- ์ต๋จ๊ฑฐ๋ฆฌ, ์ต์์๊ฐ์ ์ ํํ๋ radio๋ `search-type` name ์์ฑ๊ฐ์ ๊ฐ์ง๋ค.
+ - **radio option์ default ๊ฐ์ ์ต๋จ๊ฑฐ๋ฆฌ์ด๋ค.**
+- ๊ธธ์ฐพ๊ธฐ ๋ฒํผ์ `search-button` id ์์ฑ๊ฐ์ ๊ฐ์ง๋ค.
+- ๐ ๊ฒฐ๊ณผ๋ `table`์ ์ด์ฉํ์ฌ ๋ณด์ฌ์ค๋ค.
+
+## โ๏ธํํธ
+## ๋ฐ์ดํฐ ์ด๊ธฐํ
+์๋ฐ์คํฌ๋ฆฝํธ์์ ๋ฐ์ดํฐ๋ฅผ ์ด๊ธฐํํ๋ ๋ฐฉ๋ฒ ์ค์ ํ๋๋ ์๋์ ๊ฐ์ด data๋ฅผ `export`ํ๊ณ , `import`ํ๋ ๊ฒ์ด๋ค.
+
+```javascript
+export const users = [
+ {
+ name: 'Alt'
+ },
+ {
+ name: 'Jamie'
+ },
+ {
+ name: 'Sony'
+ }
+]
+
+export const courses = [
+ {
+ name: 'frontend',
+ },
+ {
+ name: 'backend',
+ },
+ {
+ name: 'iOS',
+ },
+ {
+ name: 'Android',
+ }
+]
+
+```
+์์ ๊ฐ์ด ๋ฐ์ดํฐ๋ฅผ `export`ํ๋ฉด ์๋์ ๊ฐ์ด ๋ฐ์ดํฐ๋ฅผ `import` ํ์ฌ ์ฌ์ฉํ ์ ์๋ค.
+```javascript
+import { users, courses } from './data.js'
+
+function App() {
+ this.users = users
+ this.courses = courses
+}
+```
+
+## ์ต๋จ ๊ฒฝ๋ก ๋ผ์ด๋ธ๋ฌ๋ฆฌ
+- `utils/Dijkstra.js` ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํ์ฉํ๋ฉด ๊ฐํธํ๊ฒ ์ต๋จ๊ฑฐ๋ฆฌ๋ฅผ ์กฐํํ ์ ์๋ค.
+- ์ ์ (Vertex)๊ณผ ๊ฐ์ (Edge), ๊ทธ๋ฆฌ๊ณ ๊ฐ์ค์น ๊ฐ๋
์ ์ด์ฉ
+ - ์ ์ : ์งํ์ฒ ์ญ
+ - ๊ฐ์ : ์งํ์ฒ ์ญ ์ฐ๊ฒฐ์ ๋ณด
+ - ๊ฐ์ค์น: ๊ฑฐ๋ฆฌ or ์์ ์๊ฐ
+- ์ต๋จ ๊ฑฐ๋ฆฌ ๊ธฐ์ค ์กฐํ ์ ๊ฐ์ค์น๋ฅผ ๊ฑฐ๋ฆฌ๋ก ์ค์
+- ์ต์ ์๊ฐ ๊ธฐ์ค ์กฐํ ์ ๊ฐ์ค์น๋ฅผ ์๊ฐ์ผ๋ก ์ค์
+
+```javascript
+import Dijkstra from "./utils/Dijkstra.js";
+const dijkstra = new Dijkstra()
+
+//dijkstra.addEdge("์ถ๋ฐ์ญ", "๋์ฐฉ์ญ", ๊ฑฐ๋ฆฌ ๋๋ ์๊ฐ);
+dijkstra.addEdge("V1", "V2", 2);
+dijkstra.addEdge("V2", "V3", 2);
+dijkstra.addEdge("V1", "V3", 100);
+
+const result = dijkstra.findShortestPath("V1", "V3");
+// result = ["V1", "V2", "V3"]
+```
+
+#### ํ
์คํธ์ค๋ช
+
+
+- ์ญ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ ๋ คํ์ง ์๋ ๊ฒฝ์ฐ V1->V3 ๊ฒฝ๋ก๊ฐ ์ต๋จ ๊ฒฝ๋ก
+- ์ญ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ ๋ คํ ๊ฒฝ์ฐ V1->V3 ๊ฒฝ๋ก์ ๊ฑฐ๋ฆฌ๋ 100km, V1->V2->V3 ๊ฒฝ๋ก์ ๊ฑฐ๋ฆฌ๋ 4km์ด๋ฏ๋ก ์ต๋จ ๊ฒฝ๋ก๋ V1->V2->V3
+
+