P2-9.4 보충학습: 전통적인 자료구조를 처음 읽는 법¶

Section ID: P2-9.4 Version: v2026.07.23

P2-9.1에서는 자료구조(data structure)를 데이터를 담는 모양과 그 데이터를 다루는 방법으로 봤습니다. 그런데 자료구조를 공부하다 보면 갑자기 낯선 이름들이 많이 나옵니다.

배열(array), 연결 리스트(linked list), 스택(stack), 큐(queue), 트리(tree), 그래프(graph), 해시 테이블(hash table).

여기서는 전통적인 자료구조 이름을 읽는 기준을 설명합니다. 이 절은 배열·연결 리스트·스택·큐·트리·그래프·해시 테이블 같은 이름을 질문 중심으로 다시 읽는 기준을 정리합니다.

이 이름들을 처음부터 구현 방식으로 외우면 어렵습니다. 이 보충학습에서는 먼저 “각 구조가 어떤 문제를 해결하려고 등장했는가”를 봅니다.

프로그래밍 기초를 오래전에 배웠거나, Python을 실습 도구로 먼저 만난 독자라면 자료구조 이름이 더 낯설 수 있습니다. Python의 리스트와 딕셔너리는 많은 일을 편하게 처리해 주기 때문에, 전통적인 배열, 연결 리스트, 스택, 큐 같은 이름이 굳이 필요한지 의문이 생깁니다.

하지만 AI 실습을 조금만 넓혀도 이 이름들은 다시 돌아옵니다. 데이터셋은 표처럼 보이고, 토큰은 순서가 있는 시퀀스로 처리되며, 라벨은 키와 값의 매핑으로 관리되고, 검색과 추천은 관계와 인덱스 구조를 사용합니다. 전통 자료구조는 “옛날 문법”이 아니라 데이터를 읽는 기본 언어에 가깝습니다.

이 절은 배열, 스택, 큐, 그래프 이름이 한꺼번에 낯설 때 이 이름이 어떤 질문을 쉽게 만드는가를 먼저 정리합니다.

먼저 가져갈 것¶

이 절은 필수 복습과 확장 배경이 한곳에 들어 있습니다. 처음 읽을 때는 아래 필수 다섯 가지를 먼저 붙잡고, 나머지는 뒤에서 다시 만나도 됩니다.

구분	먼저 가져갈 내용
필수	배열(array)은 위치(index)로 값을 읽는 구조라는 점
필수	스택(stack)은 마지막에 넣은 것을 먼저 꺼내는 규칙이라는 점
필수	큐(queue)는 먼저 들어온 것을 먼저 꺼내는 규칙이라는 점
필수	트리(tree)는 계층 관계를, 그래프(graph)는 연결 관계를 표현한다는 점
필수	Python의 리스트(list)와 딕셔너리(dictionary) 뒤에도 이런 더 일반적인 자료구조 질문이 있다는 점
확장	연결 리스트(linked list)의 연결 감각
확장	해시 테이블(hash table)의 내부 조직 감각
확장	구현 세부, 복잡도, 메모리 배치 같은 이후 학습 주제

용어	이 절에서 먼저 잡을 뜻
배열(array)	위치가 붙은 값 칸을 차례로 읽는 구조입니다.
연결 리스트(linked list)	각 항목이 다음 항목을 가리키는 식으로 이어진 구조입니다.
스택(stack)	마지막에 넣은 것을 먼저 꺼내는 규칙 중심 구조입니다.
큐(queue)	먼저 들어온 것을 먼저 꺼내는 규칙 중심 구조입니다.
해시 테이블(hash table)	키로 값을 빠르게 찾도록 조직한 구조입니다.

처음 읽는 기준: 전통적인 자료구조를 처음 읽는 법¶

전통적인 자료구조 이름을 문제 해결 질문과 연결해 읽을 수 있습니다.
선형 구조(linear structure), 비선형 구조(non-linear structure), 키 기반 구조(key-based structure)를 입문 수준에서 구분할 수 있습니다.
Python의 리스트와 딕셔너리가 전통 자료구조 설명과 완전히 같은 말은 아니지만, 그 감각을 빌려 이해할 수 있음을 설명할 수 있습니다.
AI 실습에서 데이터셋, 토큰 목록, 라벨 맵, 문서 관계, 검색 색인 같은 구조가 서로 다른 자료구조 감각을 요구한다는 점을 설명할 수 있습니다.

먼저 붙잡을 기준¶

이 보충학습에서 가장 먼저 붙잡아야 할 기준은 자료구조 이름은 대표 질문을 붙인 표지라는 점입니다.

이름	먼저 붙잡을 질문
배열(array)	몇 번째 위치의 값인가
스택(stack)	마지막에 넣은 것을 먼저 꺼내는가
큐(queue)	먼저 들어온 것을 먼저 꺼내는가
트리(tree)	부모-자식 관계가 있는가
그래프(graph)	무엇과 무엇이 연결되는가
해시 테이블(hash table)	키로 값을 빨리 찾고 싶은가

즉 이 절은 구현 세부보다 이 이름이 어떤 문제를 쉽게 만드는가를 먼저 읽는 절입니다.

배경¶

