최단 경로 알고리즘 정리: 다익스트라 vs 플로이드-와샬

1. 최단 경로 알고리즘 개요

최단 경로 알고리즘은 다음과 같이 분류

• 단일 출발점(Single-Source): 하나의 노드에서 모든 노드까지의 최단 경로 계산 → 다익스트라, 벨만-포드(Bellman-Ford)
• 전체 쌍(All-Pairs): 모든 노드 쌍 사이의 최단 경로 계산
  → 플로이드-와샬, 존슨(Johnson)

2. 다익스트라 알고리즘

기본 개념

• 그리디(Greedy) 전략 기반
• 음수가 아닌 가중치만 처리 가능
• 우선순위 큐를 사용해 최적화(O((V+E) log V))

동작 원리

1. 출발 노드의 거리를 0, 나머지는 ∞로 초기화

2. 미방문 노드 중 최소 거리 노드 선택

3. 선택 노드의 인접 노드 거리 갱신

4. 모든 노드 방문 시까지 반복

   • 그래프에서 출발점과 도착점 사이의 최단 거리를 구하는 알고리즘
   • 보통 단일 정점 간 최단 경로 산출 시 사용, 도로 교통망이나 OSPF 등의 네트워크 라우팅 프로토콜에 널리 이용

     // ShortestPath() : edge object 객체 저장을 위한 생성자
     // key: vertex
     // value: list 형태로 연결된 vertex를 표현하여 edge 연결 관계 표현
     function ShortestPath() {
     this.edges = {};
     }
     

// addVertex() : 정점 추가(간선 비용 표시를 위해 key/value object 형태로 저장) ShortestPath.prototype.addVertex = function (vertex) { this.edges[vertex] = {}; };

// addEdge() : 간선 추가 ShortestPath.prototype.addEdge = function (srcVertex, dstVertex, weight) { this.edges[srcVertex][dstVertex] = weight; };

// _extractMin() : 최단 거리 노드 검색 ShortestPath.prototype._extractMin = function (queue, dist) { let minDistance = Number.POSITIVE_INFINITY; let minVertex = null;

for (let vertex in queue) { if (dist[vertex] <= minDistance) { minDistance = dist[vertex]; minVertex = vertex; } }

return minVertex; };

// dijkstra() : 다익스트라 최단 경로 탐색 ShortestPath.prototype.dijkstra = function (start) { let queue = {}; let dist = {};

for (let vertex in this.edges) { dist[vertex] = Number.POSITIVE_INFINITY; queue[vertex] = this.edges[vertex]; }

dist[start] = 0; while (Object.keys(queue).length != 0) { let u = this._extractMin(queue, dist);

delete queue[u];

for (let neighbor in this.edges[u]) {
  let alt = dist[u] + this.edges[u][neighbor];
  if (alt < dist[neighbor]) dist[neighbor] = alt;
}

}

for (let vertex in this.edges) { if (dist[vertex] === Number.POSITIVE_INFINITY) delete dist[vertex];

return dist; };

---

## 3. 플로이드-와샬 알고리즘

### 기본 개념
- **동적 계획법(DP)** 기반
- **음수 가중치** 허용(단, 음수 사이클 제외)
- 모든 노드 쌍의 최단 경로를 O(V³) 시간에 계산

### 동작 원리
1. 인접 행렬로 거리 초기화
2. 각 노드를 중간 경유지로 사용해 거리 갱신
3. 3중 반복문으로 모든 조합 검사

- 동적 계획법을 활용해, 그래프에서 가능한 모든 정점 쌍에 대해 최단 거리를 구하는 알고리즘
- 음의 가중치가 있어도 사용 가능하며, 많은 수의 간선으로 이루어져 있는 밀집 그래프(Dense Graph)에 사용 적합

```javascript
// floydWarshall() : 플로이드-워셜 최단 경로 탐색
ShortestPath.prototype.floydWarshall = function () {
  let dist = {};

  for (let srcVertex in this.edges) {
    dist[srcVertex] = {};
    for (let dstVertex in this.edges) {
      if (srcVertex === dstVertex) dist[srcVertex][dstVertex] = 0;
      else dist[srcVertex][dstVertex] = Number.POSITIVE_INFINITY;
    }
  }

  for (let srcVertex in this.edges) {
    for (let dstVertex in this.edges[srcVertex])
      dist[srcVertex][dstVertex] = this.edges[srcVertex][dstVertex];
  }

  for (let midVertex in this.edges) 
    for (let srcVertex in this.edges)
      for (let dstVertex in this.edges)
        dist[srcVertex][dstVertex] = Math.min(dist[srcVertex][dstVertex], dist[srcVertex][midVertex] + dist[midVertex][dstVertex]);

  for (let srcVertex in this.edges)
    for (let dstVertex in this.edges)
      if (dist[srcVertex][dstVertex] === Number.POSITIVE_INFINITY)
        delete dist[srcVertex][dstVertex];

  return dist;
};

4. 알고리즘 비교

5. 선택 가이드

• 다익스트라가 적합한 경우:

  • 단일 출발점 문제
  • 그래프가 희소하고 가중치가 양수
  • 실시간 경로 계산이 필요할 때

• 플로이드-와샬이 적합한 경우:

  • 전체 노드 쌍의 경로가 필요
  • 그래프가 밀집되어 있음
  • 음수 가중치 존재 시

그래프(Graph)

• 정점과 간선으로 구성되어 네트워크 구조를 추상화한 비선형 자료 구조

• 그래프 특징

  • 정점(Vertex)과 간선(Edge)의 집합
  • 다양한 그래프 종류를 혼합하여 표현 가능

• 그래프 종류

  • 방향 그래프(Directed Graph) : 간선에 특정 방향이 존재하는 그래프(A -> B로 표현, A에서 B로만 이동 가능)
  • 무방향 그래프(Undirected Graph) : 간선에 특정 방향이 존재하지 않는 그래프(A - B로 표현, 양방향 이동 가능)
  • 가중치 그래프(Weighted Graph) : 간선에 비용이나 가중치가 할당된 그래프

• 그래프 종류 2

  • 연결 그래프(Connected Graph) : 무방향 그래프에 있는 모든 정점쌍에 대해 항상 경로가 존재하는 그래프
  • 비연결 그래프(Disconnected Graph) : 무방향 그래프에서 특정 정점쌍 사이에 경로가 존재하지 않는 그래프
  • 순환 그래프(Cycle) : 단순 경로의 시작 정점과 종료 지점이 동일하여 순환 지점이 존재하는 그래프
  • 비순환 그래프(Acyclic Graph) : 순환 지점이 존재하지 않는 그래프
  • 완전 그래프(Complete Graph) : 그래프에 속해 있는 모든 정점이 서로 연결되어 있는 그래프

• 그래프 표현 방법

  • 인접 리스트(Adjacency List) : 정점에 연결된 다른 정점을 리스트로 표현
  • 인접 행렬(Adjacency Matrix) : 정점에 연결된 다른 정점을 정점x정점 크기의 매트릭스로 표현

• 그래프 구현

  /* 방향 그래프 */
  // Graph(): edge object 객체 저장을 위한 생성자
  // key : vertex
  // value : list 형태로 연결된 vertex를 표현하여 edge 연결 관계 표현
  function Graph() {
  this.edge = {};
  }
  

// addVertex() : 정점(vertex) 추가 Graph.prototype.addVertex = function (v) { this.edge[v] = []; };

// addEdge() : 간선(edge) 추가 Graph.prototype.addEdge = function (v1, v2) { this.edge[v1].push(v2); };

// removeEdge(): 간선(edge) 삭제 Graph.prototype.removeEdge = function (v1, v2) { if (this.edge[v1]) { let idx = this.edge[v1].indexOf(v2);

if (idx != -1) {
  this.edge[v1].splice(idx, 1);
}

if (this.edge[v1].length === 0) {
  delete this.edge[v1];
}

} };

// removeVertex(): 정점(vertex) 삭제 Graph.prototype.removeVertex = function (v) { if (this.edge[v] === undefined) return;

let length = this.edge[v].length; // changed length let connectedVertex = [...this.edge[v]]; // object copy

for (let i = 0; i < length; i++) { this.removeEdge(v, connectedVertex[i]); } }:

// sizeVertex(): vertex 개수 반환 Graph.prototype.sizeVertex = function () { return Object.keys(this.edge).length; };

// sizeEdge() : edge 개수 반환 Graph.prototype.sizeEdge = function (vertex) { return this.edge[vertex] ? Object.keys(this.edge[vertex]).length : 0; };

// print() : 현재 Graph 연결 상태 출력 Graph.prototype.print = function () { for (let vertex in this.edge) { let neighbors = this.edge[vertex]; if (neighbors.length == 0) continue;

process.stdout.write(`${vertex} -> `);
for (let j = 0; j < neighbors.length; j++) {
  process.stdout.write(`${neighbors[j]} `);
}

console.log("");

} };

/* 무방향 그래프 */

// addEdge() : 간선(edge) 추가 Graph.prototype.addEdge = function (v1, v2) { this.edge[v1].push(v2); this.edge[v2].push(v1); };

// removeEdge() : 간선(edge) 삭제 Graph.prototype.removeEdge = function (v1, v2) { if (this.edge[v2]) { let idx = this.edge[v2].indexOf(v1);

if (idx != -1) {
  this.edge[v2].splice(idx, 1);
}

if (this.edge[v2].length === 0) {
  delete this.edge[v2];
}

} };

### DFS(Depth First Search)
- 트리나 그래프 등에서 하나의 노드를 최대한 깊게 들어가면서 해를 찾는 탐색 기법
- 장/단점
  - 장점 : 인접한 후보 노드만 기억하면 되므로 적은 기억공간 소요, 노드가 깊은 단계에 있을 경우 빠르게 정답 산출
  - 단점 : 선택한 경로가 답이 아닐 경우 불필요한 탐색 가능, 최단 경로를 구할 시 찾은 해가 정답이 아닐 경우 발생
```javascript
// dfs() : DFS 탐색
Graph.prototype.dfs = function (startVertex) {
  this._dfsRecursiveVisit(startVertex);
};

// _dfsRecursiveVisit() : 재귀를 이용한 DFS 탐색
Graph.prototype._dfsRecursiveVisit = function (vertex) {
  if (this.visited[vertex]) {
    return;
  }

  this.visited[vertex] = true;
  console.log(`visit " ${vertex}"`);

  let neighbors = this.edge[vertex];
  for (let i = 0; i < neighbors.length; i++) {
    this._dfsRecursiveVisit(neighbors[i]);
  }
};

// dfs() : DFS 탐색
Graph.prototype.dfs = function (startVertex) {
  this._dfsLoopVisit(startVertex);
};

// _dfsLoopVisit() : 스택을 이용한 DFS 탐색
Graph.prototype._dfsLoopVisit = function (vertex) {
  let stack = new Stack();
  stack.push(vertex);

  while (!stack.isEmpty()) {
    let vertex = stack.pop();
    if (this.visited[vertex]) {
      continue;
    }

    this.visited[vertex] = true;
    console.log(`visit "${vertex}"`);

    let neighbors = this.edge[vertex];
    for (let i = neighbors.length - 1; i >= 0; i--) {
      stack.push(neighbors[i]);
    }
  }
};

BFS(Breadth First Search)

• 트리나 그래프 등에서 인접한 노드를 우선 방문하면서 넓게 움직이며 해를 찾는 탐색 기법
• 장/단점
  • 장점 : 최단 경로 탐색에서 구한 해가 정답임을 보장
  • 단점 : 경로가 매우 길어질 경우, 탐색 범위가 증가하면서 DFS보다 많은 기억 공간이 필요

    // bfs() : BFS 탐색
    Graph.prototype.bfs = function (startVertex) {
    this._bfsLoopVisit(startVertex);
    };
    

// _bfsLoopVisit() : 큐를 이용한 BFS 탐색 Graph.prototype._bfsLoopVisit = function (vertex) { let queue = new Queue(); queue.enqueue(vertex);

while (!queue.isEmpty()) { let vertex = queue.dequeue(); if (this.visited[vertex]) { continue; }

this.visited[vertex] = true;
console.log(`visit "${vertex}"`);

let neighbors = this.edge[vertex];
for (let i = 0; i < neighbors.length; i++) {
  queue.enqueue(neighbors[i]);
}

} };

