JD.com 면접 질문

JD.com 면접의 초점

일반적인 JD.com 면접 질문

• 이진 트리를 직렬화 및 역직렬화하는 함수를 구현하세요(LeetCode 297).
  좋은 답변이 다루는 것

  • 직렬화 시 재귀적 DFS로 트리를 순회하며 노드 값을 문자열에 추가
  • null 노드는 '#'으로 표시하여 구조 유지
  • 역직렬화는 큐를 이용해 전위 순서로 노드 복원
  • 시간복잡도 O(N), 공간복잡도 O(N)

  샘플 답변 보기

  이진 트리의 직렬화는 트리 구조를 문자열로 변환하는 과정입니다. 가장 일반적인 방법은 전위 순회를 사용하여 각 노드 값을 쉼표로 구분하고, null 노드는 특수 문자(예: '#')로 표시합니다. 재귀적으로 방문하며 루트, 왼쪽, 오른쪽 순서로 값을 추가하면 됩니다. 역직렬화는 직렬화된 문자열을 다시 트리로 복원하는 과정입니다. 문자열을 쉼표로 분할하여 리스트에 저장한 후, 재귀적으로 노드를 생성합니다. 이때 전위 순회 순서를 따르므로 리스트의 앞에서부터 값을 읽어가며 null이면 반환하고 아니면 노드를 만듭니다. 이 방법은 트리의 모든 노드를 한 번씩 방문하므로 시간복잡도는 O(N)이며, 공간복잡도도 재귀 스택과 문자열 저장으로 O(N)입니다. 주의할 점은 트리가 깊을 경우 재귀로 인한 스택 오버플로우 가능성이 있으므로 반복적 방법을 고려할 수 있습니다.

  # 이진 트리 노드 정의
  class TreeNode:
      def __init__(self, val=0, left=None, right=None):
          self.val = val
          self.left = left
          self.right = right
  
  class Codec:
      def serialize(self, root):
          """전위 순회로 직렬화, null 노드는 '#'"""
          def dfs(node):
              if not node:
                  return '#'
              # 루트 + 왼쪽 + 오른쪽
              return str(node.val) + ',' + dfs(node.left) + ',' + dfs(node.right)
          return dfs(root)
  
      def deserialize(self, data):
          """직렬화된 문자열을 트리로 복원"""
          def dfs(queue):
              val = queue.pop(0)
              if val == '#':
                  return None
              node = TreeNode(int(val))
              node.left = dfs(queue)
              node.right = dfs(queue)
              return node
          queue = data.split(',')
          return dfs(queue)
  
  # 시간복잡도: O(N), 공간복잡도: O(N)

• 하루에 수백만 건의 트랜잭션을 처리하는 분산 주문 처리 시스템을 설계하세요.
  좋은 답변이 다루는 것

  • 주문 처리의 핵심 요구사항: 높은 처리량, 내결함성, 순서 보장
  • 마이크로서비스 아키텍처로 주문 접수, 검증, 결제, 재고 차감 등을 분리
  • 메시지 큐(Kafka)를 사용해 비동기 통신 및 버퍼링
  • 데이터베이스 샤딩으로 주문 테이블을 분할하여 확장성 확보
  • 분산 트랜잭션 대신 Saga 패턴을 사용하여 일관성 유지

  샘플 답변 보기

  하루 수백만 건의 트랜잭션을 처리하는 분산 주문 처리 시스템은 높은 처리량과 안정성이 필수입니다. 먼저 요구사항을 분석하면, 주문은 생성, 결제, 재고 확인, 배송 등 여러 단계를 거치며, 순서가 보장되어야 하고 중복 주문이 없어야 합니다. 시스템은 마이크로서비스 아키텍처로 구성하여 각 기능을 독립적으로 배포 및 확장할 수 있게 합니다. 주문 접수 서비스는 사용자 요청을 받아 Kafka와 같은 메시지 큐에 발행합니다. 이후 주문 검증, 결제, 재고 차감 등의 서비스가 각각 큐에서 메시지를 소비하여 비동기로 처리합니다. 데이터베이스는 주문 ID를 기준으로 샤딩하여 수평 확장이 가능하게 합니다. 분산 트랜잭션의 복잡성을 피하기 위해 Saga 패턴을 사용하여 각 단계가 완료되면 다음 단계를 트리거하고, 실패 시 보상 트랜잭션을 실행합니다. 또한 주문 상태를 저장하는 테이블에 인덱스를 걸고, Redis와 같은 캐시를 사용하여 자주 조회하는 주문 상태를 빠르게 제공합니다. 모니터링과 로깅을 통해 시스템 상태를 지속적으로 파악하고, 장애 발생 시 자동 복구 메커니즘을 구현합니다.