전통 자료구조는 Python 문법보다 먼저 배우기도 하지만, 재학습 경로에서는 오히려 뒤에서 다시 보는 편이 더 자연스러울 수 있습니다. 이미 리스트와 딕셔너리를 써 본 뒤에 배열, 스택, 큐, 트리, 그래프를 다시 읽으면 이 이름이 어떤 질문을 쉽게 만드는가를 더 잘 붙잡을 수 있기 때문입니다.

이 절은 그래서 구현 세부보다 왜 이 구조가 필요한가를 먼저 묻도록 구성합니다. 자료구조를 이름 목록으로 외우기보다, AI 실습에서 어떤 장면과 연결되는지 읽는 데 목적을 둡니다.

세 가지 기준¶

기준	왜 중요한가	이 절에서 필요한 이해 수준
왜 전통 자료구조를 다시 보는가	Python 문법 뒤에 있는 더 일반적인 사고를 회복하게 해 줍니다.	자료구조 이름이 옛 문법이 아니라 질문의 언어라는 점을 잡습니다.
자료구조 이름이 대표하는 것	저장 방식 암기보다 어떤 문제를 쉽게 만드는지 먼저 보게 해 줍니다.	이름마다 대표 질문이 다르다는 점을 이해합니다.
Python 자료형과의 관련	이미 배운 리스트와 딕셔너리를 더 넓은 구조 감각에 연결하게 해 줍니다.	리스트와 딕셔너리도 오래된 자료구조 생각과 이어져 있음을 이해합니다.

주요 학습내용¶

전통 자료구조를 왜 뒤에서 다시 보는가¶

P2-8에서는 Python 문법을 먼저 봤습니다. 그 순서는 의도적입니다. 처음부터 자료구조 이론으로 들어가면 구현 세부가 많아지고, AI 재학습이라는 목적에서 멀어질 수 있기 때문입니다.

하지만 Python 문법만으로는 다음 질문에 답하기 어렵습니다.

왜 리스트(list)는 순서대로 처리하기 좋은가?
왜 딕셔너리(dictionary)는 이름이나 ID로 값을 찾기 좋은가?
왜 어떤 데이터는 표(table)로 보고, 어떤 데이터는 그래프(graph)로 보는가?
왜 같은 데이터라도 검색, 추천, 분류, 시각화 목적에 따라 구조가 달라지는가?

전통 자료구조는 이 질문에 답하는 배경 지식입니다. 이 절은 구현 수업이 아니라, 자료구조 이름을 읽을 때 머릿속에 떠올릴 최소 지도를 만드는 보충학습입니다.

자료구조 이름은 질문을 대표한다¶

자료구조를 이름 목록으로 외우면 금방 헷갈립니다. 대신 각 이름이 대표하는 질문을 먼저 봅니다.

자료구조	대표 질문	먼저 떠올릴 장면
배열(array)	몇 번째 위치의 값인가?	순서대로 놓인 숫자, 벡터, 픽셀
연결 리스트(linked list)	다음 값은 어디에 있는가?	항목이 서로 다음 항목을 가리키는 구조
스택(stack)	마지막에 넣은 것을 먼저 꺼내는가?	되돌리기, 호출 흐름, 임시 보관
큐(queue)	먼저 들어온 것을 먼저 처리하는가?	작업 대기열, 요청 처리
트리(tree)	부모와 자식 관계가 있는가?	폴더, 분류 체계, 의사결정 흐름
그래프(graph)	무엇과 무엇이 연결되어 있는가?	친구 관계, 링크, 지식 그래프
해시 테이블(hash table)	키로 값을 바로 찾고 싶은가?	ID로 사용자 찾기, 단어 빈도 세기

이 표는 엄밀한 분류표가 아니라 입문용 지도입니다. 실제 프로그래밍 언어의 자료구조는 내부 구현이 더 복잡합니다. 예를 들어 Python의 딕셔너리(dictionary)는 사용 관점에서는 키(key)로 값(value)을 찾는 매핑(mapping)이지만, 구현 관점에서는 해시 테이블과 연결됩니다.

자료구조를 읽을 때는 이름보다 연산(operation)을 먼저 봅니다.

자주 하는 연산	질문	연결되는 자료구조 감각
접근(access)	특정 위치나 키의 값을 바로 보고 싶은가?	배열, 딕셔너리
추가(insert)	값을 자주 넣는가?	리스트, 연결 리스트, 큐
삭제(delete)	값을 자주 빼는가?	리스트, 연결 리스트, 스택, 큐
검색(search)	원하는 값을 찾아야 하는가?	배열, 해시 테이블, 트리
순회(traversal)	전체를 차례로 훑어야 하는가?	리스트, 트리, 그래프
관계 이동	연결된 다음 대상으로 이동해야 하는가?	트리, 그래프

이 표도 절대적인 답은 아닙니다. 같은 자료구조라도 구현 방식과 데이터 크기에 따라 실제 성능은 달라질 수 있습니다. 여기서는 “어떤 질문을 떠올리면 좋은가”에 집중합니다.

자료구조를 고르는 세 가지 질문¶

자료구조를 고를 때는 다음 세 질문을 먼저 확인합니다.

첫째, 데이터에 순서가 있습니까?

문장 안의 토큰, 시간 순서로 들어오는 로그, 이미지의 픽셀처럼 순서와 위치가 중요하면 리스트, 배열, 시퀀스(sequence) 감각이 필요합니다.

