코딩테스트 JS 자료구조 로드맵: 배열, 해시, 스택, 투 포인터 순서

이 글은 자료구조 이름을 외우는 로드맵이 아니라 문제의 입력·필요한 상태·반복문의 불변식으로 도구를 선택하는 기준을 제공합니다. 404였던 본문 이미지 두 개는 제거하고, 끊어진 배열 메서드 링크는 현재 공개된 학습 글로 교체했습니다. MDN과 ECMAScript 명세를 기준으로 Map의 성능 표현과 reduce 예외도 정확히 구분합니다.

이 글에서 정리하는 내용

• JS 코딩테스트는 배열 조작부터 익숙해져야 합니다
• 해시는 값을 세거나 빠르게 찾을 때 등장합니다
• 스택은 순서가 되돌아가는 문제에서 의심합니다
• 투 포인터는 범위를 줄이는 사고방식입니다
• 슬라이딩 윈도우는 구간을 다시 계산하지 않는 방식입니다
• 문제 유형은 쉬운 입력 추적부터 쌓아가는 것이 좋습니다
• 마지막에는 독자가 바로 적용할 기준을 남깁니다
• 읽는 순서를 정하면 글도 덜 흩어집니다

JS 코딩테스트는 배열 조작부터 익숙해져야 합니다

첫 단계는 입력을 숫자 배열로 바꾸고 인덱스, 현재 값, 누적 상태를 추적하는 연습입니다. map, filter, reduce를 모두 외우기 전에 반복문 한 번이 끝날 때 어떤 값이 변하는지 종이에 적어 보세요. 배열 메서드의 역할과 누적 패턴은 404였던 예전 경로 대신 현재 공개된 JavaScript reduce 학습 글에서 이어서 볼 수 있습니다.

const input = '10 20 30 40';
const values = input.trim().split(/\s+/).map(Number);
const total = values.reduce((sum, value) => sum + value, 0);

console.log(values); // [10, 20, 30, 40]
console.log(total);  // 100

MDN의 Array.prototype.reduce 문서와 ECMAScript 2026 reduce 명세는 callback과 선택적인 initialValue를 정의합니다. 빈 배열에서 initialValue 없이 reduce를 호출하면 TypeError가 발생하므로 코딩테스트에서는 합계의 0, 빈도 객체의 새 Map처럼 자료형에 맞는 초기값을 명시하는 편이 안전합니다.

배열 메서드가 항상 더 좋은 것은 아닙니다. 포인터가 여러 개이거나 중간에 종료해야 하거나 상태 변화가 복잡하면 for 또는 while이 불변식을 드러내기 쉽습니다. 반대로 모든 원소를 같은 규칙으로 변환·선별·누적할 때는 배열 메서드가 의도를 짧게 표현할 수 있습니다.

해시는 값을 세거나 빠르게 찾을 때 등장합니다

값의 등장 횟수, 이미 본 값, 키와 연결된 정보를 반복해서 확인한다면 Map을 후보로 봅니다. ECMAScript의 Map은 키와 값에 임의의 언어 값을 사용할 수 있고, 같은 키는 한 항목만 유지합니다. ECMAScript 2026 keyed collections 명세는 평균 접근 시간이 원소 수에 대해 선형보다 빨라야 한다고 요구하지만 내부 구현을 해시 테이블이나 엄격한 O(1)로 고정하지는 않습니다.

function countValues(values) {
  const counts = new Map();

  for (const value of values) {
    counts.set(value, (counts.get(value) ?? 0) + 1);
  }

  return counts;
}

console.log(countValues(['a', 'b', 'a']).get('a')); // 2

MDN Map 문서도 이 성능 요구와 키 비교 규칙을 설명합니다. 키가 문자열로 한정된 단순 빈도표는 객체로도 풀 수 있지만, 키의 자료형을 보존하거나 삽입 순회와 size가 필요하면 Map이 명확합니다. 반대로 값의 범위가 작고 고정된 정수라면 길이가 정해진 배열 카운터가 더 단순할 수 있습니다.

빈도표와 구간 이동이 함께 나오는 문제는 모든 아나그램 JS 풀이로 확장해 보세요. Map을 선택했다는 사실보다 반복문이 진행되는 동안 “현재 구간의 빈도가 정확하다”는 불변식을 유지하는 것이 핵심입니다.

스택은 순서가 되돌아가는 문제에서 의심합니다

