+
+
+
diff --git a/src/data.js b/src/data.js
new file mode 100644
index 0000000..6f4f033
--- /dev/null
+++ b/src/data.js
@@ -0,0 +1,58 @@
+export const lineTwo = [
+ {
+ station : '๊ต๋',
+ distance : 2,
+ time : 3
+ },
+ {
+ station : '๊ฐ๋จ',
+ distance : 2,
+ time : 3
+ },
+ {
+ station : '์ญ์ผ',
+ distance : 0,
+ time : 0
+ }
+]
+
+export const lineThree = [
+ {
+ station : '๊ต๋',
+ distance : 3,
+ time : 2
+ },
+ {
+ station : '๋จ๋ถํฐ๋ฏธ๋',
+ distance : 6,
+ time : 5
+ },
+ {
+ station : '์์ฌ',
+ distance : 1,
+ time : 1
+ },
+ {
+ station : '๋งค๋ด',
+ distance : 0,
+ time : 0
+ }
+]
+
+export const lineBoondang = [
+ {
+ station : '๊ฐ๋จ',
+ distance : 2,
+ time : 8
+ },
+ {
+ station : '์์ฌ',
+ distance : 10,
+ time : 3
+ },
+ {
+ station : '์์ฌ์๋ฏผ์์ฒ',
+ distance : 0,
+ time : 0
+ }
+]
\ No newline at end of file
diff --git a/src/index.js b/src/index.js
new file mode 100644
index 0000000..bcea73e
--- /dev/null
+++ b/src/index.js
@@ -0,0 +1,73 @@
+import { lineTwo, lineThree, lineBoondang } from "./data.js";
+import Dijkstra from "./utils/Dijkstra.js";
+import {isUnderTwoCharacters} from "./validation.js";
+
+let findRouteButton = document.getElementById('search-route');
+findRouteButton.addEventListener('click', showResult);
+
+function showResult() {
+ isUnderTwoCharacters();
+ document.getElementById("result").style.display="block";
+}
+
+export function findData(departureStation, arrivalStation) {
+ let v1 = '', v2 = '', v3 = '';
+ let distance = 0, time = 0;
+ let indexOfDeparture = 0;
+ let indexOfArrival = 0;
+ for (let i = 0; i < lineTwo.length; i += 1) {
+ if (departureStation === lineTwo[i].station) {
+ v1 = lineTwo[i].station;
+ distance += lineTwo[i].distance;
+ time += lineTwo[i].time;
+ indexOfDeparture = lineTwo.indexOf(lineTwo[i]);
+ }
+ if (arrivalStation === lineTwo[i].station) {
+ v3 = lineTwo[i].station;
+ indexOfArrival = lineTwo.indexOf(lineTwo[i]);
+ }
+ if (indexOfDeparture - indexOfArrival > 1) {
+ v2 = lineTwo[i-1].station;
+ distance += lineTwo[i].distance;
+ time += lineTwo[i].time;
+ }
+ }
+ getShortestPath(v1, v2, v3, distance, time);
+}
+
+function getShortestPath(v1, v2, v3, distance, time) {
+ let dijkstra = new Dijkstra();
+ dijkstra.addEdge(v1, v2, lineTwo[0].distance);
+ dijkstra.addEdge(v2, v3, lineTwo[1].distance);
+ dijkstra.addEdge(v1, v3, lineTwo[0].distance + lineTwo[1].distance);
+ const shortestPathOfDistance = dijkstra.findShortestPath(v1,v3);
+
+ dijkstra.addEdge(v1, v2, lineTwo[0].time);
+ dijkstra.addEdge(v2, v3, lineTwo[1].time);
+ dijkstra.addEdge(v1, v3, lineTwo[0].time + lineTwo[1].time);
+ const shortestPathOfTime = dijkstra.findShortestPath(v1,v3);
+
+ makeTable(distance, time, shortestPathOfDistance, shortestPathOfTime);
+}
+
+
+function makeTable( distance, time, shortestPathOfDistance) {
+ let container = document.getElementById('print-result-container');
+ let resultTable = document.createElement('table');
+ let headerRow = resultTable.insertRow(0);
+ let firstRow = resultTable.insertRow(1);
+ let secondRow = resultTable.insertRow(2);
+ let headerCell1 = headerRow.insertCell(0);
+ let headerCell2 = headerRow.insertCell(1);
+ let firstRowCell1 = firstRow.insertCell(0);
+ let firstRowCell2 = firstRow.insertCell(1);
+ let secondRowCell1 = secondRow.insertCell(0);
+ headerCell1.innerHTML = '์ด ๊ฑฐ๋ฆฌ';
+ headerCell2.innerHTML = '์ด ์์ ์๊ฐ';
+ firstRowCell1.innerHTML = `${distance}km`;
+ firstRowCell2.innerHTML = `${time}๋ถ`;
+ secondRowCell1.innerHTML = `${shortestPathOfDistance}`;
+ resultTable.border = 1;
+ resultTable.id = 'print-result-table';
+ container.appendChild(resultTable);
+}
\ No newline at end of file
diff --git a/src/utils/Dijkstra.js b/src/utils/Dijkstra.js
new file mode 100644
index 0000000..7c6cfd5
--- /dev/null
+++ b/src/utils/Dijkstra.js
@@ -0,0 +1,220 @@
+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) {
+ throw Error("์ถ๋ฐ์ง์ ๋์ฐฉ์ง๋ฅผ ๋ชจ๋ ์
๋ ฅํด์ผ ํฉ๋๋ค.");
+ }
+ 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;
+ }
+ 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;
+ },
+ };
+
+ 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);
+ };
+
+ WeightedGraph.init();
+}
diff --git a/src/validation.js b/src/validation.js
new file mode 100644
index 0000000..d783180
--- /dev/null
+++ b/src/validation.js
@@ -0,0 +1,27 @@
+import {findData} from "./index.js";
+
+export function isUnderTwoCharacters() {
+ let departureStation = document.getElementById('departure-station-name-input').value;
+ let arrivalStation = document.getElementById('arrival-station-name-input').value;
+
+ if (departureStation.length < 2 || arrivalStation.length < 2) {
+ console.log(departureStation);
+ alert("๋์๋ฆฌ ์ด์์ ์ญ ์ด๋ฆ์ ์
๋ ฅํด์ฃผ์ธ์.");
+ }
+ isNotUsuableDepartureStation(departureStation, arrivalStation);
+ findData(departureStation, arrivalStation)
+}
+
+export let stationNameList = ['๊ต๋', '๊ฐ๋จ', '์ญ์ผ', '๋จ๋ถํฐ๋ฏธ๋', '์์ฌ', '์์ฌ์๋ฏผ์์ฒ', '๋งค๋ด'];
+export function isNotUsuableDepartureStation(departureStation, arrivalStation) {
+ if ((stationNameList.includes(departureStation) === false) || (stationNameList.includes(arrivalStation) === false)) {
+ alert("์ฌ์ฉ ๊ฐ๋ฅํ ์ญ ์ด๋ฆ(๋ค)์ด ์๋๋๋ค.");
+ }
+ isSameStations(departureStation, arrivalStation);
+}
+
+export function isSameStations(departureStation, arrivalStation) {
+ if (departureStation === arrivalStation) {
+ alert("์ถ๋ฐ์ญ๊ณผ ๋์ฐฉ์ญ์ด ๊ฐ์ ์ ์์ต๋๋ค.");
+ }
+}
+
+- ์ถ๋ฐ์ญ๊ณผ ๋์ฐฉ์ญ์ ์
๋ ฅ๋ฐ์ ๊ฒฝ๋ก๋ฅผ ์กฐํํ๋ค.
+- ๊ฒฝ๋ก ์กฐํ ์ ์ด ๊ฑฐ๋ฆฌ, ์ด ์์ ์๊ฐ์ ํจ๊ป ์ถ๋ ฅํ๋ค.
+- ๊ฒฝ๋ก ์กฐํ ์ `์ต๋จ ๊ฑฐ๋ฆฌ` ๋๋ `์ต์ ์๊ฐ` ์ต์
์ ์ ํํ ์ ์๋ค.
+
+### ์์ธ ์ฒ๋ฆฌ
+- ์ถ๋ฐ์ญ๊ณผ ๋์ฐฉ์ญ์ 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`์ ์ด์ฉํ์ฌ ๋ณด์ฌ์ค๋ค.
+
+
+### ์๊ตฌ์ฌํญ
+- ์ฌ์ฉ์๊ฐ ์๋ชป๋ ์
๋ ฅ ๊ฐ์ ์์ฑํ ๊ฒฝ์ฐ `alert`์ ์ด์ฉํด ๋ฉ์์ง๋ฅผ ๋ณด์ฌ์ฃผ๊ณ , ์ฌ์
๋ ฅํ ์ ์๊ฒ ํ๋ค.
+- ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ(jQuery, Lodash ๋ฑ)๋ฅผ ์ฌ์ฉํ์ง ์๊ณ , ์์ Vanilla JS๋ก๋ง ๊ตฌํํ๋ค.
+- **์๋ฐ์คํฌ๋ฆฝํธ ์ฝ๋ ์ปจ๋ฒค์
์ ์งํค๋ฉด์ ํ๋ก๊ทธ๋๋ฐ** ํ๋ค
+ - [https://google.github.io/styleguide/jsguide.html](https://google.github.io/styleguide/jsguide.html)
+ - [https://ui.toast.com/fe-guide/ko_CODING-CONVENSION/](https://ui.toast.com/fe-guide/ko_CODING-CONVENTION)
+- **indent(์ธ๋ดํธ, ๋ค์ฌ์ฐ๊ธฐ) depth๋ฅผ 3์ด ๋์ง ์๋๋ก ๊ตฌํํ๋ค. 2๊น์ง๋ง ํ์ฉ**ํ๋ค.
+ - ์๋ฅผ ๋ค์ด while๋ฌธ ์์ if๋ฌธ์ด ์์ผ๋ฉด ๋ค์ฌ์ฐ๊ธฐ๋ 2์ด๋ค.
+ - ํํธ: indent(์ธ๋ดํธ, ๋ค์ฌ์ฐ๊ธฐ) depth๋ฅผ ์ค์ด๋ ์ข์ ๋ฐฉ๋ฒ์ ํจ์(๋๋ ๋ฉ์๋)๋ฅผ ๋ถ๋ฆฌํ๋ฉด ๋๋ค.
+- **ํจ์(๋๋ ๋ฉ์๋)์ ๊ธธ์ด๊ฐ 15๋ผ์ธ์ ๋์ด๊ฐ์ง ์๋๋ก ๊ตฌํํ๋ค.**
+ - ํจ์(๋๋ ๋ฉ์๋)๊ฐ ํ ๊ฐ์ง ์ผ๋ง ์ ํ๋๋ก ๊ตฌํํ๋ค.
+- ๋ณ์ ์ ์ธ์ [var](https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Statements/var) ๋ฅผ ์ฌ์ฉํ์ง ์๋๋ค. [const](https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Statements/const) ์ [let](https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Statements/let) ์ ์ฌ์ฉํ๋ค.
+- [import](https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Statements/import) ๋ฌธ์ ์ด์ฉํด ์คํฌ๋ฆฝํธ๋ฅผ ๋ชจ๋ํํ๊ณ ๋ถ๋ฌ์ฌ ์ ์๊ฒ ๋ง๋ ๋ค.
+- [template literal](https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Template_literals)์ ์ด์ฉํด ๋ฐ์ดํฐ์ html string์ ๊ฐ๋
์ฑ ์ข๊ฒ ํํํ๋ค.
+
+