• 프로젝트에서 속도와 품질 사이의 트레이드오프를 결정해야 했던 경험을 설명하세요. 어떻게 결정했습니까?
  좋은 답변이 다루는 것

  • 상황: 빠른 출시가 요구된 신규 기능 개발 프로젝트
  • 행동: MVP를 정의하고 핵심 기능에 집중, 코드 리뷰와 자동화 테스트 유지
  • 결과: 일정 내 출시 성공, 이후 피드백 반영하여 점진적 개선
  • 배운 점: 초기에 품질을 완전히 희생하지 않고도 속도를 높일 수 있음

  샘플 답변 보기

  과거에 신규 결제 시스템을 빠르게 출시해야 하는 프로젝트에서 속도와 품질 사이의 트레이드오프를 경험했습니다. 프로젝트 시작 시 제품팀은 3개월 내 출시를 요구했지만, 모든 요구사항을 완벽하게 구현하려면 6개월이 필요했습니다. 저는 팀과 함께 핵심 기능만 포함한 MVP를 정의했습니다. 필수 결제 수단만 지원하고, 비핵심 기능은 이후 업데이트로 미루기로 했습니다. 동시에 코드 리뷰와 자동화 테스트를 필수로 유지하여 기본적인 품질을 보장했습니다. 그 결과 일정 내에 안정적인 시스템을 출시할 수 있었습니다. 출시 후 사용자 피드백을 바탕으로 추가 기능을 단계적으로 배포했습니다. 이 경험을 통해 속도를 높이기 위해 품질을 완전히 희생할 필요가 없으며, 명확한 우선순위 설정과 점진적 개선이 효과적임을 배웠습니다.

• 구간 목록이 주어졌을 때, 모든 겹치는 구간을 병합하세요(LeetCode 56).
  좋은 답변이 다루는 것

  • 구간을 시작점 기준으로 정렬하여 병합 가능
  • 정렬 후 순차적으로 겹치는 구간을 하나로 합침
  • 새로운 구간의 시작이 현재 병합된 구간의 끝보다 작거나 같으면 겹침
  • 시간복잡도 O(N log N) (정렬), 공간복잡도 O(N) (결과 저장)

  샘플 답변 보기

  구간 병합 문제는 정렬 후 선형 스캔으로 해결할 수 있습니다. 먼저 구간을 시작점을 기준으로 오름차순 정렬합니다. 그런 다음 정렬된 리스트를 순회하면서 현재 병합 중인 구간과 다음 구간이 겹치는지 확인합니다. 겹치는 조건은 다음 구간의 시작이 현재 구간의 끝보다 작거나 같을 때입니다. 겹치면 현재 구간의 끝을 두 구간의 끝 중 큰 값으로 갱신합니다. 겹치지 않으면 현재 구간을 결과 리스트에 추가하고 다음 구간을 새로운 현재 구간으로 설정합니다. 이 알고리즘은 정렬에 O(N log N), 스캔에 O(N)이므로 전체 O(N log N)입니다. 공간은 결과 리스트에 O(N)이 필요합니다. 주의할 점은 구간이 빈 리스트로 주어질 수 있으므로 예외 처리해야 합니다.

  def merge(intervals):
      if not intervals:
          return []
      # 시작점 기준으로 정렬
      intervals.sort(key=lambda x: x[0])
      merged = [intervals[0]]
      for start, end in intervals[1:]:
          # 현재 병합된 구간의 끝
          last_end = merged[-1][1]
          if start <= last_end:
              # 겹치면 끝을 확장
              merged[-1][1] = max(last_end, end)
          else:
              # 겹치지 않으면 새 구간 추가
              merged.append([start, end])
      return merged
  
  # 시간복잡도: O(N log N), 공간복잡도: O(N)