스택은 마지막에 넣은 값을 먼저 꺼내는 LIFO 구조입니다. 괄호 짝, 최근 작업 취소, 중첩 구조, 이전의 더 큰 값처럼 현재 원소가 가장 최근의 미해결 원소와 연결될 때 의심합니다. JavaScript에서는 배열의 push와 pop으로 기본 스택을 구현할 수 있습니다.

function isValidParentheses(input) {
  const stack = [];

  for (const char of input) {
    if (char === '(') stack.push(char);
    if (char === ')') {
      if (stack.length === 0) return false;
      stack.pop();
    }
  }

  return stack.length === 0;
}

console.log(isValidParentheses('(())')); // true
console.log(isValidParentheses('(()'));  // false

이 코드의 불변식은 지금까지 읽은 접두사에서 닫히지 않은 여는 괄호만 stack에 남는다는 것입니다. 닫는 괄호를 만났을 때 stack이 비어 있으면 즉시 실패하고, 순회가 끝났을 때도 비어 있어야 합니다. 자세한 개념은 자료구조 스택 push·pop을, 적용 문제는 올바른 괄호 JS 풀이를 이어서 보세요.

투 포인터는 범위를 줄이는 사고방식입니다

투 포인터는 두 위치가 한 방향 또는 양쪽에서 움직이며 이미 확인한 후보를 다시 보지 않는 패턴입니다. 정렬된 두 배열 병합, 정렬된 배열의 합 찾기, 중복 제거가 입문 예시입니다. 포인터를 움직였을 때 버리는 후보가 다시 정답이 될 수 없다는 단조성 또는 정렬 근거가 있어야 합니다.

function mergeSorted(left, right) {
  const result = [];
  let i = 0;
  let j = 0;

  while (i < left.length && j < right.length) {
    if (left[i] <= right[j]) result.push(left[i++]);
    else result.push(right[j++]);
  }

  return result.concat(left.slice(i), right.slice(j));
}

console.log(mergeSorted([1, 3, 5], [2, 4])); // [1, 2, 3, 4, 5]

입력이 정렬되지 않았거나 포인터 이동이 어떤 후보를 안전하게 버리는지 설명할 수 없다면 투 포인터를 바로 적용하면 안 됩니다. 정렬 비용을 포함해도 이득인지 확인하고, 원래 인덱스가 필요한 문제라면 정렬 전에 인덱스를 함께 저장합니다. 이동이 눈에 보이는 연습은 두 배열 합치기 JS 풀이가 좋습니다.

슬라이딩 윈도우는 구간을 다시 계산하지 않는 방식입니다

슬라이딩 윈도우는 연속 구간의 상태를 유지하면서 오른쪽 값을 추가하고 왼쪽 값을 제거합니다. 고정 길이 k의 최대 합은 첫 구간을 한 번 계산한 뒤 창이 이동할 때 들어온 값과 나간 값만 반영하면 됩니다.

function maxFixedWindow(values, k) {
  if (k <= 0 || k > values.length) return null;

  let sum = values.slice(0, k).reduce((acc, value) => acc + value, 0);
  let best = sum;

  for (let right = k; right < values.length; right += 1) {
    sum += values[right] - values[right - k];
    best = Math.max(best, sum);
  }

  return best;
}

console.log(maxFixedWindow([2, 1, 5, 1, 3, 2], 3)); // 9

가변 길이 창에서 합이 기준을 넘으면 왼쪽을 줄이는 전형은 값이 모두 양수처럼 창 변화가 단조로울 때 성립합니다. 음수가 섞이면 왼쪽을 줄였을 때 합이 반드시 작아지지 않으므로 같은 규칙이 정답을 놓칠 수 있습니다. 이 경우 누적합, Map, 다른 탐색을 검토해야 합니다. “연속 구간”이라는 말만 보고 윈도우를 선택하지 말고 상태를 O(1)에 갱신할 수 있는지와 이동 근거를 확인하세요.

문제 유형은 쉬운 입력 추적부터 쌓아가는 것이 좋습니다

각 단계에서 쉬운 문제 세 개를 풀고, 정답 코드 없이 불변식과 시간·공간 복잡도를 말할 수 있을 때 다음 단계로 넘어가세요. 전체 준비 흐름은 프론트엔드 코딩테스트 5단계 준비 전략과 연결하면 좋습니다.

반드시 기록할 검증 항목