둘째, 이름이나 ID로 찾아야 합니까?

사용자 ID로 사용자 정보를 찾거나, 라벨 번호로 라벨 이름을 찾거나, 단어별 빈도를 세야 한다면 딕셔너리, 매핑(mapping), 해시 테이블 감각이 필요합니다.

셋째, 대상 사이의 관계를 따라가야 합니까?

문서와 문서의 링크, 사람과 사람의 관계, 개념과 개념의 연결을 따라가야 한다면 트리나 그래프 감각이 필요합니다.

이 세 질문은 AI 실습에서도 자주 등장합니다.

질문	AI 실습 예시	먼저 떠올릴 구조
순서가 중요한가?	토큰 목록, 시계열 데이터, 이미지 픽셀	리스트, 배열, 시퀀스
키로 찾아야 하는가?	라벨 맵, 단어 빈도, 설정값	딕셔너리, 해시 테이블
관계를 따라가야 하는가?	문서 링크, 지식 그래프, 추천 관계	트리, 그래프

이 세 질문을 더 짧게 다시 묶으면:

먼저 물을 것	왜 필요한가
순서가 중요한가	선형 구조 감각을 고르기 위해
이름이나 ID로 찾는가	키 기반 구조 감각을 고르기 위해
관계를 따라가야 하는가	비선형 구조 감각을 고르기 위해

세부 학습내용¶

선형 구조: 한 줄로 이어진다고 생각하기¶

선형 구조(linear structure)는 데이터를 한 줄의 순서로 보는 구조입니다. 배열, 연결 리스트, 스택, 큐가 여기에 가깝습니다.

선형 구조를 볼 때는 다음 질문을 먼저 합니다.

순서가 중요한가?
몇 번째 위치인지가 중요한가?
앞에서부터 처리하는가?
뒤에서부터 꺼내는가?
중간에 넣고 빼는 일이 많은가?

배열(array)¶

배열(array)은 같은 종류의 값을 위치(index)로 다루는 구조입니다. 수학에서 벡터(vector)를 볼 때도 위치 감각이 중요하고, 이미지 처리에서 픽셀(pixel)을 볼 때도 위치 감각이 중요합니다.

여기서는 배열을 “번호가 붙은 칸”으로 생각합니다.

위치(index)	0	1	2	3
값(value)	10	20	30	40

배열은 위치로 접근하는 감각을 줍니다. 그래서 NumPy 배열(array), 벡터(vector), 행렬(matrix)을 배울 때 다시 등장합니다.

배열을 이해할 때 중요한 점은 “위치가 의미를 갖는다”는 것입니다. 예를 들어 임베딩 벡터(embedding vector)의 각 칸은 숫자 하나를 담지만, 그 숫자들이 모인 위치 관계가 모델의 계산에 사용됩니다. 이미지도 픽셀 값이 아무 순서로 흩어져 있으면 이미지가 되지 않습니다. 어느 위치의 값인지가 중요합니다.

Python의 리스트도 위치로 값을 꺼낼 수 있으므로 배열처럼 보입니다.

문제 상황: 배열처럼 위치가 중요한 구조에서 특정 칸의 값을 바로 꺼내 보고 싶습니다. 입력(input): 숫자 네 개가 순서대로 담긴 리스트와 인덱스 2입니다. 기대 출력(output): 세 번째 위치의 값 30이 출력됩니다. 확인할 개념: 배열 감각의 핵심이 값 자체보다 위치(index)로 접근하는 데 있음을 봅니다.

# 이 예제는 전통적인 자료구조가 저장 방식과 접근 방식을 어떻게 다르게 만드는지 확인합니다.
values = [10, 20, 30, 40]
print(values[2])

그러나 Python 리스트와 전통적인 배열을 완전히 같은 말로 보면 곤란합니다. Python 리스트는 여러 객체에 대한 참조를 담는 동적 구조이고, NumPy 배열은 같은 종류의 숫자를 촘촘하게 담아 계산하기 좋게 만든 구조입니다. 지금은 “위치로 접근한다”는 공통 감각만 가져가면 됩니다.

연결 리스트(linked list)¶

여기부터의 연결 리스트와 뒤 해시 테이블 단락은 확장 읽기에 가깝습니다. 배열, 스택, 큐, 트리, 그래프의 대표 질문이 먼저 잡혔다면 이 부분은 다음 학습으로 넘겨도 괜찮습니다.

연결 리스트(linked list)는 각 항목이 다음 항목을 가리킨다고 생각하는 구조입니다. 배열처럼 모든 칸이 연속된 위치에 있다고 생각하기보다, “이 항목 다음은 저 항목”이라는 연결 관계를 생각합니다.

여기서는 다음처럼 이해합니다.

1	`Kim -> Lee -> Park -> None`

이 예시는 실제 Python 리스트와 같은 구현이라는 뜻이 아닙니다. 연결 리스트는 값을 저장한 항목(node)이 다음 항목을 가리킨다는 발상을 보여 줍니다.

연결 리스트는 이후 그래프를 이해할 때도 도움이 됩니다. “값들이 서로 가리킨다”는 감각이 관계 구조로 이어지기 때문입니다.