// _bfsShortestPath() : 다른 정점 간 최단 경로 비용 산출 Graph.prototype._bfsShortestPath = function (vertex) { let queue = new Queue(); queue.enqueue(vertex);

let distance = {}; let pre_visit = {}; for (let vertex in this.edge) { distance[vertex] = 0; pre_visit[vertex] = null; }

while(!queue.isEmpty()) { let vertex = queue.dequeue(); if (this.visited[vertex]) { continue; }

this.visited[vertex] = true;
console.log(`visit "${vertex}"`);

let neighbors = this.edge[vertex];
for (let i = 0; i < neighbors.length; i++) {
  distance[neighbors[i]] = distance[vertex] + 1;
  pre_visit[neighbors[i]] = vertex;
  queue.enqueue(neighbors[i]);
}

}

return { distance, pre_visit }; };

// _from_to_path() : from 정점에서 to 정점으로 최단 경로 출력 Graph.prototype._from_to_path = function (pre_visit, from, to) { let stack = new Stack();

for (let v = to; v !== from; v = pre_visit[v]) { stack.push(v); } stack.push(from);

while (!stack.isEmpty()) { let v = stack.pop(); process.stdout.write(${v} ->); } console.log("end"); };

// shortestPath(): 다른 정점 간 최단 경로 탐색 Graph.prototype.shortestPath = function (startVertex) { let result = this._bfsShortestPath(startVertex);

console.log(result.distance); console.log(result.pre_visit);

for (let vertex in this.edge) { if (vertex === startVertex) continue;

this._from_to_path(result.pre_visit, startVertex, vertex);

} }; ```

• 그래프의 일종으로 두 노드 사이의 하나의 간선만 연결되어 있는, 최소 연결과 계층 형태의 비선형 자료 구조

• 노드(node) : 하나 이상의 값을 갖는 객체 단위

• 간선(edge) : 두 노드를 연결하는 선

• 루트 노드(Root node) : 부모가 없는 최상위 노드

• 단말 노드(Leaf node) : 자식이 없는 노드

• 부모 노드(Parent node) : 특정 Sub-Tree 내에서의 상위 노드

• 자식 노드(Child node) : 특정 Sub-Tree 내에서의 하위 노드

• 형제(Sibling) : 부모가 없는 최상위 노드

• 트리 특징

  • 주요 특징 : '최소 연결 트리'로 불림, 계층 모델, 방향 비순환 그래프(DAG: Directed Acyclic Graph) 한 종류
  • 트리 종류 : 이진 트리, 이진 탐색 트리, AVL 트리, 힙(Heap)
  • 노드 크기(size) : 자신을 포함한 모든 자손 노드의 개수
  • 노드 깊이(depth) : 루트에서 특정 노드에 도달하기 위한 간선의 개수
  • 노드 레벨(level) : 트리의 특정 깊이를 가지는 노드의 집합
  • 노드 차수(degree) : 노드가 지닌 가지의 수
  • 트리 차수(tree degree) : 트리의 최대 차수
  • 트리 높이(height) : 루트 노드에서 가장 깊숙이 있는 노드의 깊이

• 트리 순회

  • 트리 구조에서 각각의 노드를 정확히 한 번씩 체계적인 방법으로 방문하는 과정
  • N(Node) : 해당 노드를 방문
  • L(Left) : 왼쪽 서브 트리로 이동
  • R(Right) : 오른쪽 서브 트리로 이동
  • 순회 방식
    • 전위 순회(Pre-order) : N-L-R
    • 중위 순회(In-order) : L-N-R
    • 후위 순회(Post-order) : L-R-N
    • 층별 순회(Level-order) : 낮은 Level부터 순차적으로 순회

이진 트리(Binary Tree)

• 각각의 노드가 최대 두개의 자식 노드를 가지는 트리 자료 구조

• 활용 방식

  • 검색과 정렬 : 이진 탐색 트리와 이진 힙 구현에 활용
  • 허프만 코딩 : 연관 분기 구조 위한 데이터 표현에 활용

• 이진 트리의 종류

  • 포화 이진 트리(Perfect binary Tree)
  • 완전 이진 트리(Complete binary Tree)
  • 정 이진 트리(Full binary Tree)
  • 편향 이진 트리(Skewed binary Tree)
  • 균형 이진 트리(Balanced binary Tree)

• 포화 이진 트리(Perfect binary Tree)

  • 모든 레벨의 노드가 가득 채워져 있는 트리
  • 특징
    • Leaf 노드를 제외한 모든 자식은 2개의 노드를 보유
    • 노드의 개수 n = 2^h - 1

• 완전 이진 트리(Complete binary Tree)

  • 마지막 레벨 전까지 노드가 가득 채워져 있고, 마지막 레벨은 왼쪽부터 순차적으로 채워져 있는 트리
  • 특징
    • 배열을 사용해 효율적인 표현 가능
    • 노드의 개수 : n < 2^h - 1

• 정 이진 트리(Full binary Tree)

  • 모든 노드가 0개 또는 2개의 자식 노드만 갖는 트리
  • 특징
    • proper 또는 plane 이진 트리라고도 불림
    • 노드의 개수 : n <= 2^h - 1

• 편향 이진 트리(Skewed binary Tree)

  • 왼쪽 혹은 오른쪽으로 편향되게 치우쳐 있는 트리
  • 특징
    • 각각의 높이에 하나의 노드만 존재
    • 노드의 개수 : h

• 균형 이진 트리(Balanced binary Tree)

  • 삽입/삭제가 이루어 질 때, 왼쪽 서브 트리와 오른쪽 서브 트리의 높이 차를 1 이하로 맞추는 이진 탐색 트리
  • 특징
    • 서브 트리 높이 차이가 항상 1 이하로 유지
    • 균형 트리 종류 : AVL 트리, Red-Black 트리, B트리, B+트리, B*트리

• 이진 트리 구현

  // Node() : value와 left, right node 저장을 위한 생성자
  function Node(value) {
  this.value = value;
  this.left = null;
  this.right = null;
  }
  

// BinaryTree() : 시작 노드인 root를 저장하기 위한 생성자 function BinaryTree() { this.root = null; }

// _insertNode() : 재귀로 트리를 순회하면 노드 추가 (내부 사용) BinaryTree.prototype._insertNode = function (node, value) { if (node === null) { node = new Node(value); } else if (value < node.value) { node.left = this._insertNode(node.left, value); } else if (value >= node.value) { node.right = this._insertNode(node.right, value); } return node; };

// insert() : 노드 추가 BinaryTree.prototype.insert = function (value) { this.root = this._insertNode(this.root, value); };

// _preOrderTraverseNode() : 재귀로 트리를 순회하며 전위 순회(내부 사용) BinaryTree.prototype._preOrderTraverseNode = function (node, callback) { if (node === null) { return; }

callback(node); this._preOrderTraverseNode(node.left, callback); this._preOrderTraverseNode(node.right, callback); };

// preOrderTraverse() : 전위 순회하며 노드 출력 BinaryTree.prototype.preOrderTraverse = function (callback) { this._preOrderTraverseNode(this.root, callback); };

// _inOrderTraverseNode() : 재귀로 트리를 순회하며 중위 순회(내부 사용) BinaryTree.prototype._inorderTraverseNode = function (node, callback) { if (node === null) { return; }

this._inOrderTraverseNode(node.left, callback); callback(node); this._inOrderTraverseNode(node.right, callback); };

// inOrderTraverse() : 중위 순회하며 노드 출력 BinaryTree.prototype.inOrderTraverse = function (callback) { this._inOrderTraverseNode(this.root, callback); };

// _postOrderTraverseNode() : 재귀로 트리를 순회하며 후위 순회(내부 사용) BinaryTree.prototype._postOrderTraverseNode = function (node, callback) { if (node === null) { return; }

this._postOrderTraverseNode(node.left, callback); this._postOrderTraverseNode(node.right, callback); callback(node); };

// postOrderTraverse() : 후위 순회하며 노드 출력 BinaryTree.prototype.postOrderTraverse = function (callback) { this._postOrderTraverseNode(this.root, callback); };

// Queue 객체 추가 function Queue(array) { this.array = array ? array : []; } Queue.prototype.isEmpty = function () { return this.array.length == 0; }; Queue.prototype.enqueue = function (element) { return this.array.push(element); }; Queue.prototype.dequeue = function () { return this.array.shift(); };

// levelOrderTraverse() : 층별 순회하며 노드 출력 BinaryTree.prototype.levelOrderTraverse = function (callback) { let q = new Queue(); let node; q.enqueue(this.root); while (!q.isEmpty()) { node = q.dequeue(); callback(node); if (node.left !== null) q.enqueue(node.left); if (node.right !== null) q.enqueue(node.right); } };

### 이진 탐색 트리
- 현재 노드를 기준으로 왼쪽에는 작은 값, 오른쪽에는 큰 값으로 정렬해 놓는 이진 트리 기반 자료 구조
```javascript
// Node() : value와 left, right node 저장을 위한 생성자
function Node(value) {
  this.value = value;
  this.left = null;
  this.right = null;
}

// BinarySearchTree() : 시작 노드인 root를 저장하기 위한 생성자
function BinarySearchTree() {
  this.root = null;
}

// _inOrderTraverseNode() : 재귀로 트리를 순회하며 중위 순회(내부 사용)
BinarySearchTree.prototype._inorderTraverseNode = function (node, callback) {
  if (node === null) {
    return;
  }

  this._inOrderTraverseNode(node.left, callback);
  callback(node);
  this._inOrderTraverseNode(node.right, callback);
};

// inOrderTraverse() : 중위 순회하며 노드 출력
BinarySearchTree.prototype.inOrderTraverse = function (callback) {
  this._inOrderTraverseNode(this.root, callback);
};

// _insertNode() : 재귀로 트리를 순회하면 노드 추가 (내부 사용)
BinarySearchTree.prototype._insertNode = function (node, value) {
  if (node === null) {
    node = new Node(value);
  } else if (value < node.value) {
    node.left = this._insertNode(node.left, value);
  } else if (value >= node.value) {
    node.right = this._insertNode(node.right, value);
  }
  return node;
};

// insert() : 노드 추가
BinarySearchTree.prototype.insert = function (value) {
  this.root = this._insertNode(this.root, value);
};

// _minNode() : 반복문으로 트리를 순회하며 최솟값 노드 탐색
BinarySearchTree.prototype._minNode = function (node) {
  if (node === null) {
    return null;
  }

  while (node && node.left !== null) {
    node = node.left;
  }

  return node.value;
};

// _maxNode() : 반복문으로 트리를 순회하며 최댓값 노드 탐색
BinarySearchTree.prototype._maxNode = function (node) {
  if (node === null) {
    return null;
  }

  while (node && node.right !== null) {
    node = node.right;
  }

  return node.value;
};

// min() : 최솟값 노드 탐색
BinarySearchTree.prototype.min = function () {
  return this._minNode(this.root);
};

// max() : 최댓값 노드 탐색
BinarySearchTree.prototype.max = function () {
  return this._maxNode(this.root);
};

// _searchNode() : 재귀로 트리를 순회하며 값을 만족하는 노드 탐색
BinarySearchTree.prototype._searchNode = function (node, value) {
  if (node === null) {
    return false;
  }

  if (node.value === value) {
    return true;
  } else if (node.value > value) {
    return this._searchNode(node.left, value);
  } else if (node.value < value) {
    return this._searchNode(node.right, value);
  }
};

// search() : value 노드 탐색
BinarySearchTree.prototype.search = function (value) {
  return this._searchNode(this.root, value);
};

// _finMinNode() : 반복문으로 트리를 순회하며 최솟값을 보유한 노드 탐색
BinarySearchTree.prototype._findMinNode = function (node) {
  while (node && node.left !== null)
    node = node.left;

  return node;
};

// _removeNode() : 재귀로 트리를 순회하며 값을 만족하는 노드를 찾고 삭제
BinarySearchTree.prototype._removeNode = function (node, value) {
  if (node === null)
    return null;
  if (node.value === value) {
    // case 1 : leaf node
    if (node.left === null && node.right === null) {
      node = null;
    }
    // case 2 : 1 child node
    else if (node.left === null) {
      node = node.right;
    } else if (node.right === null) {
      node = node.left;
    }
    // case 3 : 2 child node
    else {
      let aux = this._findMinNode(node.right);
      node.value = aux.value;
      node.right = this._removeNode(node.right, aux.value);
    }
  } else if (node.value > value) {
    node.left = this._removeNode(node.left, value);
  } else if (node.value < value) {
    node.right = this._removeNode(node.right, value);
  }
  return node;
};