• 빈 배열, 원소 하나, 중복만 있는 입력, 정렬 여부 등 경계값을 적습니다.
• 반복문 시작과 끝에 참이어야 하는 불변식을 한 문장으로 씁니다.
• 시간 복잡도에 정렬·slice·concat·중첩 메서드 비용까지 포함합니다.
• Map을 무조건 O(1)이라고 단정하지 않고 명세가 보장하는 범위와 문제 제한을 구분합니다.
• 브루트포스와 작은 무작위 입력을 비교해 최적화 풀이의 결과를 검산합니다.

마지막에는 독자가 바로 적용할 기준을 남깁니다

도구를 고른 뒤에는 “왜 이 자료구조가 필요한가”, “반복문이 진행돼도 무엇이 항상 맞는가”, “어떤 입력에서 규칙이 깨지는가”를 답하세요. 세 질문에 답하지 못하면 이름을 외운 것이지 풀이를 설계한 것은 아닙니다.

읽는 순서를 정하면 글도 덜 흩어집니다

결론: 배열은 모든 풀이의 입력과 순회의 바닥이고, Map·스택은 필요한 상태의 모양을 바꾸며, 투 포인터·슬라이딩 윈도우는 반복해서 보던 후보나 구간 계산을 줄입니다. 배열 → Map·Set → 스택 → 투 포인터 → 슬라이딩 윈도우 순서로 학습하되, 각 단계는 코드 암기가 아니라 불변식·예외·검증으로 통과하세요.

오늘은 새 알고리즘을 더 외우기보다 이미 푼 문제 하나를 골라 입력 크기, 저장 상태, 불변식, 경계값, 시간 복잡도를 다섯 줄로 다시 적어 보세요. 그 기록이 다음 문제에서 자료구조를 선택하는 실제 기준이 됩니다.

공식 근거

• MDN: Array.prototype.reduce
• MDN: Map
• ECMAScript 2026: Indexed Collections
• ECMAScript 2026: Keyed Collections

실행 보충 실습: 함수·표준 입력·복잡도를 직접 확인하기

자료구조를 고르기 전에 코드가 어디에서 입력을 받고 어디로 답을 내보내는지 고정해야 합니다. 브라우저에서 버튼을 눌러 실행하던 JavaScript와 Node.js 채점 코드는 같은 문법을 쓰지만 입출력 도구가 다릅니다. 이 보충 실습은 위에서 사용한 합계 계산을 실행 파일로 완성합니다. 새로운 출제 문제를 추가한 것이 아니라 입력 경로를 비교하기 위한 연습입니다.

1. 실행 환경과 제출 계약을 먼저 확인합니다

플랫폼 이름만으로 제출 방식을 추측하지 말고 문제의 JavaScript 실행 버전, 함수 이름·인수·반환 타입 또는 표준 입력 형식을 확인하세요. 함수 호출형에서는 console.log만 하고 return을 빼면 채점기가 답을 받지 못할 수 있습니다. 표준 입력형에서는 디버그 문장이 표준 출력에 섞이면 오답이 됩니다.

터미널에서 node --version을 실행해 설치 여부와 버전을 확인합니다. 아래 파일은 CommonJS를 명시하는 .cjs 확장자를 사용하므로 주변 package.json의 type 설정과 혼동을 줄입니다. 브라우저에서는 Node의 require와 파일 API를 그대로 사용할 수 없습니다. Node.js CommonJS 문서를 기준으로 구성했습니다. 이 실습은 Node.js v24.19.0에서 실행했습니다.

2. 계산 함수를 입출력에서 분리합니다

solution은 숫자 배열을 받아 합계 숫자를 반환합니다. 빈 배열의 합은 0으로 정합니다. solution.cjs를 저장하세요. 마지막 module.exports는 다음 파일과 로컬 테스트에서 함수를 불러오기 위한 연결입니다. 함수 호출형 채점에 제출할 때는 채점기가 요구하는 solution 함수 선언을 사용하고, 로컬 연결용 export 줄과 테스트 실행 부분은 제출 형식에 맞게 제외합니다.

파일: solution.cjs

function solution(values) {
  let total = 0;
  for (const value of values) total += value;
  return total;
}
module.exports = { solution };

이 함수 자체에는 파일 읽기나 출력이 없습니다. 입력 형식이 달라져도 같은 숫자 배열로 바꾸면 계산 부분을 그대로 검증할 수 있습니다. sum 대신 total 하나만 유지하며 이미 읽은 값의 합이 total이라는 불변식을 사용합니다.