연결 리스트가 중요한 이유는 “데이터가 반드시 연속된 칸에 있어야 하는 것은 아니다”라는 생각을 열어 주기 때문입니다. 데이터가 다음 대상을 가리킬 수 있다면, 한 줄의 순서도 연결로 표현할 수 있습니다.

다만 Python을 사용하는 입문 단계에서 연결 리스트를 직접 구현할 일은 많지 않습니다. 여기서는 연결 리스트를 깊게 구현하기보다, 포인터(pointer), 노드(node), 연결(link)이라는 말을 만났을 때 겁먹지 않기 위한 배경으로 둡니다.

스택(stack)¶

스택(stack)은 마지막에 넣은 것을 먼저 꺼내는 구조입니다. 보통 LIFO(last in, first out)라고 부릅니다.

예를 들어 접시를 쌓으면 가장 위에 올린 접시를 먼저 꺼내게 됩니다.

push A
push B
push C
pop  -> C
pop  -> B

스택은 프로그래밍에서 되돌리기(undo), 함수 호출 흐름(call stack), 괄호 검사 같은 예시로 자주 등장합니다. 지금은 구현보다 “마지막에 넣은 것이 먼저 나온다”는 규칙을 기억하면 됩니다.

AI 실습에서도 스택 감각을 간접적으로 만납니다. 예를 들어 코드 실행 중 오류가 나면 traceback이 위에서 아래로 함수 호출 흐름을 보여 줍니다. 이때 “함수가 함수를 호출했고, 나중에 들어간 호출이 먼저 끝난다”는 감각은 스택과 연결됩니다.

큐(queue)¶

큐(queue)는 먼저 들어온 것을 먼저 처리하는 구조입니다. 보통 FIFO(first in, first out)라고 부릅니다.

줄을 서서 기다릴 때 먼저 온 사람이 먼저 처리되는 것과 비슷합니다.

enqueue A
enqueue B
enqueue C
dequeue -> A
dequeue -> B

큐는 요청 처리, 작업 대기열, 메시지 처리, 데이터 스트리밍에서 자주 등장합니다. AI 서비스에서도 사용자의 요청을 순서대로 처리하거나, 백그라운드 작업을 대기열에 넣는 방식과 연결됩니다.

큐는 서비스 관점에서 특히 중요합니다. 모델 호출이 오래 걸리거나, 이미지 생성처럼 작업 시간이 긴 요청은 바로 처리하지 않고 작업 대기열에 넣을 수 있습니다. 이때 큐는 단순한 자료구조 이름이 아니라 “요청을 어떤 순서로 처리할 것인가”라는 운영 관점과 연결됩니다.

비선형 구조: 한 줄이 아니라 관계로 보기¶

비선형 구조(non-linear structure)는 데이터를 한 줄의 순서로만 보지 않습니다. 대표적으로 트리와 그래프가 있습니다.

비선형 구조를 볼 때는 다음 질문을 먼저 합니다.

부모와 자식 관계가 있는가?
여러 대상이 서로 연결되는가?
하나의 경로만 있는가, 여러 경로가 있는가?
관계를 따라 이동해야 하는가?

트리(tree)¶

트리(tree)는 계층 관계를 표현하는 구조입니다. 하나의 루트(root)에서 시작해 가지(branch)가 갈라지는 모양으로 설명합니다.

폴더 구조를 생각하면 쉽습니다.

book
├─ part-01
│  └─ chapter-01
└─ part-02
   └─ chapter-09

트리는 분류 체계, 파일 시스템, 의사결정 트리(decision tree), 문서 구조를 설명할 때 자주 등장합니다. 한 학습 문서의 목차도 Part, Chapter, Section으로 내려가는 트리 구조에 가깝습니다.

트리를 볼 때는 “한 대상이 여러 하위 대상을 가진다”는 감각이 중요합니다. 예를 들어 책의 목차는 Part 아래 Chapter가 있고, Chapter 아래 Section이 있습니다. 이 구조에서는 위에서 아래로 내려가며 범위가 좁아집니다.

AI에서는 의사결정 트리(decision tree)처럼 판단 과정을 나누는 모델도 있고, 문서의 제목과 소제목을 계층으로 읽는 작업도 있습니다. 검색 시스템에서도 카테고리 분류나 문서 구조 이해에 트리 감각이 쓰입니다.

그래프(graph)¶

그래프(graph)는 대상 사이의 연결을 표현합니다. 그래프에서는 대상을 노드(node), 연결을 엣지(edge)라고 부릅니다.

트리는 그래프보다 제한적인 구조로 볼 수 있습니다. 트리는 보통 계층이 뚜렷하지만, 그래프는 여러 방향의 연결을 허용합니다.

Kim -- Lee
Kim -- Park
Lee -- Choi
Park -- Choi

그래프는 친구 관계, 웹 링크, 교통망, 지식 그래프, 추천 시스템, 검색 구조를 이해할 때 중요합니다. P2-9.3에서는 그래프를 관계 표현 관점에서 따로 다룹니다.

그래프는 “관계가 하나의 줄이나 계층으로만 정리되지 않을 때” 필요합니다. 친구 관계는 한 사람이 여러 사람과 연결될 수 있고, 문서 링크도 여러 방향으로 이어질 수 있습니다. 지식 그래프(knowledge graph)는 개념, 대상, 속성 사이의 관계를 노드와 엣지로 표현합니다.