// remove() : 노드 삭제
BinarySearchTree.prototype.remove = function (value) {
  root = this._removeNode(this.root, value);
};

• 먼저 해시함수란?

  • 임의의 길이의 데이터를 고정된 길이의 데이터로 매핑하는 함수
  • 해시 함수 특성
    • 압축성 : 다양한 가변 길이의 입력에 대해 고정된 크기의 결과값을 반환하는 성질
    • 효율성 : 어떤 입력 값에 대해서도 많은 자원과 시간이 소요되지 않고 처리되는 성질
    • 저항성 : 결과값을 바탕으로 입력 값을 찾는 것이 불가능한 성질

• 해시테이블

  • Hash 함수를 사용하여 평균 O(1) 시간 복잡도로 특정 값을 신속하게 찾는 자료 구조
  • 충돌(Collision) 해결방법
    • 해시 함수 변경 : 더 큰 숫자의 공간과 Modular 산술 값을 이용해 충돌 최소화
    • 자료구조 확장 : Open Addressing Method(선형 조사법, 이중 해시), Close Addressing Method(체이닝)

      const HASH_SIZE = 37;
      

// Element() : key, value 저장을 위한 생성자 function Element(key, value) { this.key = key; this.value = value; }

// HashTable() : 생성자 function HashTable() { this.table = new Array(HASH_SIZE); this.length = 0; }

// hashCode() : 해시 함수 HashTable.prototype.hashCode = function (key) { let hash = 0; for (let i = 0; i < key.length; i++) { hash += key.charCodeAt(i); } return hash % HASH_SIZE; };

// put() : 데이터 추가 HashTable.prototype.put = function (key, value) { let index = this.hashCode(key); console.log(key: ${key} -> index: ${index});

if (this.table[index] !== undefined) { return false; }

this.table[index] = new Element(key, value); this.length++;

return true; };

// get() : 데이터 조회 HashTable.prototype.get = function (key) { return this.table[this.hashCode(key)]; };

// remove() : 데이터 삭제 HashTable.prototype.remove = function (key) { let element = this.table[this.hashCode(key)];

if (element !== undefined) { delete this.table[this.hashCode(key)]; this.length--; }

return element; };

// clear() : 초기화 HashTable.prototype.clear = function () { this.table = new Array(HASH_SIZE); this.length = 0; };

// size() : 크기 반환 HashTable.prototype.size = function () { return this.length; };

// getBuffer() : 데이터 셋 반환 HashTable.prototype.getBuffer = function () { let array = []; for (let i = 0; i< this.table.length; i++) { if (this.table[i]) { array.push(this.table[i]); } } return array; };

// print() : 데이터 셋 출력 HashTable.prototype.print = function () { for (let i = 0; i < this.table.length; i++) { if (this.table[i]) { console.log(i + " -> " + this.table[i].key + ": " + this.table[i].value); } } };

- 충돌해결, 해시함수 변경을 통해서 충돌을 최소화함
```javascript
// loselose
const HASH_SIZE = 37;

// hashCode() : 해시 함수
HashTable.prototype.hashCode = function (key) {
  let hash = 0;
  for (let i = 0; i < key.length; i++) {
    hash += key.charCodeAt(i);
  }
  return hash % HASH_SIZE;
};

// use djb2 hash size
const HASH_SIZE = 1013;

// hashCode() : 해시 함수
HashTable.prototype.hashCode = function (key) {
  let hash = 5381;
  for (let i = 0; i < key.length; i++) {
    hash = hash * 33 + key.charCodeAt(i);
  }
  return hash % HASH_SIZE;
};

선형 조사법 해시테이블

• Hash 충돌이 발생했을 때, 그 다음 주소를 확인하고 비어 있다면 그 자리에 대신 저장하는 해시테이블 기반 자료구조

  cosnt HASH_SIZE = 5; // 충돌을 위해 변경
  

// Element() : Key, value 저장을 위한 생성자 function Element(key, value) { this.key = key; this.value = value; }

// LinearHashTable() : 생성자 function LinearHashTable() { this.table = new Array(HASH_SIZE); this.length = 0; }

// hashCode() : 해시 함수 LinearHashTable.prototype.hashCode = function (key) { let hash = 0; for (let i = 0; i < key.length; i++) { hash += key.charCodeAt(i); } return hash % HASH_SIZE; };

// clear() : 초기화 LinearHashTable.prototype.clear = function () { this.table = new Array(HASH_SIZE); this.length = 0; };

// size() : 크기 반환 LinearHashTable.prototype.size = function () { return this.length; };

// getBuffer() : 데이터 셋 반환 LinearHashTable.prototype.getBuffer = function () { let array = []; for (let i = 0; i < this.table.length; i++) { if (this.table[i]) { array.push(this.table[i]); } } return array; };

// print() : 데이터 셋 출력 LinearHashTable.prototype.print = function () { for (let i = 0; i < this.table.length; i++) { if (this.table[i]) { console.log(i + " -> " + this.table[i].key + ": " + this.table[i].value); } } };

// put() : 데이터 추가 LinearHashTable.prototype.put = function (key, value) { let index = this.hashCode(key); let startIndex = index; console.log(key: ${key} -> index: ${index});

do { if (this.table[index] === undefined) { this.table[index] = new Element(key, value); this.length++;

  return true;
}

index = (index + 1) % HASH_SIZE;

} while (index !== startIndex);

return false; };

// get() : 데이터 조회 LinearHashTable.prototype.get = function (key) { let index = this.hashCode(key); let startIndex = index;

do { if (this.table[index] !== undefined && this.table[index].key === key) { return this.table[index].value; }

index = (index + 1) % HASH_SIZE;

} while (index !== startIndex);

return undefined; };

// remove() : 데이터 삭제 LinearHashTable.prototype.remove = function (key) { let index = this.hashCode(key); let startIndex = index;

do { if (this.table[index] !== undefined && this.table[index].key === key) { let element = this.table[index]; delete this.table[index]; this.length--;

  return element;
}

index = (index + 1) % HASH_SIZE;

} while (index !== startIndex);

return undefined; };

### 체이닝 해시테이블
- 별도의 자료구조인 연결리스트를 병합 사용하여 Hash 충돌을 해결한 해시테이블 기반 자료구조
```javascript
// 앞서 LinkedList를 모듈로 가져와서 사용

const HASH_SIZE = 37;

// Element() : key, value 저장을 위한 생성자
function Element(key, value) {
  this.key = key;
  this.value = value;
}

// ChainingHashTable() : 생성자
function ChainingHashTable() {
  this.table = new Array(HASH_SIZE);
  this.length = 0;
}

// hashCode() : 해시 함수
ChainingHashTable.prototype.hashCode = function (key) {
  let hash = 0;
  for (let i = 0; i < key.length; i++) {
    hash += key.charCodeAt(i);
  }
  return hash % HASH_SIZE;
};

// clear() : 초기화
ChainingHashTable.prototype.clear = function () {
  this.table = new Array(HASH_SIZE);
  this.length = 0;
};

// size() : 크기 반환
ChainingHashTable.prototype.size = function () {
  return this.length;
};

// put() : 데이터 추가
ChainingHashTable.prototype.put = function (key, value) {
  let index = this.hashCode(key);
  console.log(`key: ${key} -> index: ${index}`);

  if (this.table[index] === undefined) {
    this.table[index] = new LinkedList();
  }

  this.table[index].append(new Element(key, value));
  this.length++;

  return true;
};

// getBuffer() : 데이터 셋 반환
ChainingHashTable.prototype.getBuffer = function () {
  let array = [];
  for (let i = 0; i < this.table.length; i++) {
    if (this.table[i]) {
      let current = this.table[i].head;
      do {
        array.push(current.data);
        current = current.next;
      } while (current);
    }
  }
  return array;
};

// print() : 데이터 셋 출력
ChainingHashTable.prototype.print = function () {
  for (let i = 0; i < this.table.length; i++) {
    if (this.table[i]) {
      let current = this.table[i].head;
      process.stdout.write(`#${i}`);
      do {
        process.stdout.write(` -> ${current.data.key}: ${current.data.value}`);
        current = current.next;
      } while (current);
      console.log("");
    }
  }
};

// get() : 데이터 조회
ChainingHashTable.prototype.get = function (key) {
  let index = this.hashCode(key);

  if (this.table[index] !== undefined && !this.table[index].isEmpty()) {
    let current = this.table[index].head;

    do {
      if (current.data.key === key) {
        return current.data.value;
      }
      current = current.next;
    } while (current);
  }

  return undefined;
};

// remove() : 데이터 삭제
ChainingHashTable.prototype.remove = function (key) {
  let index = this.hashCode(key);
  let element = undefined;

  if (this.table[index] !== undefined) {
    let current = this.table[index].head;

    do {
      if (current.data.key === key) {
        element = current.data;
        this.table[index].remove(current.data);
        if (this.table[index].isEmpty()) {
          delete this.table[index];
        }
      }
      current = current.next;
    } while (current);
  }

  this.length--;
  return element;
};

우선순위 큐(Priority Queue)

1. 우선순위 큐란?

우선순위 큐는 각 요소에 우선순위가 부여되고, 우선순위가 높은 요소가 먼저 처리되는 추상 자료형(ADT)입니다. 일반 큐(FIFO)와 달리 요소의 추가/제거 순서가 우선순위에 의해 결정되며, 동일한 우선순위인 경우에는 삽입 순서(FIFO)를 따름

핵심 특징

• 우선순위 기반 처리: 높은 우선순위 요소가 먼저 제거됨.
• 동적 구조: 요소 추가 시마다 내부적으로 재정렬됨.
• 유연한 구현: 배열, 연결리스트, 힙(Heap) 등 다양한 자료구조로 구현 가능

2. 우선순위 큐의 주요 연산

// Element() : 데이터와 우선순위를 저장하기 위한 생성자 함수
function Element(data, priority) {
  this.data = data;
  this.priority = priority;
}

// PriorityQueue() : Element 관리를 위한 생성자 함수
function PriorityQueue() {
  this.array = [];
}

// getBuffer() : 객체 내 데이터 셋 반환
PriorityQueue.prototype.getBuffer = function () {
  return this.array.map((element) => element.data);
};

// isEmpty() : 객체 내 데이터 존재 여부 파악
PriorityQueue.prototype.isEmpty = function () {
  return this.array.length == 0;
};

// enqueue() : 데이터 추가
PriorityQueue.prototype.enqueue = function (data, priority) {
  let element = new Element(data, priority);
  let added = false;

  for (let i = 0; i < this.array.length; i++) {
    if (element.priority < this.array[i].priority) {
      this.array.splice(i, 0, element);
      added = true;
      break;
    }
  }

  if (!added) {
    this.array.push(element);
  }

  return this.array.length;
};

// dequeue() : 데이터 삭제
PriorityQueue.prototype.dequeue = function () {
  return this.array.shift();
};

// front() : 가장 첫 데이터 반환
PriorityQueue.prototype.front = function () {
  return this.array.length == 0 ? undefined : this.array[0].data;
};

// size() : 큐 내 데이터 개수 확인
PriorityQueue.prototype.size = function () {
  return this.array.length;
};

// clear() : 큐 초기화
PriorityQueue.prototype.clear = function () {
  this.array = [];
};

3. 구현 방식별 특징

힙이 가장 효율적으로 널리 사용되며, Python의 queue.PriorityQueue와 Java의 PriorityQueue도 내부적으로 힙을 사용함.

4. 실제 활용 사례

1) 운영체제 작업 스케줄링

• 고우선순위 시스템 이벤트(예: 하드웨어 인터럽트)를 먼저 처리

2) 네트워크 패킷 관리

• VoIP 데이터(낮은 지연 요구)를 일반 데이터보다 우선 전송

3) 알고리즘 최적화

• 다익스트라 알고리즘: 최소 거리 노드 우선 처리
• A* 경로 탐색: 예상 비용이 낮은 경로 우선 탐색

스택(Stack)

1. 스택이란?