• JD의 배달 네트워크를 위한 실시간 물류 추적 시스템을 설계하세요.
  좋은 답변이 다루는 것

  • 실시간 추적을 위해 GPS 데이터를 스트리밍으로 수집 (Kafka)
  • 배달 기사 위치를 메모리 내 데이터 저장소(Redis Geospatial)에 저장
  • 조회 API는 사용자에게 최신 위치를 빠르게 제공
  • 데이터 파이프라인으로 과거 데이터를 분석하여 예상 도착 시간 계산
  • 확장성을 위해 파티셔닝과 복제본 사용

  샘플 답변 보기

  실시간 물류 추적 시스템은 배달 기사와 배송물의 위치를 지속적으로 업데이트하고 사용자에게 조회 서비스를 제공해야 합니다. 먼저 각 배달 기사의 모바일 앱이 일정 간격(예: 5초)으로 GPS 좌표를 전송합니다. 이 데이터는 Kafka와 같은 메시지 큐를 통해 수집되어 스트리밍 처리됩니다. 위치 정보는 Redis의 Geospatial 자료구조를 사용하여 메모리에 저장함으로써 빠른 쓰기와 읽기를 지원합니다. 또한 지리적 지역별로 파티셔닝하여 부하를 분산합니다. 사용자가 주문 상태를 조회하면, 담당 배달 기사의 최신 위치를 Redis에서 읽어와 지도에 표시합니다. 예상 도착 시간을 계산하기 위해 과거 데이터를 Spark나 Flink로 분석하여 교통 상황 등을 반영한 모델을 만듭니다. 데이터 손실을 방지하기 위해 위치 메시지를 Kafka에 저장하고, Redis 클러스터를 구성하여 고가용성을 유지합니다. 확장성을 위해 지역을 기준으로 샤딩하고, Redis Read Replicas를 두어 조회 성능을 높입니다.

• 큰 테이블 간의 조인으로 인해 느린 데이터베이스 쿼리를 어떻게 최적화하시겠습니까?
  좋은 답변이 다루는 것

  • 실행 계획 분석 (EXPLAIN)으로 병목 구간 파악
  • 조인 컬럼에 인덱스 추가 (특히 외래 키와 필터 조건)
  • 불필요한 컬럼 조회를 피하고 서브쿼리나 뷰를 활용
  • 데이터 변경이 적다면 요약 테이블이나 캐시 사용 고려
  • 파티셔닝이나 샤딩으로 테이블 분할

  샘플 답변 보기

  큰 테이블 간의 조인이 느린 경우, 먼저 실행 계획을 분석하여 어떤 단계에서 비용이 많이 드는지 확인합니다. 대부분의 경우 조인 컬럼에 인덱스가 없어서 Full Table Scan이 발생하는 것이 원인입니다. 따라서 조인에 사용되는 컬럼과 WHERE 절의 필터 조건에 인덱스를 생성합니다. 또한 쿼리에서 필요한 컬럼만 SELECT하여 데이터 전송량을 줄입니다. 만약 조인 결과가 집계 쿼리라면, 미리 집계된 요약 테이블을 만들어 사용하거나, Redis와 같은 캐시를 활용할 수 있습니다. 데이터베이스 매개변수(예: join_buffer_size)를 튜닝하는 것도 도움이 됩니다. 테이블이 너무 크면 파티셔닝이나 샤딩을 고려하여 데이터를 분산시킵니다. 정규화를 역정규화하여 자주 조인되는 테이블을 하나로 합치는 전략도 있지만, 데이터 정합성에 주의해야 합니다. 마지막으로, 쿼리 자체를 재작성하여 더 효율적인 조인 순서나 서브쿼리를 사용할 수 있습니다.

• 팀 간 협업이 필요했던 프로젝트에 대해 말씀해 주세요. 결과는 어땠습니까?
  좋은 답변이 다루는 것

  • 상황: 사내 데이터 플랫폼 구축 프로젝트, 데이터 엔지니어링팀과 ML팀 협업
  • 행동: 정기 미팅을 통해 요구사항을 조율하고 공통 API 명세 정의
  • 결과: 플랫폼 지연 완료되었지만, 협업으로 재사용성 높은 아키텍처 구축
  • 배운 점: 초기부터 팀 간 커뮤니케이션 채널을 확립하는 것이 중요

  샘플 답변 보기

  사내 데이터 플랫폼을 구축하는 프로젝트에서 데이터 엔지니어링팀과 ML팀 간의 협업이 필요했습니다. 데이터 엔지니어링팀은 안정적인 데이터 파이프라인을 원했고, ML팀은 빠른 모델 실험을 위해 다양한 데이터 변환을 원했습니다. 초기에 우리는 주 1회 회의를 열어 각 팀의 요구사항을 공유하고 충돌 지점을 식별했습니다. 가장 큰 갈등은 데이터 변환을 어디에서 수행할지였습니다. 합의점으로 공통 데이터 레이어를 두어 변환된 데이터를 공유하고, 각 팀은 자신의 작업에 집중하기로 했습니다. 또한 API 명세를 함께 정의하여 인터페이스를 명확히 했습니다. 프로젝트는 예정보다 지연되었지만, 그 덕분에 재사용 가능한 데이터 API를 만들 수 있었고 이후 다른 팀에서도 사용하게 되었습니다. 이 경험을 통해 초기에 협업 규칙과 커뮤니케이션 채널을 설정하는 것이 중요하다고 깨달았습니다.