그래프를 이해하면 “검색 결과가 왜 링크를 따라 확장되는가”, “추천이 왜 비슷한 사용자나 항목의 연결을 보는가”, “RAG에서 문서 조각들이 왜 관계를 가질 수 있는가” 같은 질문을 더 잘 볼 수 있습니다.

키 기반 구조: 이름표로 찾기¶

키 기반 구조(key-based structure)는 “어떤 값이 몇 번째에 있는가”보다 “어떤 키로 찾을 것인가”가 중요합니다.

Python에서 가장 익숙한 예는 딕셔너리(dictionary)입니다.

문제 상황: 몇 번째 위치가 아니라 이름표 같은 키로 점수를 바로 찾고 싶습니다. 입력(input): 이름을 키로 하고 점수를 값으로 갖는 딕셔너리입니다. 기대 출력(output): Kim이라는 키에 대응하는 점수 82가 출력됩니다. 확인할 개념: 키 기반 구조는 위치보다 키로 값을 찾는 감각이 핵심이라는 점을 봅니다.

# 이 예제는 전통적인 자료구조가 저장 방식과 접근 방식을 어떻게 다르게 만드는지 확인합니다.
score_by_name = {
    "Kim": 82,
    "Lee": 75,
    "Park": 91,
}

print(score_by_name["Kim"])

이 코드는 이름을 키(key)로 사용해 점수를 찾습니다.

전통 자료구조에서는 해시 테이블(hash table)이 키 기반 검색과 자주 연결됩니다. 해시 테이블은 키를 어떤 위치로 바꾸어 값을 찾는 구조라고 설명할 수 있습니다. 다만 실제 구현은 충돌 처리, 메모리 배치, 크기 조정 같은 세부 주제를 포함하므로 여기서는 깊게 들어가지 않습니다.

해시(hash)는 입문 단계에서 “키를 저장 위치를 찾기 위한 값으로 바꾸는 과정” 정도로 이해하면 됩니다. 예를 들어 "Kim"이라는 이름을 그대로 처음부터 끝까지 비교하며 찾는 대신, 그 이름을 어떤 숫자 위치로 바꾸어 값을 찾는 방식이 해시 테이블의 기본 감각입니다.

현실의 해시 테이블은 같은 위치가 나오는 충돌(collision)을 처리해야 하고, 데이터가 늘어나면 내부 크기도 조정해야 합니다. 이 절에서는 그런 구현 세부를 다루지 않습니다. 현재 본편에서는 충돌 처리와 리사이징을 따로 확장하지 않고, 중요한 것은 딕셔너리처럼 키로 값을 찾는 구조 뒤에 해시 테이블 감각이 있다는 점입니다.

여기서는 다음 정도를 기준으로 기억합니다.

리스트(list)는 순서대로 처리하기 좋습니다.
딕셔너리(dictionary)는 키로 찾기 좋습니다.
해시 테이블(hash table)은 키로 값을 찾는 구현 방식과 연결됩니다.

사례 및 예시¶

Python의 리스트와 딕셔너리는 전통 자료구조와 어떻게 이어지는가¶

Python을 먼저 배우면 리스트(list)와 딕셔너리(dictionary)가 매우 편리하게 느껴집니다. 그래서 “자료구조는 이 둘만 알면 되는 것 아닌가?”라는 생각이 들 수 있습니다.

하지만 전통 자료구조 이름을 알면 코드의 의도를 더 잘 읽을 수 있습니다.

Python에서 보이는 코드	자료구조 감각	읽는 방법
`items = []`	리스트, 시퀀스	여러 항목을 순서대로 모은다
`items.append(x)`	스택 감각도 가능	뒤에 값을 추가한다
`items.pop()`	스택 감각	마지막 값을 꺼낸다
`collections.deque()`	큐, 덱(deque)	앞뒤에서 넣고 뺀다
`{key: value}`	매핑, 해시 테이블 감각	키로 값을 찾는다
`{node: [neighbors]}`	그래프 인접 리스트 감각	노드별 연결 대상을 담는다

Python 객체가 전통 자료구조와 1:1로 완전히 같은 것은 아닙니다. 그러나 전통 자료구조 감각은 Python 코드를 읽을 때 “이 코드는 어떤 처리 방식을 의도하는가”를 파악하게 도와줍니다.

사례 1. Python 리스트와 딕셔너리만 알면 자료구조는 끝난 것인가¶

한 학습자가 Python 리스트와 딕셔너리를 익힌 뒤 배열, 스택, 큐, 트리, 그래프 같은 이름은 굳이 몰라도 되지 않을까라고 생각할 수 있습니다. 작은 실습에서는 실제로 그렇게 느껴질 수 있습니다.

하지만 작업이 커지면 질문이 달라집니다. 토큰은 순서대로 처리해야 하고, 작업 요청은 대기열처럼 다뤄야 하며, 라벨 이름은 키로 찾고, 문서 링크나 추천 관계는 연결 구조로 읽어야 합니다. 즉 Python 기본 자료형을 쓸 때도 그 뒤의 자료구조 감각이 계속 작동합니다.