스택(Stack)은 데이터를 쌓아 올린 형태의 선형 자료구조로, LIFO(Last In, First Out) 원칙을 따릅니다. 즉, 가장 마지막에 추가된 데이터가 가장 먼저 제거되는 구조
실생활에서는 접시를 쌓아두는 모습, 프링글스 통에서 감자칩을 꺼내는 모습이 대표적인 예

2. 스택의 주요 연산

스택에서는 오직 한 쪽(Top)에서만 데이터의 추가와 삭제가 일어납니다.
주요 연산은 다음과 같습니다.

• Push: 스택의 맨 위(Top)에 요소를 추가
• Pop: 스택의 맨 위(Top) 요소를 제거 및 반환
• Peek(Top): 스택의 맨 위 요소를 제거하지 않고 확인
• isEmpty: 스택이 비어있는지 확인
• Size: 스택에 들어있는 요소의 개수 반환

// Stack() : 생성자 함수로 초기 데이터 설정
function Stack(array) {
  this.array = array ? array : [];
}

// getBuffer() : 객체 내 데이터 셋 반환
Stack.prototype.getBuffer = function () {
  return this.array.slice();
}

// isEmpty() : 객체 내 데이터 존재 여부 파악
Stack.prototype.isEmpty = function () {
  return this.array.length == 0;
};

// push() : 데이터 추가
Stack.prototype.push = function (element) {
  return this.array.push(element);
}

// pop() : 데이터 삭제
Stack.prototype.pop = function () {
  return this.array.pop();
}

// peek() : 가장 끝 데이터 반환
Stack.prototype.peek = function () {
  return this.array[this.array.length - 1];
}

// size() : 스택 내 데이터 개수 확인
Stack.prototype.size = function () {
  return this.array.length;
}

// indexOf() : 데이터 위치 값 조회
Stack.prototype.indexOf = function (element, position = 0) {
  /* case 1 */
  // return this.array.indexOf(element, position);
  /* case 2 */
  for (let i = position; i < this.array.length; i++) {
    if (element == this.array[i]) return i;
  }

  return -1;
};

// includes() : 데이터 존재 여부 확인
Stack.prototype.includes = function (element, position = 0) {
  /* case 1 */
  // return this.array.includes(element);
  /* case 2 */
  for (let i = position; i < this.array.length; i++) {
    if (element == this.array[i]) return true;
  }

  return false;
};

각 연산은 일반적으로 시간 복잡도 $$O(1)$$로 매우 빠르게 수행됨.

3. 스택의 구현 방식

스택은 배열(Array)과 연결리스트(Linked List) 두 가지 방식으로 구현할 수 있음

• 배열 기반 스택: 크기가 고정되어 있어 미리 최대 크기를 정해야 하며, 인덱스 접근이 빠름.
• 연결리스트 기반 스택: 크기 제한이 없고, 필요에 따라 메모리가 할당되어 유연함

4. 스택의 활용 사례

스택은 다양한 분야에서 핵심적인 역할을 합니다.

• 함수 호출 관리(Recursion/Call Stack)
  함수가 호출될 때마다 현재 상태를 스택에 저장, 함수 종료 시 스택에서 꺼내 복귀

• 수식 계산 및 괄호 검사
  중위/후위/전위 표기법 변환, 괄호의 짝이 맞는지 검사할 때 활용

• 브라우저 뒤로가기(Undo/Redo)
  사용자의 이전 작업 상태를 스택에 저장, 뒤로가기/앞으로가기 기능 구현

• 문자열 역순 출력
  문자열을 한 글자씩 스택에 넣었다가 꺼내면 역순으로 출력 가능.

• 운영체제의 프로세스 스케줄링
  프로세스의 상태 저장 및 복원에 활용

5. 스택의 장단점

장점

• 구현이 간단하고, 삽입/삭제 연산이 매우 빠름(O(1))
• 함수 호출, undo/redo 등 다양한 분야에서 필수적으로 사용

단점

• 중간 요소에 직접 접근 불가(Top에서만 접근 가능)
• 배열 기반 스택은 크기 제한이 있을 수 있음

1. 연결리스트란?

연결리스트는 각 노드가 오직 한 방향(다음 노드)으로만 연결되어 있는 선형 자료구조
각 노드는 두 가지 정보를 가짐.

• 데이터(Data): 저장하고자 하는 값
• 포인터(Next): 다음 노드를 가리키는 참조(주소)

리스트의 시작은 헤드(Head) 노드로, 끝은 null(혹은 None)로 표시함.

구조 예시

[Head] -> [Node1] -> [Node2] -> [Node3] -> null

2. 연결리스트의 장점과 단점

장점

• 동적 크기: 필요에 따라 노드를 추가/삭제할 수 있어 메모리 효율적
• 빠른 삽입/삭제: 특정 위치(특히 맨 앞)에서의 삽입/삭제가 빠름 (O(1))

단점

• 느린 탐색: 임의 접근이 불가능해, 원하는 위치까지 순차적으로 접근해야 함 (O(n))
• 추가 메모리 사용: 데이터 외에 포인터를 위한 메모리 필요

3. 연결리스트의 활용 예시

1) 스택(Stack)과 큐(Queue) 구현

• 스택: Head에 push/pop을 하면 LIFO 구조를 쉽게 구현 가능
• 큐: Head와 Tail 포인터를 활용해 FIFO 구조 구현

2) 동적 데이터 관리

• 실시간 데이터 추가/삭제가 빈번한 작업
  예: 작업 리스트, 대기열 등

3) 해시 테이블의 체이닝

• 해시 충돌 시, 같은 해시값을 가진 데이터를 단일 연결리스트로 관리

4. 연결리스트의 한계와 개선 방향

• 역방향 탐색 불가: 한 방향으로만 이동 가능, 이전 노드로 돌아갈 수 없음
• 임의 접근 비효율: 인덱스 기반 접근이 느림

이런 한계를 극복하기 위해 이중 연결리스트(Doubly Linked List), 원형 연결리스트(Circular Linked List) 등이 고안됨.

구현

// Node() : data와 point를 가지고 있는 객체
function Node(data) {
  this.data = data;
  this.next = null;
}

// LinkedList(): head와 length를 가지고 있는 객체
function LinkedList() {
  this.head = null;
  this.length = 0;
}

// size() : 연결 리스트 내 노드 개수 확인
LinkedList.prototype.size = function () {
  return this.length;
}

// isEmpty() : 객체 내 노드 존재 여부 파악
LinkedList.prototype.isEmpty = function () {
  return this.length === 0;
}

// printNode() : 노드 출력
LinkedList.prototype.printNode = function () {
  for (let node = this.head; node != null; node = node.next) {
    process.stdout.write(`${node.data} -> `);
  }
  console.log("null");
}

// append() : 연결 리스트 가장 끝에 노드 추가
LinkedList.prototype.append = function (value) {
  let node = new Node(value),
    current = this.head;

  if (this.head === null) {
    this.head = node;
  } else {
    while (current.next != null) {
      current = current.next;
    }
    current.next = node;
  }

  this.length++;
};

// insert() : position 위치에 노드 추가
LinkedList.prototype.insert = function (value, position = 0) {
  if (position < 0 || position > this.length) {
    return false;
  }

  let node = new Node(value),
    current = this.head,
    index = 0,
    prev;

  if (position == 0) {
    node.next = current;
    this.head = node;
  } else {
    while (index++ < position) {
      prev = current;
      current = current.next;
    }

    node.next = current;
    prev.next = node;
  }

  this.length++;

  return true;
};

// remove() : value 데이터를 찾아 노드 삭제
LinkedList.prototype.remove = function (value) {
  let current = this.head,
    prev = current;

  while (current.data != value && current.next != null) {
    prev = current;
    current = current.next;
  }

  if (current.data != value) {
    return null;
  }

  if (current === this.head) {
    this.head = current.next;
  } else {
    prev.next = current.next;
  }

  this.length--;

  return current.data;
};

// removeAt() : position 위치 노드 삭제
LinkedList.prototype.removeAt = function (position = 0) {
  if (position < 0 || position >= this.length) {
    return null;
  }

  let current = this.head,
    index = 0,
    prev;

  if (position == 0) {
    this.head = current.next;
  } else {
    while (index++ < position) {
      prev = current;
      current = current.next;
    }

    prev.next = current.next;
  }

  this.length--;

  return current.data;
}

// indexOf() : value 값을 갖는 노드 위치 반환
LinkedList.prototype.indexOf = function (value) {
  let current = this.head,
    index = 0;

  while (current != null) {
    if (current.data === value) {
      return index;
    }

    index++;
    current = current.next;
  }

  return -1;
}

// remove2() : indexOf + removeAt = remove
LinkedList.prototype.remove2 = function (value) {
  let index = this.indexOf(value);
  return this.removeAt(index);
};

• 알고리즘 성능 평가 지표

  • 정확성
  • 작업성
  • 메모리 사용량
  • 최적성
  • 효율성
    • 시간 복잡도
    • 공간 복잡도

• 시간 복잡도

  • 입력 크기의 값에 대해 단위 연산을 몇 번 수행하는지 계산하여, 알고리즘의 수행시간을 평가하는 방법
  • 3가지 점근적 표현법
    • 빅오 : 최악의 상황을 고려하여 성능 측정 결과 표현
    • 세타 : 평균적인 경우에서의 성능 측정 결과 표현
    • 오메가 : 최선의 상황일 때의 성능 측정 결과 표현
  • 빅오 복잡도 차트를 보면 log일 때 퍼포먼스가 좋음

• 빅오 표기법의 경우 for문 하나의 경우 n회로 따지고 수행 하나는 1회로 침

• 이 때 1+1+1 = 3이어도 O(1)임 n이 있다면 1+n+1 = n+2인데 O(n)임

• 참고자료

경우의 수

• 어떤 사건 혹은 일이 일어날 수 있는 경우의 가짓수를 수로 표현
• 일상 생활에서의 경우의 수
  • 주사위 : 던지는 결과, 1 ~ 6 사이의 숫자이므로 경우의 수는 6
  • 윷 : 던지는 결과, 도,개,걸,윷,모 이므로 경우의 수는 5
  • 가위바위보 : 게임 결과, 가위, 바위, 보 중에 하나를 낼 수 있으므로 경우의 수는 3
  • 동전 : 던지는 결과, 앞면 혹은 뒷면이므로 경우의 수는 2
• 완전탐색으로 경우의 수를 푸는 알고리즘
  • 순열 : 서로 다른 n개의 원소 중에서 r를 중복 없이 골라 순서에 상관 있게 나열하는 경우의 수 nPr
  • 조합 : 서로 다른 n개의 원소 중에서 r를 중복 없이 골라 순서에 상관 없이 나열하는 경우의 수 nCr
  • 중복 순열 : 서로 다른 n개의 원소 중에서 r개를 중복 있게 골라 순서에 상관 있게 나열하는 경우의 수 nHr

    // 순열 예제
    let input = ["a", "b", "c"];
    let count = 0;
    

function permutation(arr) { for (let i = 0; i < arr.length; i++) { for (let j = 0; j < arr.length; j++) { if (i == j) continue; for (let k = 0; k < arr.length; k++) { if (i == k) continue; if (j == k) continue;

    console.log(arr[i], arr[j], arr[k]);
    count++;
  }
}

} }

permutation(input);

```javascript
// 순열 예제(재귀 활용)
let input = ["a", "b", "c"];
let count = 0;

function permutation(arr, s, r) {
  if (s == r) {
    count++;
    console.log(arr.join(" "));
    return;
  }

  for (let i = s; i < arr.length; i++) {
    [arr[s], arr[i]] = [arr[i], arr[s]];
    permutation(arr, s + 1, r);
    [arr[s], arr[i]] = [arr[i], arr[s]];
  }
}

permutation(input, 0, 2);

// 조합 예제
let input = [1, 2, 3, 4];
let count = 0;

function combination(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      count++;
      console.log(arr[i], arr[j]);
    }
  }
}

combination(input);

// 조합 예제(재귀 활용)
let input = [1, 2, 3, 4];
let output = [];
let count = 0;

function combination(arr, data, s, idx, r) {
  if (s == r) {
    count++;
    console.log(data);
    return;
  }

  for (let i = idx; arr.length - i >= r - s; i++) {
    data[s] = arr[i];
    combination(arr, data, s + 1, i + 1, r);
  }
}

combination(input, output, 0, 0, 2);

점화식

• 점화식(재귀식)이란 수열에서 이웃하는 두개의 항 사이에 성립하는 관계를 나타낸 관계식
• 대표적인 점화식
  • 등차수열 : F(n) = F(n - 1) + a
  • 등비수열 : F(n) = F(n - 1) * a
  • 팩토리얼 : F(n) = F(n - 1) * n
  • 피보나치 수열 : F(n) = F(n - 1) + F(n - 2)
• 등차수열 예제

  let result;
  

function forloop(s, t, number) { let acc = 0;

for (let i = 1; i <= number; i++) { if (i == 1) acc += s; else acc += t;

console.log(i, acc);

}

return acc; }

result = forloop(3, 2, 5); console.log(result);

```javascript
let result;