3. 표준 입력을 읽고 숫자로 바꿉니다

이 연습의 입력 계약은 첫 토큰 N 뒤에 정수 N개입니다. N은 0 이상 100000 이하, 각 값의 절댓값은 1000000 이하로 제한합니다. 따라서 합의 절댓값도 최대 100000000000이고 Number의 안전한 정수 범위 안입니다. 제한을 없애면 Number 정밀도와 BigInt 필요 여부를 다시 판단해야 합니다.

파일: main.cjs

const fs = require('node:fs');
const { solution } = require('./solution.cjs');

function solve(input) {
  const trimmed = input.trim();
  if (trimmed === '') throw new Error('입력이 비었습니다.');
  const tokens = trimmed.split(/\s+/);
  if (!tokens.every((token) => /^-?\d+$/.test(token))) {
    throw new Error('정수 토큰만 허용합니다.');
  }
  const [n, ...values] = tokens.map(Number);
  if (!Number.isSafeInteger(n) || n < 0 || n > 100000 || values.length !== n) {
    throw new Error('개수 N과 값의 개수를 확인하세요.');
  }
  if (!values.every((value) => Number.isSafeInteger(value) && Math.abs(value) <= 1000000)) {
    throw new Error('각 값은 절댓값 1000000 이하의 정수여야 합니다.');
  }
  return String(solution(values));
}

if (require.main === module) {
  try {
    process.stdout.write(solve(fs.readFileSync(0, 'utf8')) + '\n');
  } catch (error) {
    console.error(error.message);
    process.exitCode = 1;
  }
}
module.exports = { solve };

readFileSync(0, “utf8”)의 0은 표준 입력 파일 디스크립터이고 utf8은 문자열로 읽겠다는 설정입니다. Node.js stdin 문서와 파일 읽기 문서에서 확인할 수 있습니다. require.main === module 조건 때문에 직접 실행할 때만 입력을 읽고, 테스트에서 불러올 때는 입력을 기다리지 않습니다.

빈 문자열에 곧바로 split과 Number를 적용하면 빈 입력을 0으로 오해할 수 있어 먼저 검사했습니다. /\s+/는 연속 공백·탭·줄바꿈을 함께 나누고 Number가 숫자로 변환합니다. 그러나 문장, 격자 행, 앞뒤 공백이 의미 있는 문제에는 전체 trim과 공백 분리가 맞지 않을 수 있습니다. 그런 문제는 줄 단위 구조를 유지하는 별도 파서가 필요합니다.

input.txt를 같은 폴더에 저장합니다. 아래 명령은 macOS·Linux·Git Bash·Windows 명령 프롬프트처럼 입력 리다이렉션을 지원하는 셸에서 실행합니다. PowerShell에서는 같은 폴더에서 cmd /c "node main.cjs < input.txt"로 실행할 수 있습니다. 온라인 채점기가 한 파일만 받는다면 solution 함수와 main.cjs의 입출력 부분을 한 제출 파일로 합치고 로컬 require/export 연결은 제거해야 합니다.

파일: input.txt

4
10 20 30 40

node main.cjs < input.txt

정상 결과는 숫자 100과 줄바꿈 하나입니다. 이 명령은 입력 파일을 표준 입력으로 보내므로 키보드 입력 종료를 기다리지 않습니다.

100

4. 예제뿐 아니라 경계값과 실제 프로세스를 확인합니다

test.cjs는 계산 함수, 입력 파서, 실제 Node 프로세스의 표준 출력과 종료 코드를 각각 검사합니다. 프로세스 실행에 셸 명령 문자열을 사용하지 않으므로 경로의 공백이나 셸별 리다이렉션 차이 없이 동일한 입력을 보낼 수 있습니다. 아래 검증문은 본문 파일을 직접 불러옵니다.

파일: test.cjs