이 보충학습이 전통적인 이름을 다시 꺼내는 이유도 여기에 있습니다. 목표는 구현 수업이 아니라, 어떤 문제를 해결하려고 이런 이름이 생겼는가를 읽는 것입니다. 그러면 Python 코드에서 이미 보고 있는 리스트와 딕셔너리도 더 큰 지도의 일부로 이해할 수 있습니다.

확인 가능한 결과는 AI 실습 장면을 구조 질문으로 다시 바꿔 볼 수 있는지입니다. 이건 순서 문제인가, 키 조회 문제인가, 관계 추적 문제인가를 구분할 수 있다면, 자료구조 이름을 단순 용어 목록이 아니라 문제 해석 도구로 쓰기 시작한 것입니다.

같은 자료를 다르게 담아 보기¶

다음 데이터는 같은 학생 정보를 세 가지 관점으로 담은 예입니다. 순서대로 처리하려면 리스트가 편하고, 이름으로 찾으려면 딕셔너리가 편하며, 친구 관계를 표현하려면 그래프에 가까운 구조가 필요합니다.

문제 상황: 같은 학생 정보를 순서, 키 조회, 관계 추적 관점으로 각각 담아 보고 싶습니다. 입력(input): 학생 이름, 점수, 친구 관계. 기대 출력(output): 순서 기반 첫 점수, 이름 기반 점수 조회, 연결된 친구 목록. 확인할 개념: 같은 데이터도 어떤 질문을 먼저 하느냐에 따라 자연스러운 자료구조가 달라집니다.

# 이 예제는 전통적인 자료구조가 저장 방식과 접근 방식을 어떻게 다르게 만드는지 확인합니다.
scores = [82, 75, 91]
score_by_name = {
    "Kim": 82,
    "Lee": 75,
    "Park": 91,
}
friends = {
    "Kim": ["Lee", "Park"],
    "Lee": ["Kim"],
    "Park": ["Kim"],
}

print("list by position:", scores[0])
print("dict by key:", score_by_name["Kim"])
print("graph by neighbor:", friends["Kim"])

세 예시는 모두 Python 문법으로 작성되어 있지만, 각각 다른 자료구조 감각을 사용합니다. 첫 번째는 순서, 두 번째는 키 기반 검색, 세 번째는 관계 표현입니다.

연습 및 예제¶

직접 돌려보는 최소 Python 예제¶

다음 예제는 전통 자료구조를 완전히 구현하려는 코드가 아닙니다. 각 자료구조가 어떤 동작 감각을 갖는지 확인하기 위한 작은 예제입니다. Colab 코드 셀이나 로컬 Python 파일에서 그대로 실행해 볼 수 있습니다.

배열(array) 감각: 위치로 접근하기¶

Python 리스트는 전통적인 배열과 완전히 같지는 않지만, 위치(index)로 접근하는 감각을 확인하기에는 적합합니다.

문제 상황: 배열 감각에서 값을 읽고 바꾸는 기본 동작을 직접 확인하고 싶습니다. 입력(input): 숫자 네 개가 든 리스트와 두 개의 인덱스 접근, 한 번의 값 수정입니다. 기대 출력(output): 첫 번째 값, 세 번째 값, 수정 뒤 전체 리스트가 순서대로 출력됩니다. 확인할 개념: 배열처럼 보이는 구조에서는 위치로 읽고 위치로 값을 바꾼다는 점을 확인합니다.

# 이 예제는 전통적인 자료구조가 저장 방식과 접근 방식을 어떻게 다르게 만드는지 확인합니다.
values = [10, 20, 30, 40]

print(values[0])
print(values[2])

values[1] = 25
print(values)

이 예제에서 중요한 것은 값마다 위치가 있고, 그 위치로 값을 꺼내거나 바꿀 수 있다는 점입니다.

연결 리스트(linked list) 감각: 다음 항목을 따라가기¶

연결 리스트는 항목이 다음 항목을 가리킨다는 발상을 보여 줍니다. 여기서는 클래스를 만들지 않고 딕셔너리로 노드(node) 감각만 확인합니다.

문제 상황: 연속된 칸이 아니라 다음 항목을 따라가며 값을 읽는 흐름을 보고 싶습니다. 입력(input): value와 next를 가진 세 개의 노드 딕셔너리입니다. 기대 출력(output): Kim, Lee, Park가 차례대로 출력됩니다. 확인할 개념: 연결 리스트 감각은 위치 번호보다 다음 노드를 가리키는 링크에 있다는 점을 봅니다.

# 이 예제는 전통적인 자료구조가 저장 방식과 접근 방식을 어떻게 다르게 만드는지 확인합니다.
third = {"value": "Park", "next": None}
second = {"value": "Lee", "next": third}
first = {"value": "Kim", "next": second}

node = first
while node is not None:
    print(node["value"])
    node = node["next"]

이 예제는 Kim -> Lee -> Park -> None 흐름을 실제로 따라갑니다. 핵심은 값들이 연속된 칸에 있는지보다, 다음 항목으로 이동할 수 있는 연결이 있다는 점입니다.

스택(stack) 감각: 마지막에 넣은 것을 먼저 꺼내기¶

Python 리스트의 append()와 pop()으로 스택 감각을 확인할 수 있습니다.