• LRU 제거 정책을 가진 캐시를 구현하세요(LeetCode 146).
  좋은 답변이 다루는 것

  • HashMap으로 키-값 저장, 이중 연결 리스트로 접근 순서 관리
  • get: 키가 있으면 노드를 리스트 맨 앞으로 이동하고 값 반환
  • put: 키가 있으면 값을 갱신하고 노드를 앞으로; 없으면 새 노드 생성 후 용량 초과 시 맨 뒤 노드 제거
  • 모든 연산 O(1) 시간 복잡도, 공간복잡도 O(capacity)

  샘플 답변 보기

  LRU 캐시는 가장 오랫동안 사용되지 않은 항목을 제거하는 정책입니다. 구현은 HashMap과 이중 연결 리스트를 결합합니다. HashMap은 키를 노드에 매핑하여 O(1) 조회를 제공하고, 이중 연결 리스트는 최근 사용 순서를 유지합니다. get 연산은 키가 존재하면 해당 노드를 리스트의 헤드로 이동시키고 값을 반환합니다. put 연산은 키가 이미 있으면 값을 업데이트하고 노드를 헤드로 이동시키며, 새로운 키이면 새 노드를 생성하여 헤드에 추가하고, 용량이 초과되면 테일 노드(가장 오래된)를 제거합니다. 이 방법은 모든 연산을 O(1)에 수행할 수 있습니다. 주의할 점은 더미 헤드와 테일을 사용하여 경계 조건을 간단히 처리하는 것입니다.

  class Node:
      def __init__(self, key=0, val=0):
          self.key = key
          self.val = val
          self.prev = None
          self.next = None
  
  class LRUCache:
      def __init__(self, capacity):
          self.capacity = capacity
          self.cache = {}  # 키 -> 노드
          # 더미 헤드와 테일
          self.head = Node()
          self.tail = Node()
          self.head.next = self.tail
          self.tail.prev = self.head
  
      def _remove(self, node):
          # 연결 리스트에서 노드 제거
          prev = node.prev
          nxt = node.next
          prev.next = nxt
          nxt.prev = prev
  
      def _add_to_head(self, node):
          # 헤드 바로 다음에 노드 추가 (가장 최근 사용)
          node.prev = self.head
          node.next = self.head.next
          self.head.next.prev = node
          self.head.next = node
  
      def get(self, key):
          if key in self.cache:
              node = self.cache[key]
              # 제거 후 헤드로 이동
              self._remove(node)
              self._add_to_head(node)
              return node.val
          return -1
  
      def put(self, key, value):
          if key in self.cache:
              node = self.cache[key]
              node.val = value
              self._remove(node)
              self._add_to_head(node)
          else:
              if len(self.cache) >= self.capacity:
                  # 가장 오래된 노드(테일 직전) 제거
                  lru = self.tail.prev
                  self._remove(lru)
                  del self.cache[lru.key]
              new_node = Node(key, value)
              self.cache[key] = new_node
              self._add_to_head(new_node)
  
  # 시간복잡도: O(1) (get, put 모두), 공간복잡도: O(capacity)

준비 팁

• 화이트보드나 일반 텍스트 편집기에서 코딩 연습을 하세요. JD.com은 자동 완성 없이 대면 코딩 세션을 자주 사용합니다.
• JD.com의 비즈니스와 최신 기술 뉴스, 특히 물류 자동화, 클라우드(JD Cloud), 소매 기술을 검토하세요.
• 면접이 언어를 전환할 수 있으므로 중국어와 영어로 사고 과정을 설명할 준비를 하세요.
• 시스템 설계 시 확장성과 내결함성에 중점을 두세요. JD.com은 광군제와 같은 피크 부하를 처리합니다.
• 행동 질문에 대해 주도성, 문제 해결, JD의 가치와의 일치를 강조하는 구체적인 예를 준비하세요.

자주 묻는 질문