const assert = require('node:assert/strict');
const { spawnSync } = require('node:child_process');
const path = require('node:path');
const { solution } = require('./solution.cjs');
const { solve } = require('./main.cjs');
assert.equal(solution([]), 0);
assert.equal(solution([10, 20, 30, 40]), 100);
assert.equal(solve('4\r\n10  20\t30 40\r\n'), '100');
assert.equal(solve('0\n'), '0');
assert.equal(solve('3\n-3 0 2'), '-1');
assert.throws(() => solve(''), /비었습니다/);
assert.throws(() => solve('2\n1'), /개수/);
assert.throws(() => solve('1\n3px'), /정수 토큰/);
assert.throws(() => solve('1\n1000001'), /절댓값/);
assert.equal(solve('100000\n' + Array(100000).fill('1000000').join(' ')), '100000000000');
const run = spawnSync(process.execPath, [path.join(__dirname, 'main.cjs')], {
  input: '4\n10 20 30 40\n', encoding: 'utf8',
});
assert.equal(run.status, 0);
assert.equal(run.stdout, '100\n');
assert.equal(run.stderr, '');
const invalid = spawnSync(process.execPath, [path.join(__dirname, 'main.cjs')], {
  input: '2\n1\n', encoding: 'utf8',
});
assert.equal(invalid.status, 1);
assert.equal(invalid.stdout, '');
assert.match(invalid.stderr, /개수/);
console.log('함수, 공백, 경계값, 표준 입출력 검증 통과');

node test.cjs

“함수, 공백, 경계값, 표준 입출력 검증 통과”가 나오면 CRLF 줄바꿈, 빈 배열, 음수, 개수 불일치, 숫자가 아닌 토큰, 값 범위, 최대 N과 실제 stdout까지 통과한 것입니다. 잘못된 입력은 표준 출력에 답을 쓰지 않고 오류 메시지와 종료 코드 1을 내는 것으로 계약을 정했습니다. 채점 문제에서 유효 입력이 보장된다면 이런 방어 검사는 제출 코드에서 간소화할 수 있습니다.

5. 시간 측정 전에 반복 횟수를 셉니다

계산 함수 solution은 N개를 한 번 방문하므로 O(N) 시간, 합계 변수는 O(1) 추가 공간입니다. 전체 프로그램은 원본 문자열, 토큰, 숫자 배열을 저장하므로 전체 공간을 O(1)이라고 쓰면 안 됩니다. 입력 문자열 길이를 L이라고 하면 파싱은 O(L), 계산은 O(N), 전체 저장은 O(L + N)으로 봅니다. 이 입력 계약처럼 정수 자릿수가 제한되면 보통 전체를 O(N)으로 요약할 수 있습니다.

중첩 반복문에서는 안쪽 범위까지 합해야 합니다. 모든 서로 다른 위치 쌍을 한 번씩 방문하면 N(N-1)/2회입니다. 아래 파일은 실행 속도의 초 단위를 재는 대신 실제 방문 횟수를 출력합니다. 따라서 컴퓨터 성능에 상관없이 입력 크기에 따른 증가를 비교할 수 있습니다.

파일: complexity.cjs

const assert = require('node:assert/strict');
function countVisits(n) {
  let linear = 0;
  let pairs = 0;
  for (let i = 0; i < n; i += 1) linear += 1;
  for (let i = 0; i < n; i += 1) {
    for (let j = i + 1; j < n; j += 1) pairs += 1;
  }
  return { n, linear, pairs };
}
for (const n of [0, 1, 10, 100]) {
  const result = countVisits(n);
  assert.equal(result.linear, n);
  assert.equal(result.pairs, n < 2 ? 0 : n * (n - 1) / 2);
  console.log(JSON.stringify(result));
}

node complexity.cjs

{"n":0,"linear":0,"pairs":0}
{"n":1,"linear":1,"pairs":0}
{"n":10,"linear":10,"pairs":45}
{"n":100,"linear":100,"pairs":4950}

N이 10에서 100으로 10배 늘 때 한 번 순회는 10에서 100회로 늘지만, 쌍 방문은 45에서 4950회로 늘어납니다. Big-O는 상수와 작은 항을 생략해 큰 입력에서의 증가 양상을 설명하므로 쌍 방문은 O(N²)입니다. 이 숫자가 특정 채점 제한의 통과 시간을 보장하지는 않습니다. 정렬, slice, 반복문 안의 includes처럼 숨어 있는 전체 순회도 함께 계산해야 합니다.

이제 세 수 중 최솟값으로 돌아가 보세요. 입력은 문자열에서 숫자로 바꾸지만 비교 대상은 항상 세 개라 계산은 O(1)이라는 점을 위의 N개 합계와 비교하면 됩니다. 디버깅할 때는 실행 실패, 파싱 실패, 계산 오답, 출력 형식 오류를 순서대로 나누어 확인하세요.