function recursive(s, t, number) {
  if (number == 1) {
    return s;
  }

  return recursive(s, t, number - 1) + t;
}

result = recursive(3, 2, 5);
console.log(result);

• 등비수열 예제

  let result;
  

function forloop(s, t, number) { let acc = 0;

for (let i = 1; i <= number; i++) { if (i == 1) acc *= s; else acc *= t;

console.log(i, acc);

}

return acc; }

result = forloop(3, 2, 5); console.log(result);

```javascript
let result;

function recursive(s, t, number) {
  if (number == 1) {
    return s;
  }

  return recursive(s, t, number - 1) * t;
}

result = recursive(3, 2, 5);
console.log(result);

• 팩토리얼 예제

  let result;
  

function recursive(number) { if (number == 1) { return number; }

return recursive(number - 1) * number; }

result = recursive(5); console.log(result);

- 피보나치 수열 예제
```javascript
let result;

function recursive(number) {
  if (number == 1 || number == 0) {
    return number;
  }

  return recursive(number - 1) + recursive(number - 2);
}

result = recursive(5);
console.log(result);

1. 이벤트 위임 (Event Delegation)

개념

• 이벤트 위임은 부모 요소에 단일 이벤트 리스너를 추가하여 자식 요소의 이벤트를 처리하는 방식.
• 이벤트 버블링을 활용하여 자식 요소에서 발생한 이벤트가 부모 요소로 전파되도록 함.

장점

1. 성능 최적화:
   • 많은 자식 요소에 각각 이벤트 리스너를 추가할 필요 없이 부모에 단일 리스너만 추가하면 됨.
2. 동적 요소 지원:
   • DOM에 새로 추가된 자식 요소도 부모의 이벤트 리스너로 처리할 수 있음.

단점

1. 추가 조건 필요:
   • 이벤트가 버블링되므로, 특정 자식 요소만 처리하려면 조건문(if (event.target.tagName === 'I'))을 추가해야 함.
2. 복잡성 증가:
   • 단순한 구조에서는 개별 리스너를 사용하는 것이 더 직관적일 수 있음.

2. 이벤트 버블링 (Event Bubbling)

개념

• DOM 이벤트 모델에서, 이벤트가 발생하면 가장 안쪽의 요소(타겟)에서 시작하여 부모 요소로 전파됨.
• 예를 들어, 자식 요소에서 click 이벤트가 발생하면 해당 이벤트는 부모, 조부모 등 상위 요소로 전달됨.

이벤트 캡처와의 차이

• 캡처(Capturing): 이벤트가 최상위 요소에서 시작하여 타겟 요소로 전파됨.
• 버블링(Bubbling): 타겟 요소에서 시작하여 최상위 요소로 전파됨.

3. mouseenter vs mouseover

• mouseenter: 마우스가 해당 요소에 진입할 때만 트리거되며, 자식 요소에는 영향을 받지 않음.
• mouseover: 마우스가 해당 요소 또는 그 자식 요소에 진입할 때마다 트리거됨.

장단점 비교

• mouseenter:
  • 버블링되지 않으므로 불필요한 이벤트 트리거를 방지할 수 있음.
  • 자식 요소가 없는 구조에서 효율적임.
• mouseover:
  • 버블링되므로 부모 컨테이너에서 자식 요소의 이벤트를 감지할 수 있음.
  • 이벤트 위임 방식에 적합함.

4. mouseleave vs mouseout

• mouseleave: 마우스가 해당 요소 전체에서 벗어날 때만 트리거되며, 자식 요소에는 영향을 받지 않음.
• mouseout: 마우스가 해당 요소 또는 그 자식 요소에서 벗어날 때마다 트리거됨.

장단점 비교

• mouseleave:
  • 버블링되지 않으므로 불필요한 이벤트 트리거를 방지할 수 있음.
  • 자식 요소가 없는 구조에서 효율적.
• mouseout:
  • 버블링되므로 부모 컨테이너에서 자식 요소의 이벤트를 감지할 수 있음.
  • 이벤트 위임 방식에 적합함.

코드 비교 및 분석

원래 코드 (개별 리스너 + mouseenter, mouseleave)

stars.forEach((star) => {
  star.addEventListener('mouseenter', handleMouseEnter);
  star.addEventListener('mouseleave', handleMouseLeave);
  star.addEventListener('click', handleClick);
});

• 각 별(i) 태그에 개별적으로 리스너를 추가.
• 이 방식은 구조가 단순하고 코드 가독성이 높음.
• 별점 개수가 많아질 경우 성능 저하 가능성이 있음.

중간 코드 (이벤트 위임 + mouseover, mouseout)