문제 상황: 마지막에 넣은 값이 먼저 나오는 스택 규칙을 직접 보고 싶습니다. 입력(input): 빈 리스트에 "A", "B", "C"를 차례대로 넣은 뒤 두 번 꺼내는 코드입니다. 기대 출력(output): "C", "B", 그리고 남은 리스트가 출력됩니다. 확인할 개념: 스택의 핵심 규칙이 LIFO(last in, first out)라는 점을 확인합니다.

# 이 예제는 전통적인 자료구조가 저장 방식과 접근 방식을 어떻게 다르게 만드는지 확인합니다.
stack = []

stack.append("A")
stack.append("B")
stack.append("C")

print(stack.pop())
print(stack.pop())
print(stack)

마지막에 넣은 "C"가 먼저 나옵니다. 이것이 LIFO(last in, first out) 감각입니다.

큐(queue) 감각: 먼저 들어온 것을 먼저 처리하기¶

큐는 앞에서 꺼내고 뒤에 넣는 흐름을 갖습니다. Python에서는 collections.deque를 사용하면 이 감각을 간단히 확인할 수 있습니다.

문제 상황: 먼저 들어온 값이 먼저 나오는 큐 규칙을 직접 보고 싶습니다. 입력(input): deque에 "A", "B", "C"를 넣고 앞에서 두 번 꺼내는 코드입니다. 기대 출력(output): "A", "B", 그리고 남은 큐가 출력됩니다. 확인할 개념: 큐의 핵심 규칙이 FIFO(first in, first out)라는 점을 확인합니다.

# 이 예제는 전통적인 자료구조가 저장 방식과 접근 방식을 어떻게 다르게 만드는지 확인합니다.
from collections import deque

queue = deque()

queue.append("A")
queue.append("B")
queue.append("C")

print(queue.popleft())
print(queue.popleft())
print(queue)

먼저 들어온 "A"가 먼저 나옵니다. 이것이 FIFO(first in, first out) 감각입니다.

트리(tree) 감각: 부모와 자식으로 내려가기¶

트리는 부모와 자식 관계를 표현합니다. 다음 예제는 책 목차를 작은 트리처럼 표현합니다.

문제 상황: 책 목차처럼 위에서 아래로 내려가는 계층 구조를 작은 데이터로 보고 싶습니다. 입력(input): title과 children으로 구성한 중첩 딕셔너리입니다. 기대 출력(output): 책 제목, 각 Part 제목, 그 아래 Chapter 이름이 계층적으로 출력됩니다. 확인할 개념: 트리는 부모 아래에 자식이 달린 계층 구조라는 점을 확인합니다.

# 이 예제는 전통적인 자료구조가 저장 방식과 접근 방식을 어떻게 다르게 만드는지 확인합니다.
book = {
    "title": "study-book",
    "children": [
        {
            "title": "Part 1",
            "children": ["Chapter 1", "Chapter 2"],
        },
        {
            "title": "Part 2",
            "children": ["Chapter 8", "Chapter 9"],
        },
    ],
}

print(book["title"])
for part in book["children"]:
    print("-", part["title"])
    for chapter in part["children"]:
        print("  -", chapter)

트리 예제에서는 위에서 아래로 내려가며 범위가 좁아집니다. 책, 파트, 챕터처럼 계층이 뚜렷한 데이터를 읽을 때 이 감각이 필요합니다.

그래프(graph) 감각: 연결된 대상을 따라가기¶

그래프는 대상 사이의 연결을 표현합니다. 다음 예제는 사람 사이의 관계를 인접 리스트(adjacency list)처럼 표현합니다.

문제 상황: 특정 사람과 직접 연결된 이웃을 그래프 구조에서 꺼내 보고 싶습니다. 입력(input): 사람별 친구 목록을 담은 인접 리스트 딕셔너리입니다. 기대 출력(output): Kim의 이웃 목록과 각 연결 문장이 출력됩니다. 확인할 개념: 그래프에서는 순서보다 연결된 대상 목록을 읽는 것이 중요하다는 점을 봅니다.

# 이 예제는 전통적인 자료구조가 저장 방식과 접근 방식을 어떻게 다르게 만드는지 확인합니다.
graph = {
    "Kim": ["Lee", "Park"],
    "Lee": ["Kim", "Choi"],
    "Park": ["Kim"],
    "Choi": ["Lee"],
}

print(graph["Kim"])

for friend in graph["Kim"]:
    print("Kim is connected to", friend)

그래프에서는 “몇 번째인가”보다 “누구와 연결되어 있는가”가 중요합니다. 추천, 검색, 링크 분석을 볼 때 이 감각이 다시 등장합니다.

해시 테이블(hash table) 감각: 키로 값 찾기¶

Python 딕셔너리는 사용 관점에서 키로 값을 찾는 구조입니다. 내부 구현까지 설명하지 않더라도 해시 테이블 감각을 확인하기 좋습니다.

문제 상황: 순서대로 훑지 않고 이름표 같은 키로 값을 읽고 새 값을 추가해 보고 싶습니다. 입력(input): 이름을 키로, 점수를 값으로 담은 딕셔너리와 새 항목 추가입니다. 기대 출력(output): Kim의 점수와 새 항목이 추가된 딕셔너리가 출력됩니다. 확인할 개념: 키 기반 구조는 몇 번째 위치보다 어떤 이름으로 찾는지가 중요하다는 점을 확인합니다.