container.addEventListener('mouseover', (event) => {
  if (event.target.tagName === 'I') {
    const ratingValue = parseInt(event.target.dataset.ratingValue, 10);
    stars.forEach((star, index) => {
      star.classList.toggle('hovered', index  {
  stars.forEach((star) => star.classList.remove('hovered'));
});

container.addEventListener('click', (event) => {
  if (event.target.tagName === 'I') {
    const ratingValue = parseInt(event.target.dataset.ratingValue, 10);
    stars.forEach((star, index) => {
      star.classList.toggle('selected', index < ratingValue);
    });

    const ratingChangeEvent = new CustomEvent('rating-change', {
      detail: ratingValue,
    });
    container.dispatchEvent(ratingChangeEvent);
  }
});

• 부모 컨테이너(container)에 단일 리스너를 추가하여 모든 별의 이벤트를 처리함.
• 동적으로 추가된 별점도 자동으로 처리 가능.
• 성능 최적화 측면에서 유리함

1. beforeunload 이벤트란?

• beforeunload는 사용자가 페이지를 떠나거나 새로고침하려고 할 때 발생하는 브라우저 이벤트.
• 이 이벤트를 활용하면 페이지를 벗어나는 시점에 특정 작업(예: 상태 저장)을 수행할 수 있음.
• 주로 다음과 같은 경우에 사용됨:
  • 세션 상태 저장
  • 사용자 데이터를 서버에 전송
  • 사용자에게 경고 메시지 표시 (예: "페이지를 떠나시겠습니까?")

2. 현재 코드에서의 활용

현재 코드에서는 beforeunload 이벤트를 통해 사이드 내비게이션의 활성화 상태를 저장하고 있습니다. 이 과정은 다음과 같은 흐름으로 이루어짐:

(1) 상태 확인

• nav 요소의 .active 클래스가 존재하는지 확인하여 사이드 내비게이션이 열려 있는지 여부를 판단함

(2) 로컬 스토리지에 상태 저장

• localStorage.setItem("navActive", isCurrentlyActive)를 사용하여 사이드 내비게이션의 상태를 저장함.
• 키(navActive)와 값(true 또는 false)을 통해 상태를 기록함.

(3) beforeunload 이벤트 등록

• window.addEventListener("beforeunload", ...)를 통해 페이지가 떠나는 시점에 위의 상태 확인 및 저장 작업을 실행함.

3. 코드 흐름 설명

window.addEventListener("beforeunload", () => {
  const isCurrentlyActive = nav.classList.contains("active");
  localStorage.setItem("navActive", isCurrentlyActive);
});

코드 실행 흐름:

1. 사용자가 페이지를 떠나거나 새로고침하려고 할 때 beforeunload 이벤트가 발생함.
2. 현재 내비게이션의 활성화 상태(nav.classList.contains("active"))를 확인.
3. 로컬 스토리지에 해당 상태(true 또는 false)를 저장함.

4. beforeunload와 unmount의 차이점

피드백에서 언급된 "상태 저장은 unmount 시점에서 한 번만 하면 될 것 같다"는 내용은 다음과 같은 차이를 고려해야 함:

beforeunload:

• 브라우저 이벤트로, 페이지가 떠나는 시점에 실행됨.
• 클라이언트 측에서만 동작하며, 서버와 연동되지 않음.

Unmount:

• React와 같은 프레임워크에서 컴포넌트가 DOM에서 제거될 때 발생하는 라이프사이클 메서드입니다 (componentWillUnmount()).
• 특정 컴포넌트 단위로 실행되며, 더 세부적인 제어가 가능.

5. beforeunload 사용 시 고려사항

1. 다른 도메인 간 데이터 공유:

   • localStorage는 동일한 도메인에서만 접근 가능하므로 다른 도메인에서는 사용할 수 없음.
   • 크로스 도메인 데이터 공유가 필요하다면 쿠키 또는 서버 측 API와 연동해야함.

2. 보안 문제:

   • 민감한 데이터를 저장할 경우 XSS 공격에 취약할 수 있음.
   • 민감한 정보는 반드시 서버 측에서 관리.

3. 사용 사례 적합성:

   • 현재 요구사항에서는 간단히 사이드 내비게이션 상태만 저장하므로 localStorage와 beforeunload 조합이 적합함.

6. 결론

현재 구현된 코드에서 beforeunload는 사용자가 페이지를 떠날 때 사이드 내비게이션의 활성화 상태를 로컬 스토리지에 저장하는 데 적합합니다. 다만, 다른 도메인 간 데이터 공유가 필요하거나 보안이 중요한 경우에는 쿠키 또는 서버 측 API를 사용하는 것이 더 적합할 수 있음

localStorage, sessionStorage, 그리고 Cookies는 모두 브라우저에서 데이터를 저장하는 데 사용되지만, 각각의 특성과 사용 사례가 다름

비교표: localStorage vs sessionStorage vs Cookies

상황별 사용 사례

1. localStorage

• 특징: 영구적으로 데이터를 저장하며, 브라우저를 닫아도 데이터가 유지.
• 사용 사례:
  • 사용자 환경설정 저장 (예: 다크 모드, 언어 설정)
  • SPA(Single Page Application)에서 상태 관리
  • 페이지 간 데이터 공유 (동일 도메인 내)

2. sessionStorage

• 특징: 현재 브라우저 탭이나 창이 열려 있는 동안만 데이터를 유지.
• 사용 사례:
  • 일시적인 폼 데이터 저장
  • 탭 간 분리된 상태 관리
  • 페이지 이동 중 임시 데이터 저장

3. Cookies

• 특징: 서버와 클라이언트 간 데이터를 주고받을 수 있으며, 만료 시간 설정이 가능.
• 사용 사례:
  • 세션 관리 및 인증 토큰 저장
  • 크로스 도메인/서브도메인 데이터 공유
  • 자동 로그인 구현

보안 고려사항

localStorage와 sessionStorage

• XSS 공격에 취약하여 민감한 데이터를 저장하는 데 적합하지 않음.
• 데이터를 암호화하거나 민감한 정보는 서버 측으로 이동하는 것이 좋음.

Cookies

• HttpOnly 및 Secure 플래그를 사용하면 보안을 강화할 수 있음
• CSRF 공격 방지를 위해 SameSite 플래그를 설정하는 것이 권장됨.

결론 및 선택 기준

1. 민감한 데이터를 저장해야 한다면 Cookies를 사용하는 것이 가장 적합함
2. 사용자 환경설정이나 애플리케이션 상태처럼 클라이언트 측에서만 필요한 데이터를 저장하려면 localStorage가 적합함
3. 일회성 데이터나 세션 동안만 필요한 데이터를 저장하려면 sessionStorage를 선택

DOMContentLoaded와 window.onload의 차이는 주로 이벤트 발생 시점과 사용 사례에 따라 나뉨.

차이점 요약

세부 설명

1. DOMContentLoaded

• 이 이벤트는 브라우저가 HTML 문서를 완전히 로드하고 DOM 트리를 생성한 직후 발생
• 스타일시트, 이미지, 서브프레임과 같은 외부 리소스는 로드되지 않아도 이벤트가 발생
• 주요 사용 사례:
  • DOM 요소를 조작하거나 초기화 작업을 수행해야 할 때.
  • 외부 리소스 로드 여부와 상관없이 빠르게 동작해야 하는 스크립트를 실행할 때.
• 예시:

  document.addEventListener('DOMContentLoaded', () => {
    console.log('DOM is fully loaded and parsed');
    // DOM 조작 코드
  });

2. window.onload

• 이 이벤트는 페이지의 모든 리소스(이미지, 스타일시트, 서브프레임 등)가 완전히 로드된 후에 발생
• DOMContentLoaded보다 느리게 실행되며, 모든 외부 자원이 필요할 때 유용합니다.
• 주요 사용 사례:
  • 이미지 크기 계산이나 레이아웃 관련 작업처럼 외부 리소스가 모두 준비된 후에 실행해야 할 작업.
  • 페이지의 모든 콘텐츠가 로드된 상태에서 특정 작업을 수행해야 할 때.
• 예시:

  window.onload = () => {
    console.log('Page is fully loaded');
    // 외부 리소스를 포함한 작업
  };

적합한 사용 시점

언제 DOMContentLoaded를 사용할까?

• DOM 요소를 즉시 조작하거나 초기화해야 하는 경우.
• 외부 리소스(이미지, CSS 등)가 필요하지 않은 작업.

언제 window.onload를 사용할까?

• 이미지나 스타일시트와 같은 외부 리소스가 모두 준비된 후에 작업해야 하는 경우.
• 예를 들어, 이미지 슬라이더나 레이아웃 계산 작업.

결론

대부분의 경우에는 DOMContentLoaded를 사용하는 것이 더 적합함. 이는 DOM이 준비되는 즉시 JavaScript를 실행할 수 있어 사용자 경험을 개선하고 페이지 로드를 빠르게 느끼게 하기 때문임. 그러나 모든 외부 리소스를 기다려야 하는 특정 상황에서는 window.onload를 사용하는 것이 적합함.

웹 개발에서 레이아웃을 구성할 때, 복잡한 계산식보다는 가변적이고 단순한 단위를 사용하는 것이 중요합니다. 이는 브라우저의 계산 부담을 줄이고, 팀원들 간의 코드 이해도를 높이는 데 도움이 됩니다. 이번 글에서는 박스 모델을 활용해 복잡한 계산식을 피하는 방법과, 가변적이고 단순한 단위를 사용하는 전략을 소개합니다.

1. 박스 모델 이해

박스 모델의 구성

• 콘텐츠 영역: 실제 콘텐츠가 포함된 영역.
• 패딩: 콘텐츠와 테두리 사이의 공간.
• 테두리: 콘텐츠와 패딩을 둘러싼 선.
• 마진: 박스와 다른 요소 사이의 공간.

박스 모델의 중요성

• 레이아웃 제어: 박스 모델을 이해하면 복잡한 계산식 없이도 레이아웃을 쉽게 제어할 수 있습니다.
• 가변적 레이아웃: min-width, max-width와 같은 속성을 사용해 가변적인 레이아웃을 구현할 수 있습니다.

2. 가변적이고 단순한 단위 사용

min-width와 max-width

• 적합한 상황: 레이아웃이 특정 너비 이하로 줄어들지 않도록 하거나, 최대 너비를 설정할 때 유용합니다.
• 예제 코드

  .container {
    max-width: 1020px;
    width: 100%;
  }

vw와 % 단위

• 적합한 상황: 반응형 디자인에서 브라우저 창의 너비에 따라 레이아웃을 조정해야 할 때 유용합니다.
• 예제 코드

  .responsive-card {
    width: 30vw; /* 브라우저 창의 너비에 따라 조정 */
  }

rem 단위

• 적합한 상황: 폰트 크기와 같은 상대적인 크기를 조정해야 할 때 유용합니다. 미디어 쿼리와 함께 사용하면 반응형 디자인에 유리합니다.

• 예제 코드

  :root {
    font-size: 16px; /* 기본 폰트 크기 설정 */
  }
  
  .card {
    width: 20rem; /* 폰트 크기에 상대적인 너비 */
  }

3. Float 레이아웃 최적화

Float의 문제점

• 복잡한 계산: Float를 사용할 때 직접 여백과 아이템 크기를 계산해야 하는 경우가 많습니다.
• 부모 요소 처리: Float 요소의 부모 요소에 overflow: hidden이나 clearfix 클래스를 사용해 Float를 해제해야 합니다.

최적화 전략

• 박스 모델 활용: 박스 모델을 잘 이해하고, min-width, max-width와 같은 속성을 사용해 가변적인 레이아웃을 구현합니다.
• 가상 요소 사용: clearfix와 같은 클래스를 사용해 Float를 해제하는 방법을 활용합니다.

예제 코드

.clearfix::after {
  content: "";
  display: block;
  clear: both;
}

.float-item {
  float: left;
  width: calc(100% - 300px); /* 복잡한 계산식 대신 박스 모델 활용 */
}

4. Grid 레이아웃과의 비교

Grid의 장점

• 2차원 배열: Grid는 행과 열로 아이템을 배치하는 데 유리합니다.
• 복잡한 레이아웃 지원: Grid는 복잡한 레이아웃을 쉽게 구현할 수 있습니다.

Grid의 단점

• 복잡한 계산: Grid도 특정 상황에서 복잡한 계산식이 필요할 수 있습니다.
• 예제 코드

  .grid-container {
    grid-template-columns: minmax(200px, 1fr) 2fr;
  }

5. 결론

CSS 레이아웃을 구성할 때, 복잡한 계산식보다는 가변적이고 단순한 단위를 사용하는 것이 중요합니다. 박스 모델을 잘 이해하고, min-width, max-width와 같은 속성을 활용하면 레이아웃을 쉽게 제어할 수 있습니다. Float나 Grid를 사용할 때도, 박스 모델과 가상 요소를 활용해 복잡한 계산식을 피하는 것이 좋습니다. 이러한 전략을 통해 더 나은 웹 페이지를 구현할 수 있습니다.

웹 개발에서 CSS 단위 선택은 디자인의 반응성과 접근성을 결정하는 중요한 요소입니다. px와 rem은 각각 고유한 특성과 장단점을 가지고 있으며, 프로젝트의 요구 사항에 맞게 적절히 선택해야 합니다. 이번 글에서는 px와 rem의 차이점과 사용 사례를 살펴보고, 이를 선택하는 기준을 정리해 보겠습니다.

1. px 단위

특징

• 고정된 크기: px는 절대적인 단위로, 브라우저의 해상도에 따라 고정된 크기를 제공합니다.
• 적합한 상황: 고정된 레이아웃이 필요한 경우나, 브라우저의 가변성에 관계없이 일정한 크기를 유지해야 할 때 유용합니다.
• 예시: 이미지나 아이콘의 크기, 테두리 너비 등 고정된 크기가 필요한 요소에 적합합니다.

문제점

• 반응형 디자인 제한: px는 사용자의 브라우저 설정에 따라 크기를 조정할 수 없으므로, 반응형 디자인에서 제한적입니다.
• 접근성 문제: 시각 장애가 있는 사용자가 브라우저에서 폰트 크기를 조정할 때, px로 설정된 요소는 크기가 변하지 않아 접근성이 저해될 수 있습니다.

2. rem 단위

특징

• 상대적인 크기: rem은 루트 요소의 폰트 크기에 상대적인 단위로, 반응형 디자인에 유리합니다.
• 적합한 상황: 반응형 디자인에서 전체 레이아웃의 크기를 쉽게 조정해야 할 때 유용합니다.
• 예시: 폰트 크기, 패딩, 마진 등 레이아웃의 크기를 유연하게 조정해야 하는 요소에 적합합니다.

장점

• 반응성: 사용자가 브라우저에서 폰트 크기를 조정할 수 있어, 레이아웃이 자연스럽게 확대/축소됩니다.
• 접근성 향상: 시각 장애가 있는 사용자가 브라우저에서 폰트 크기를 조정할 때도 레이아웃이 잘 유지됩니다.

3. 선택 기준

목적성

• 각 단위의 특성과 프로젝트의 요구 사항에 맞춰 선택합니다.
• 고정된 크기 필요: px를 사용.
• 반응형 디자인 필요: rem을 사용.

성능

• px는 고정된 크기를 제공하지만, 반응형 디자인에서는 rem이 더 유리합니다.
• rem은 루트 요소의 폰트 크기에 따라 크기가 조정되므로, 사용자 환경에 맞게 레이아웃이 확대/축소됩니다

4. 예외 및 특이 케이스

px 사용 사례

• 고정된 요소: 이미지, 아이콘, 테두리 너비 등 고정된 크기가 필요한 요소에 px를 사용합니다.
• 레거시 브라우저 지원: 일부 오래된 브라우저에서 rem이 지원되지 않을 수 있으므로, px를 사용해야 할 수도 있습니다.

rem 사용 사례

• 반응형 폰트 크기 조정: 사용자가 브라우저에서 폰트 크기를 조정할 때 레이아웃이 자연스럽게 확대/축소되도록 rem을 사용합니다.
• 접근성 향상: 시각 장애가 있는 사용자가 브라우저에서 폰트 크기를 조정할 때도 레이아웃이 잘 유지되도록 rem을 사용합니다.

5. 결론

CSS 단위 선택은 프로젝트의 목적과 요구 사항에 따라 다르게 접근해야 합니다. px는 고정된 크기를 제공하며, rem은 반응형 디자인과 접근성을 향상시킵니다. 각 단위의 특성을 이해하고 적절히 활용하면 더 나은 웹 페이지를 구현할 수 있습니다.

웹 개발에서 레이아웃을 구성하는 방법은 여러 가지가 있으며, 각 방법은 고유한 특성과 장단점을 가지고 있습니다. 이번 글에서는 Flexbox, Grid, Float의 사용 사례와 예외적인 경우를 살펴보고, 이를 선택하는 기준을 정리해 보겠습니다.

1. Flexbox

특징

• 1차원 배열: 주로 수평 또는 수직으로 아이템을 배치하는 데 적합합니다.
• 유연한 크기 조정: 아이템의 크기를 유연하게 조정할 수 있어 반응형 디자인에 유리합니다.
• 간단한 구현: 비교적 간단한 구현이 가능하며, 브라우저에서도 계산이 단순합니다.

예시

• 네비게이션 바: 메뉴 아이템을 수평으로 배치할 때 유용합니다.
• 리스트 아이템: 여러 아이템을 수평 또는 수직으로 나열할 때 적합합니다.

예제 코드

.flex-container {
  display: flex;
  justify-content: space-between; /* 아이템을 수평으로 배치 */
  align-items: center; /* 아이템을 수직으로 중앙 정렬 */
}

2. Grid

특징

• 2차원 배열: 행과 열로 아이템을 배치하는 데 적합합니다.
• 복잡한 레이아웃 지원: 복잡한 레이아웃을 쉽게 구현할 수 있으며, 모바일에서도 순서를 자유롭게 변경할 수 있습니다.
• 다소 복잡한 구현: 1차원보다 복잡한 계산이 필요할 수 있습니다.

예시

• 갤러리: 이미지나 아이템을 격자 형태로 배치할 때 유용합니다.
• 테이블 형태의 레이아웃: 데이터를 테이블 형태로 표현할 때 적합합니다.

예제 코드

.grid-container {
  display: grid;
  grid-template-columns: repeat(3, 1fr); /* 3열 격자 */
  grid-template-rows: repeat(2, 1fr); /* 2행 격자 */
  gap: 10px; /* 격자 간격 */
}

3. Float

특징

• 레거시 프로젝트: 오래된 웹사이트나 특정 상황에서 여전히 유용할 수 있습니다.
• 단순한 구현: 비교적 간단한 구현이 가능하지만, 최근에는 Flexbox나 Grid로 대체되는 경우가 많습니다.

예시

• 네이버 포털: Float를 사용한 레이아웃이 여전히 존재하는 레거시 프로젝트.
• 특정 상황: 특정한 레이아웃 요구 사항이 있을 때 Float가 유용할 수 있습니다.

예제 코드

.float-item {
  float: left; /* 아이템을 왼쪽으로 띄움 */
  width: 50%; /* 아이템의 너비 설정 */
}

4. 선택 기준

목적성

• 각 레이아웃 방법은 고유한 쓰임새가 있으며, 프로젝트의 요구 사항에 맞춰 선택해야 합니다.
• 1차원 배열: Flexbox가 적합.
• 2차원 배열: Grid가 적합.
• 레거시 프로젝트: Float가 필요할 수 있음.

성능

• Flexbox와 Grid의 성능 차이는 미미하지만, 복잡한 레이아웃에서는 Grid가 더 복잡할 수 있습니다.

팀 내부 규칙

• 팀 내부에서 일관된 스타일을 유지하기 위해 특정 레이아웃 방법만 사용하는 규칙을 정할 수 있지만, 상황에 맞게 유연하게 활용하는 것이 더 효율적일 수 있습니다.

5. 예외 및 특이 케이스

2차원 배열에서 Flexbox 사용

• Flexbox의 2D 레이아웃: Flexbox도 2D 레이아웃을 구현할 수 있으며, 특히 아이템의 크기가 유연하게 변할 때 유용합니다. 예를 들어, Flexbox의 flex-wrap 속성을 사용해 아이템을 여러 줄로 나열할 수 있습니다
• Grid보다 유리한 경우: Flexbox는 아이템의 크기를 유연하게 조정할 수 있어, Grid보다 더 유연한 레이아웃이 필요한 경우에 유리할 수 있습니다

1차원 배열에서 Grid 사용

• Grid의 1D 레이아웃: Grid는 1차원 배열에서도 유용할 수 있으며, 특히 아이템의 크기를 정확히 제어해야 할 때 유리합니다. 예를 들어, Grid는 열의 너비를 1fr로 설정하여 동일한 너비로 유지할 수 있습니다
• Flexbox보다 유리한 경우: Grid는 아이템의 크기를 정확히 제어할 수 있어, Flexbox보다 더 정밀한 레이아웃이 필요한 경우에 유리할 수 있습니다

6. 결론

CSS 레이아웃 방법은 프로젝트의 요구 사항에 맞게 선택해야 합니다. Flexbox는 1차원 배열에, Grid는 2차원 배열에 적합하며, Float는 레거시 프로젝트나 특정 상황에서 유용할 수 있습니다. 각 레이아웃 방법의 특성을 이해하고, 상황에 맞게 적절히 활용하는 것이 중요합니다. 예외적으로 Flexbox도 2D 레이아웃에 사용될 수 있으며, Grid도 1D 레이아웃에 유리할 수 있습니다. 이러한 유연성을 이해하고 활용하면 더 나은 웹 페이지를 구현할 수 있습니다.

1. 호버/포커스 상호작용의 올바른 처리

문제점

초기 코드에서는 개별 요소에 호버/포커스 효과를 적용해 전체적인 상호작용이 부자연스러웠습니다.
예: 카드와 아이콘이 별도로 반응해 UX 일관성 저하.

수정 전 코드

/* 카드와 아이콘을 각각 처리 → 일관성 없는 동작 */
.card-content:hover { border-color: blue; }
.arrow-icon-container:hover { background-color: blue; }

수정 후 코드

.card-content {
  transition: border-color 0.3s ease-in; 
}

/* 카드 전체에 호버/포커스 시 하위 요소 제어 */
.card-content:hover .purchase-icon-container,
.card-content:focus-within .purchase-icon-container {
  background-color: var(--color-blue-500);
}

.card-content:hover .purchase-icon-container::before {
  content: "구매하기"; /* 가상 요소로 텍스트 추가 */
}

핵심 원칙

1. 부모 요소 중심 제어: :focus-within을 사용해 자식 요소의 포커스도 캐치.
2. 상태 동기화: 카드 호버 시 모든 하위 요소가 동시에 반응하도록 처리.
3. 트랜지션 최적화: transition 속성은 최종 대상에 직접 적용.

2. 박스 모델 정렬: Flexbox 활용법

문제점

이미지가 카드 내에서 수직/수평 중앙 정렬되지 않아 시안과 달랐습니다.

수정 전

.product-card-image {
  padding-top: 10px; /* 임시방편 조정 */
}

수정 후

.card-content {
  display: flex;
  justify-content: center; /* 수평 중앙 */
  align-items: center;     /* 수직 중앙 */
  height: 310px;           /* 고정 높이 필수 */
}

왜 Flexbox인가?

• 반응형 대응 용이: margin이나 padding으로 위치 조정 시 다양한 해상도에서 깨질 수 있음.
• 직관적인 정렬: 1줄의 CSS로 복잡한 계산 없이 중앙 정렬 가능.

3. ARIA 속성의 올바른 사용

잘못된 사례

<span class="btn" aria-label="구매하기">...</span>

→ span은 클릭 이벤트를 기본 지원하지 않음. role="button" 추가 필요.

개선 코드

<button class="purchase-btn" aria-label="상품 구매하기">
  <img src="icon.svg" alt="" aria-hidden="true">
</button>

ARIA 사용 가이드

4. 디자인 시안 정확 구현 전략

실제 사례 비교

구현 절차

1. 픽셀 단위 측정: Figma에서 padding, margin 값 정확히 확인.
2. 상대 단위 사용: px 대신 rem으로 반응형 대응.
3. 변수 활용:

   :root {
     --button-padding: 8px 16px;
     --icon-size: 40px;
   }

5. 종합 평가표

6. 개발자 체크리스트

다음 작업 전에 반드시 확인하세요:

1. W3C Validator로 HTML 검증
2. 스크린 리더로 음성 출력 테스트
3. Figma 시안과 픽셀 단위 비교
4. nth-child 대신 명시적 클래스 사용 여부 확인
5. 모든 인터랙티브 요소 키보드 탐색 테스트

"디자인을 코드로 옮기는 것은 단순 변환이 아닌 재해석입니다.
태그 선택에서부터 스타일링까지, 모든 단계에서 '왜?'를 묻는 습관이 전문가와 주니어를 구분합니다."
– 프론트엔드 개발자 마틴 파울러

웹 개발에서 시맨틱 태그와 적절한 속성 사용은 웹 접근성을 높이고 유지보수를 용이하게 만듭니다. 이번 글에서는 h1 태그와 alt 속성의 의미 있는 사용, 그리고 nth-child 대신 클래스를 활용한 스타일링의 중요성을 이론과 예제를 통해 정리해보겠습니다.

1. 시맨틱 태그와 헤딩 구조

문제점

초기 코드에서는 다음과 같은 문제가 있었습니다:

1. 헤딩 구조의 단절: h2 이후 바로 h6을 사용하여 시맨틱 구조가 깨짐.
2. 스타일을 위한 헤딩 태그 남용: 헤딩 태그는 문서의 계층 구조를 표현하기 위한 용도인데, 단순히 스타일링 목적으로 사용됨.

수정 과정

수정 전 코드:

<header class="header">
  <h1 class="logo">
    <a href="https://www.coupang.com/">
      <img src="./assets/logo/logo.png" alt="쿠팡 로고 이미지" />
    </a>
  </h1>
</header>
<section class="section">
  <div class="today-discovery-headline">
    <h2 class="title-medium-24">오늘의 발견</h2>
    <h6 class="title-medium-16 subtitle">
      <span role="separator" aria-orientation="vertical">|</span>
      오늘 쿠팡이 엄선한 가장 핫한 제품
    </h6>
  </div>
</section>

수정 후 코드:

<header class="header">
  <h1 class="logo">
    <a href="https://www.coupang.com/">
      <img src="./assets/logo/logo.png" alt="쿠팡" />
    </a>
  </h1>
</header>
<section class="section">
  <div class="today-discovery-headline">
    <h2 class="title-medium-24">오늘의 발견</h2>
    <h3 class="title-medium-16 subtitle">
      <span role="separator" aria-orientation="vertical">|</span>
      오늘 쿠팡이 엄선한 가장 핫한 제품
    </h3>
  </div>
</section>

개선 사항

1. 헤딩 구조의 연속성 유지: h2 다음에 h3를 사용하여 문서 계층 구조를 명확히 표현.
2. 스타일링은 CSS로 처리: 헤딩 태그를 스타일링 목적으로 사용하는 대신, CSS 클래스(title-medium-16)를 활용.
3. alt 속성의 의미 부여: 로고 이미지의 alt 값을 "쿠팡 로고 이미지"에서 "쿠팡"으로 변경하여 간결하면서도 명확하게 표현.

왜 중요한가?

• 시맨틱 구조 유지: 검색 엔진과 스크린 리더가 문서를 올바르게 해석할 수 있도록 돕습니다.
• 접근성 향상: 스크린 리더 사용자는 alt 텍스트를 통해 이미지를 이해합니다.
• 유지보수 용이성: 스타일링은 CSS로 분리하여 HTML 구조와 디자인을 독립적으로 관리할 수 있습니다.

2. nth-child 대신 클래스 활용

문제점

초기 코드에서는 nth-child 선택자를 사용해 카드 레이아웃을 스타일링했습니다. 그러나 이는 다음과 같은 문제를 야기합니다:

1. 요소 순서가 변경되면 스타일이 깨질 위험이 있음.
2. 코드 가독성이 떨어짐(어떤 요소가 어떤 스타일을 가지는지 명확하지 않음).

수정 과정

수정 전 코드:

<div class="card-link-column">
  <a href="/">
    <div class="card-content" tabindex="0">
      <img src="./assets/discovery/honeytea.jpg" alt="오뚜기 따뜻한 차 향기" class="product-card-image" />
      <div class="arrow-icon-container" tabindex="0">
        <img src="./assets/icon/angle-right-square.svg" alt="화살표 아이콘" />
      </div>
    </div>
  </a>
</div>

.card-link-column:nth-child(-n + 2) {
  width: 50%;
  float: left;
  padding: 10px;
}

.card-link-column:nth-child(n + 3):nth-child(-n + 6) {
  width: 25%;
  float: left;
  padding: 10px;
}

수정 후 코드:

<ul class="card-link">
  <li class="card-link-item big">
    <a href="/" class="card-content">
      <img src="./assets/discovery/honeytea.jpg" alt="오뚜기 따뜻한 차 향기" class="product-card-image" />
      <span class="purchase-icon-container" aria-label="구매하기">
        <img src="./assets/icon/angle-right-square.svg" alt="구매하기 아이콘" />
      </span>
    </a>
  </li>
</ul>

.card-link {
  list-style: none;
  padding-left: 0;
}

.card-link-item {
  float: left;
  padding: 10px;
}

.card-link-item.big {
  width: 50%;
}

.card-link-item.small {
  width: 25%;
}

개선 사항

1. 클래스 기반 스타일링: 각 카드에 명확한 클래스(big, small)를 부여하여 역할과 크기를 정의.
2. 가독성 향상: 클래스 이름만 보고도 요소의 크기와 레이아웃을 쉽게 이해할 수 있음.
3. 변경에 유연함: HTML 요소 순서가 바뀌더라도 스타일이 깨지지 않음.

3. 요약 및 결론

시맨틱 태그와 접근성

• 헤딩 태그는 문서 계층 구조를 표현하는 데 사용하며, 디자인 목적으로 남용하지 않아야 합니다.
• alt 속성은 이미지의 의미를 간결하고 명확하게 전달해야 합니다.

클래스 기반 스타일링

• nth-child 선택자는 특정 상황에서 유용하지만, 요소 순서 변경에 취약하므로 클래스 기반 접근법이 더 안전하고 유지보수에 용이합니다.

최종 메시지

HTML과 CSS는 단순히 화면에 보이는 요소를 만드는 도구가 아니라, 사용자 경험(UX)과 접근성을 고려해야 하는 중요한 기술입니다. 시맨틱 태그와 적절한 속성 사용, 그리고 명확한 클래스 네이밍은 더 나은 웹 개발로 가는 첫걸음임. 위 내용을 바탕으로 프로젝트나 과제에서 코드를 작성할 때 항상 "구조적 의미", "접근성", "유지보수성"을 염두하자!

1. 시맨틱 태그와 웹 접근성

웹 개발에서 시맨틱 태그를 사용하는 것은 구조적 의미를 명확히 하고, 웹 접근성을 향상시키는 데 중요한 역할을 합니다. 시맨틱 태그는 콘텐츠의 목적을 명확히 하여 검색 엔진 최적화(SEO)와 접근성 도구(스크린 리더 등)의 효율성을 높입니다.

예를 들어, ul과 li는 목록 데이터를 표현할 때 사용되며, div는 구조적 의미가 없는 컨테이너로 사용됩니다. 과도한 div 태그 남발은 코드 가독성을 낮추고 접근성을 저해할 수 있습니다.

2. tabindex 속성의 정의와 사용법

tabindex는 HTML 요소의 키보드 포커스 탐색 순서를 제어하는 속성입니다. 기본적으로 대화형 요소(예: a, button, input)는 tabindex="0"을 가지며, 키보드로 탐색할 수 있습니다.

계속 놓친 부분이

1. a 태그 속성에 자식요소로 tabindex 가질 수 있는 인터랙티브한 요소를 삽입한 것(tabindex 사용 포함)
2. img 태그로 변경 후에도 span 태그가 아닌 button 태그로 또 자식 요소로 삽입해서 오류가 뜬 것

tabindex 값의 의미

• tabindex="0": 요소를 기본 탐색 순서에 포함.
• 양의 정수(tabindex="1" 이상): 탐색 순서를 명시적으로 지정하지만, 접근성을 저해할 수 있어 권장하지 않음[3].
• tabindex="-1": 요소를 키보드 포커스에서 제외하지만 프로그래밍적으로 포커스 가능[5].

사용 사례

• 비대화형 콘텐츠에 키보드 이벤트를 추가하려면 tabindex="0"을 설정합니다.
• 특정 요소를 탐색 순서에서 제외하려면 tabindex="-1"을 사용합니다.

3. 실전 예제: 카드 컴포넌트 개선

문제점

초기 코드에서 다음과 같은 문제가 있었습니다:

1. 과도한 `` 태그 사용으로 시맨틱 구조가 부족.
2. tabindex 속성 남용으로 키보드 탐색이 비정상적으로 작동.
3. button 태그를 a 태그 내부에 삽입하여 HTML 구조 오류 발생.

수정 과정

수정 전 코드:

<div class="card-link">
  <div class="card-link-column">
    <a href="/">
      <div class="card-content" tabindex="0">
        <img src="./assets/image.jpg" alt="상품 이미지" class="product-card-image" />
        <div class="arrow-icon-container" tabindex="0">
          <img src="./assets/icon.svg" alt="아이콘" />
        </div>
      </div>
    </a>
  </div>
</div>

최종 수정 코드:

<ul class="card-link">
  <li class="card-link-item">
    <a href="/" class="card-content">
      <img src="./assets/image.jpg" alt="상품 이미지" class="product-card-image" />
      <span class="purchase-icon-container" aria-label="구매하기">
        <img src="./assets/icon.svg" alt="구매하기 아이콘" />
      </span>
    </a>
  </li>
</ul>

개선 사항

1. 시맨틱 태그 활용: ul과 li를 사용해 목록 구조를 명확히 함.
2. HTML 구조 오류 제거: button 대신 span을 사용하여 구조적 문제 해결.
3. 웹 접근성 향상: 키보드 탐색은 기본적인 HTML 마크업 순서에 따라 자연스럽게 이루어지도록 설계.

4. tabindex 활용 시 주의사항

• 남용 금지: tabindex 값을 0보다 큰 값으로 설정하면 접근성 도구의 탐색 흐름을 방해할 수 있습니다[3].
• 자연스러운 탐색 보장: 마크업 순서를 논리적으로 구성하여 추가적인 tabindex 설정 없이도 키보드 탐색이 원활하도록 작성합니다.
• 비대화형 콘텐츠에 이벤트 추가: 필요할 경우만 tabindex를 사용해 키보드 이벤트를 활성화합니다.

5. 요약

웹 개발에서는 디자인 요구사항과 접근성 사이의 균형을 유지해야 합니다. 시맨틱 태그와 적절한 tabindex 속성 사용은 사용자 경험과 웹 접근성을 동시에 향상시킬 수 있습니다. 위 예제는 이러한 원칙을 실천하며, 올바른 HTML 구조와 속성 활용의 중요성을 보여줍니다.

• 예외를 처리하는 방법, 특정 문 실행시 에러가 발생한다면 나머지 코드를 계속 실행하는 것은 의미가 없음
• 그래서 이러한 예외를 처리해서 우회하는 방법이나 다양하게 처리를 하는 것, 사용자에게 예외 사항을 알려주는 경우도 포함

try-catch

• 기본적으로 에러를 다룰 때 try-catch 구문으로 다룸
• try 구문에서 발생한 에러는 catch에서 error 객체로 들어가 catch 구문이 실행이 됨
• 이 error 객체에 다양한 에러 관련 값들이 있기에 이를 잘 처리해 에러 처리를 할 수 있음

  try {
  X();
  } catch (e) {
  // try에서 에러가 발생할 경우 실행되는 구문
  console.error(e);
  console.error('에러 발생');
  } finally {
  // 어떠한 상황에서도 실행되는 구문
  }

에러 - 던지기

• 사용자 & 개발자를 위해서 일부러 에러를 던져서 알려줄 수 있음

• 아래와 같이 에러를 던져서 처리할 수 있음

• 사이트가 다운되거나 알 수 없는 에러 등 사용자에게 안내해서 잘 처리할 수 있음

  function login(id, pw) {
  if (id === 'zero' && pw === 0000) {
    return true;
  }
  
  // 위 조건을 만족 못해도 문법적 에러가 없기에 직접 아래와 같이 throw를 통해 에러를 발생시켜줘야함
  throw new Error('로그인 실패')
  }
  

try { login('one', 111) } catch (error) { console.error(error); console.error('에러 발생'); window.alert(error); // 사용자에게 안내하는 것도 추가 } finally { console.log('로그인 시도 시간 : ' + new Date()); }

### 스택 - 추적
- 에러는 스택 형태로 쌓여서 기록이 됨, `e.stack` 을 통해서 에러의 스택을 확인할 수 있음
- 어디서부터 어디가 문제가 있는지 그 기록을 확인가능함, 어디서 잘못되고 처리해야하는지 스택 형태로 추적해서 확인가능함
```js
function x() {
  c();
  v();
  b();
  x();
  x();
  x();
}

try {
  x();
} catch (e) {
  console.error(e.stack);
}

• 로그를 보게 되면 스택 기록임을 알면 됨(에러에 대해서)

커스텀 - 에러

• 에러 객체는 메시지, 스택 꽤 여러가지 다룰 수 있는게 많음

• 좀 더 구체적인 에러처리를 위해서 에러 객체를 확장해서 직접 커스텀한 에러를 만들 수 있음

• 그리고 에러 객체를 구분해서 좀 더 디테일하게 처리할 수도 있음

  class LoginError extends Error {
  constructor(message) {
    super(message);
  
    this.name = 'Login Error';
  }
  }
  

// LoginError도 확장가능 class SomeError extends LoginError {

}

function login(id, pw) { if (id !== 'a') { throw new LoginError('아이디 불일치') }

if (id === 'a' && password === 'a') { return true; }

throw new Error('로그인 실패'); }

try { login('ac', 'a'); } catch (e) { console.error(e); if (e instanceof LoginError) { console.error('로그인 에러가 발생했습니다'); } else { console.error('에러가 발생했습니다.'); } } finally { console.log('로그인 시도 시간 : ' + new Date()); }

```

• 커스텀 에러 객체를 기존의 에러 객체에서 확장해서 만들 수 있음
• 더 견고하게 에러 처리를 하다보면 직접 만들어서 처리할 수 있음, 또한 커스텀 에러를 더 확장해서 만들 수도 있음

• 모듈은 독립적인 특성을 가진 기능 단위의 부품
• 프로그램의 기능을 독립적인 부품으로 분리한 것, 동시에 여러 다른 모듈과 함께 조합하여 재사용될 수 있음
• 여기서 중요한 것은 내가 만든 코드가 어떻게 재활용 할 수 있는가도 중요함
• 예전에는 즉시 실행함수, 클로저등으로 모듈로 응용해서 썼지만, 요즘에는 이러한 모듈을 지원을 해 줌

CommonJS

• JS 커뮤니티에서 만든 모듈 시스템임, NodeJS 모듈도 CommonJS로 이루어져있음(모듈 사용이 용이함)

• 아래와 같이 별도의 파일로 저장된 것에 대해서 모듈을 써서 할 수 있음

  // CommonJS (Export)
  function Person(name, age, location) {
  this.name = name;
  this.age = age;
  this.location = location;
  
  this.getName = function () {
    return this.name + '입니다';
  };
  }
  

module.exports = Person;

```js
// CommonJS (Import)
// require를 통해서 모듈을 불러와서 사용함
const Person = require('./02-CommonJS-person');

const me = new Person('kevin', 10, 'Korea');
const you = new Person('hart', 20, 'USA');

console.log(me.getName());
console.log(you.getName());

• 다양한 파일을 가져오고 다양한 함수, 객체등을 불러와서 처리할 수 있음, 이를 통해서 굳이 복잡하게 파일을 구성하지 않고 파일을 여러개 나누고 분리해서 재활용을 할 수 있음
• 파일 단위로 나눠서 편하게 할 수 있음

amd

• Asynchronous Module Definition의 약자, 모듈을 선언하면서 의존하고 있는 모듈을 함께 명시, 비동기적으로 의존 모듈을 불러옴

• 왜냐하면 CommonJS는 동기적으로 쓰기 때문임

• 아래와 같이 별도의 정의 문법을 바탕으로 사용할 수 있음

  define(['module'], function(module) {
  return function() {
  
  }
  })

• CommonJS는 서버에서 쓰면서 동기적으로 동작하고 amd의 경우 브라우저에서도 동작할 수 있고 비동기적인 특성을 가짐

• amd를 주로 쓰지 않지만 특성을 알아두면 좋음

umd

• Universal Module Definition으로 AMD와 CommonJS 두 방식 모두 지원하고 클라이언트, 서버 어디에서나 작동함
• 아래와 같이 적용되서 쓸 수 있음

  (function (root, factory) {
  if (typeof exports === 'object' && module.exports) {
    // CommonJS
    module.exports = factory(require('module'))
  } else if (typeof define === 'function' && define.amd) {
    // AMD
    define(['module'], function (module) { })
  } else {
    // 전역 공간
    root.global = factory(root.module)
  }
  }(this, function (module) {
  // 실제 모듈
  }))

es-module

• es-module은 최신 브라우저에서만 동작함, 아래와 같이 간단하게 키워드만을 통해서 쓸 수 있음

  export const a = 'a';
  

export function hello() { return 'hello'; }

export { a, hello };

```js
import { a, hello } from './05-es-module-export.js';
// as 키워드로 이름을 바꿀 수도 있음
// import * as i from './05-es-module-export.js';

console.log(a);
console.log(hello());

• 기본 내보내기와 기본 가져오기는 아래와 같이 할 수 있음, 해당 파일에서 내보내는 것이 기본이라 중괄호 없이 쓴 것

  function hello() {
  return 'hello';
  }
  

export default hello;

```js
import h from './05-es-module-default-export';

console.log(h());

• 브라우저에서도 아래와 같이 script 타입을 모듈로 지정해서 쓸 수 있음

  <!DOCTYPE html>
  <html lang="ko">
  <head>
    <title>Zero base</title>
    <meta charset="utf-8" />
    <script type="module" src="./05-es-module-export.js"></script>
    <script type="module" src="./05-es-module-default-export.js"></script>
  </head>
  
  <body></body>
  </html>

  const a = 'a';
  

function hello() { return 'hello'; }

export { a, hello };

- 이 때 위의 경우 모듈을 순서대로 가져오는데 `async` 키워드를 붙이면 예측할 수 없음(비동기로 불러오니까)
```html
    <script async type="module" src="./05-es-module-export.js"></script>
    <script async type="module" src="./05-es-module-default-export.js"></script>

• 아래와 같이 되는 것을 확인가능함

  <!DOCTYPE html>
  <html lang="ko">
  <head>
    <title>Zero base</title>
    <meta charset="utf-8" />
    <script type="module" src="./05-es-module-export.js"></script>
    <script type="module">
      import { a, hello } from './05-es-module-export.js';
  
      console.log(a);
      console.log(hello());
    </script>
  </head>
  
  <body></body>
  </html>

• 참고자료