# 이 예제는 전통적인 자료구조가 저장 방식과 접근 방식을 어떻게 다르게 만드는지 확인합니다.
score_by_name = {
    "Kim": 82,
    "Lee": 75,
    "Park": 91,
}

print(score_by_name["Kim"])

score_by_name["Choi"] = 88
print(score_by_name)

이 예제에서 중요한 것은 순서대로 훑어서 찾는 것이 아니라, "Kim" 같은 키로 값을 찾는다는 점입니다.

AI 실습에서 다시 만나는 자료구조¶

AI 실습에서는 자료구조 이름이 직접 나오지 않아도 비슷한 발상을 계속 만납니다.

AI 실습 장면	자료구조 감각
문장 여러 개를 입력으로 넣는다	리스트, 시퀀스
토큰을 순서대로 처리한다	배열, 시퀀스
라벨 번호를 라벨 이름으로 바꾼다	딕셔너리, 매핑
중복 단어를 제거한다	집합
표 형식 데이터를 다룬다	테이블, DataFrame
문서와 문서의 링크를 따라간다	그래프
임베딩을 모아 검색한다	배열, 인덱스, 검색 구조
작업 요청을 순서대로 처리한다	큐

이 보충학습은 모든 구조를 구현하게 만드는 대신, 앞으로 AI 실습 문서를 읽을 때 순서가 중요한 구조, 키로 찾는 구조, 관계를 따라가는 구조를 구분할 수 있게 만드는 데 초점을 둡니다.

오해하기 쉬운 지점¶

첫째, Python 리스트는 전통적인 배열과 완전히 같은 말이 아닙니다.

둘 다 위치로 값을 꺼낼 수 있지만, Python 리스트는 동적으로 크기가 바뀌고 서로 다른 종류의 객체도 담을 수 있습니다. NumPy 배열은 숫자 계산에 맞게 더 엄격한 구조를 갖습니다. 따라서 “리스트는 배열이다”라고 단정하기보다 “리스트는 배열처럼 위치 접근 감각을 제공한다”고 이해하는 편이 안전합니다.

둘째, 딕셔너리는 해시 테이블과 연결되지만 해시 테이블 설명 자체는 아닙니다.

Python 딕셔너리는 키로 값을 찾게 해 주는 매핑 객체입니다. 내부 구현은 해시 테이블 감각과 연결되지만, 사용 설명과 구현 설명을 구분해야 합니다.

셋째, 트리와 그래프는 완전히 별개의 세계가 아닙니다.

트리는 계층이 뚜렷한 관계 구조이고, 그래프는 더 일반적인 연결 구조입니다. 여기서는 트리를 “부모-자식 관계가 강한 구조”, 그래프를 “여러 대상의 연결을 표현하는 구조”로 구분합니다.

넷째, 자료구조는 성능만을 위한 것이 아닙니다.

자료구조는 코드의 의미도 드러냅니다. 리스트를 쓰면 “순서대로 처리한다”는 의도가 보이고, 딕셔너리를 쓰면 “키로 찾는다”는 의도가 보입니다. 그래프 구조를 쓰면 “관계를 따라간다”는 의도가 보입니다.

체크리스트¶

배열, 스택, 큐, 트리, 그래프, 해시 테이블을 대표 질문으로 설명할 수 있는가?
왜 Python 문법을 본 뒤에도 전통 자료구조 이름을 다시 읽어야 하는지 말할 수 있는가?
순서, 키, 관계 중 무엇이 중요한지에 따라 구조를 고르는 감각을 설명할 수 있는가?
배열(array)을 위치(index)로 값을 다루는 구조로 설명할 수 있다.
연결 리스트(linked list)를 항목이 다음 항목을 가리키는 구조로 설명할 수 있다.
스택(stack)을 LIFO, 큐(queue)를 FIFO 규칙으로 설명할 수 있다.
트리(tree)를 계층 구조, 그래프(graph)를 관계 구조로 구분할 수 있다.
딕셔너리(dictionary)와 해시 테이블(hash table)이 키 기반 검색과 연결됨을 설명할 수 있다.
Python의 편리한 문법 뒤에도 전통 자료구조 감각이 숨어 있음을 설명할 수 있다.
배열, 연결 리스트, 스택, 큐, 트리, 그래프, 딕셔너리 예제를 Python으로 실행해 보고 출력 흐름을 설명할 수 있다.
이건 순서 문제인가, 키 조회 문제인가, 관계 추적 문제인가를 먼저 구분할 수 있는가?

출처와 참고 자료¶

NIST, Data structure, Dictionary of Algorithms and Data Structures, 확인 날짜: 2026-07-20. 전통 자료구조 이름을 데이터 조직 방식으로 읽는 기본 정의 확인에 사용했다.
NIST, Abstract data type, Dictionary of Algorithms and Data Structures, 확인 날짜: 2026-07-20. 스택·큐 같은 구조를 구현보다 제공 동작 중심으로 설명하는 근거로 사용했다.
Python Software Foundation, Data Structures, Python 3.14.6 documentation, 확인 날짜: 2026-07-20. Python 리스트와 딕셔너리 문법이 전통 자료구조 감각과 어떻게 연결되는지 확인하는 근거로 사용했다.