그림 16-3 페이지 편집 버튼
+ +그림은 직접 수정할 수 없으므로 [Issue](https://github.com/krahets/hello-algo/issues)를 만들거나 댓글로 문제를 설명해 주기 바란다. 확인 후 최대한 빨리 그림을 다시 제작하여 교체하겠다. + +### 2. 내용 작성 + +코드를 다른 프로그래밍 언어로 옮기거나 글의 내용을 확장하는 등 이 오픈 소스 프로젝트에 참여하고 싶다면 다음 풀 리퀘스트 절차를 따르면 된다. + +1. GitHub에 로그인한 뒤 이 책의 [코드 저장소](https://github.com/krahets/hello-algo)를 개인 계정으로 포크한다. +2. 포크한 저장소의 웹페이지로 이동하여 `git clone` 명령으로 저장소를 로컬에 복제한다. +3. 로컬에서 내용을 작성하고 충분히 테스트하여 코드가 올바른지 검증한다. +4. 로컬 변경 사항을 커밋한 뒤 원격 저장소로 푸시한다. +5. 저장소 웹페이지를 새로 고침하고 ‘Create pull request’ 버튼을 눌러 풀 리퀘스트를 만든다. + +### 3. Docker 배포 + +`hello-algo` 루트 디렉터리에서 다음 Docker 명령을 실행하면 `http://localhost:8000/ko/`에서 한국어판을 열 수 있다. + +```shell +docker-compose up -d +``` + +다음 명령으로 배포를 제거할 수 있다. + +```shell +docker-compose down +``` diff --git a/ko/docs/chapter_appendix/index.md b/ko/docs/chapter_appendix/index.md new file mode 100644 index 000000000..a47b4d49c --- /dev/null +++ b/ko/docs/chapter_appendix/index.md @@ -0,0 +1,14 @@ +--- +comments: true +icon: material/help-circle-outline +--- + +# 제 16 장 부록 + +{ class="cover-image" } + +## 이 장의 내용 + +- [16.1 프로그래밍 환경 설치](installation.md) +- [16.2 함께 만드는 책](contribution.md) +- [16.3 용어집](terminology.md) diff --git a/ko/docs/chapter_appendix/installation.md b/ko/docs/chapter_appendix/installation.md new file mode 100644 index 000000000..fb3d0b849 --- /dev/null +++ b/ko/docs/chapter_appendix/installation.md @@ -0,0 +1,76 @@ +--- +comments: true +--- + +# 16.1 프로그래밍 환경 설치 + +## 16.1.1 IDE 설치 + +로컬 통합 개발 환경(IDE)으로는 가벼운 오픈 소스 도구인 VS Code를 권장한다. [VS Code 공식 웹사이트](https://code.visualstudio.com/)에서 운영체제에 맞는 버전을 내려받아 설치한다. + +{ class="animation-figure" } + +그림 16-1 공식 웹사이트에서 VS Code 내려받기
+ +VS Code는 풍부한 확장 생태계를 갖추고 있어 대부분의 프로그래밍 언어를 실행하고 디버깅할 수 있다. Python을 예로 들면, ‘Python Extension Pack’을 설치한 뒤 Python 코드를 디버깅할 수 있다. 설치 과정은 아래 그림(16-2)과 같다. + +{ class="animation-figure" } + +그림 16-2 VS Code 확장 설치
+ +## 16.1.2 언어 실행 환경 설치 + +### 1. Python 환경 + +1. [Miniconda3](https://docs.conda.io/en/latest/miniconda.html)를 내려받아 설치한다. Python 3.10 이상이 필요하다. +2. VS Code 확장 마켓플레이스에서 `python`을 검색하여 Python Extension Pack을 설치한다. +3. (선택 사항) 명령줄에 `pip install black`을 입력하여 코드 포매터를 설치한다. + +### 2. C/C++ 환경 + +1. Windows에서는 [MinGW](https://sourceforge.net/projects/mingw-w64/files/)를 설치해야 한다([설정 안내](https://blog.csdn.net/qq_33698226/article/details/129031241)). macOS에는 Clang이 기본으로 포함되어 있어 별도로 설치할 필요가 없다. +2. VS Code 확장 마켓플레이스에서 `c++`를 검색하여 C/C++ Extension Pack을 설치한다. +3. (선택 사항) Settings 페이지에서 코드 서식 옵션인 `Clang_format_fallback Style`을 검색하고 `{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }`로 설정한다. + +### 3. Java 환경 + +1. [OpenJDK](https://jdk.java.net/18/)를 내려받아 설치한다(JDK 9보다 높은 버전이어야 한다). +2. VS Code 확장 마켓플레이스에서 `java`를 검색하여 Extension Pack for Java를 설치한다. + +### 4. C# 환경 + +1. [.NET 8.0](https://dotnet.microsoft.com/ko-kr/download)을 내려받아 설치한다. +2. VS Code 확장 마켓플레이스에서 `C# Dev Kit`을 검색하여 C# Dev Kit을 설치한다([설정 안내](https://code.visualstudio.com/docs/csharp/get-started)). +3. Visual Studio를 사용해도 된다([설치 안내](https://learn.microsoft.com/ko-kr/visualstudio/install/install-visual-studio?view=vs-2022)). + +### 5. Go 환경 + +1. [go](https://go.dev/dl/)를 내려받아 설치한다. +2. VS Code 확장 마켓플레이스에서 `go`를 검색하여 Go를 설치한다. +3. `Ctrl + Shift + P`를 눌러 명령 팔레트를 열고 go를 입력한다. `Go: Install/Update Tools`를 선택한 뒤 모든 항목을 체크하여 설치한다. + +### 6. Swift 환경 + +1. [Swift](https://www.swift.org/download/)를 내려받아 설치한다. +2. VS Code 확장 마켓플레이스에서 `swift`를 검색하여 [Swift for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang)를 설치한다. + +### 7. JavaScript 환경 + +1. [Node.js](https://nodejs.org/ko/)를 내려받아 설치한다. +2. (선택 사항) VS Code 확장 마켓플레이스에서 `Prettier`를 검색하여 코드 포매터를 설치한다. + +### 8. TypeScript 환경 + +1. JavaScript 환경과 같은 순서로 설치한다. +2. [TypeScript Execute (tsx)](https://github.com/privatenumber/tsx?tab=readme-ov-file#global-installation)를 설치한다. +3. VS Code 확장 마켓플레이스에서 `typescript`를 검색하여 [Pretty TypeScript Errors](https://marketplace.visualstudio.com/items?itemName=yoavbls.pretty-ts-errors)를 설치한다. + +### 9. Dart 환경 + +1. [Dart](https://dart.dev/get-dart)를 내려받아 설치한다. +2. VS Code 확장 마켓플레이스에서 `dart`를 검색하여 [Dart](https://marketplace.visualstudio.com/items?itemName=Dart-Code.dart-code)를 설치한다. + +### 10. Rust 환경 + +1. [Rust](https://www.rust-lang.org/tools/install)를 내려받아 설치한다. +2. VS Code 확장 마켓플레이스에서 `rust`를 검색하여 [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer)를 설치한다. diff --git a/ko/docs/chapter_appendix/terminology.md b/ko/docs/chapter_appendix/terminology.md new file mode 100644 index 000000000..04c1ddc6f --- /dev/null +++ b/ko/docs/chapter_appendix/terminology.md @@ -0,0 +1,144 @@ +--- +comments: true +--- + +# 16.3 용어집 + +아래 표(16-1)에는 이 책에 나오는 주요 용어를 정리했다. 영어 문헌을 읽을 때 도움이 되므로 각 용어의 영어 명칭을 기억해 두기를 권장한다. + +표 16-1 자료 구조와 알고리즘의 주요 용어
+ +그림 4-1 배열의 정의와 저장 방식
+ +## 4.1.1 배열의 기본 연산 + +### 1. 배열 초기화 + +필요에 따라 초깃값을 지정하지 않거나 지정하는 두 가지 초기화 방식을 사용할 수 있다. 초깃값을 지정하지 않으면 대부분의 프로그래밍 언어는 배열 원소를 $0$으로 초기화한다. + +=== "Python" + + ```python title="array.py" + # 배열 초기화 + arr: list[int] = [0] * 5 # [ 0, 0, 0, 0, 0 ] + nums: list[int] = [1, 3, 2, 5, 4] + ``` + +=== "C++" + + ```cpp title="array.cpp" + /* 배열 초기화 */ + // 스택에 저장 + int arr[5] = {}; + int nums[5] = { 1, 3, 2, 5, 4 }; + // 힙에 저장(공간을 직접 해제해야 함) + int* arr1 = new int[5] {}; + int* nums1 = new int[5] { 1, 3, 2, 5, 4 }; + ``` + +=== "Java" + + ```java title="array.java" + /* 배열 초기화 */ + int[] arr = new int[5]; // { 0, 0, 0, 0, 0 } + int[] nums = { 1, 3, 2, 5, 4 }; + ``` + +=== "C#" + + ```csharp title="array.cs" + /* 배열 초기화 */ + int[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ] + int[] nums = [1, 3, 2, 5, 4]; + ``` + +=== "Go" + + ```go title="array.go" + /* 배열 초기화 */ + var arr [5]int + // Go에서 길이를 지정하면([5]int) 배열이고, 지정하지 않으면([]int) 슬라이스다 + // Go 배열의 길이는 컴파일 시 결정되도록 설계되었으므로 상수로만 길이를 지정할 수 있다 + // 용량 확장 메서드 extend()를 쉽게 구현하기 위해 아래에서는 슬라이스(Slice)를 배열(Array)로 간주한다 + nums := []int{1, 3, 2, 5, 4} + ``` + +=== "Swift" + + ```swift title="array.swift" + /* 배열 초기화 */ + let arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0] + let nums = [1, 3, 2, 5, 4] + ``` + +=== "JS" + + ```javascript title="array.js" + /* 배열 초기화 */ + var arr = new Array(5).fill(0); + var nums = [1, 3, 2, 5, 4]; + ``` + +=== "TS" + + ```typescript title="array.ts" + /* 배열 초기화 */ + let arr: number[] = new Array(5).fill(0); + let nums: number[] = [1, 3, 2, 5, 4]; + ``` + +=== "Dart" + + ```dart title="array.dart" + /* 배열 초기화 */ + List그림 4-2 배열 원소의 메모리 주소 계산
+ +위 그림(4-2)에서 배열의 첫 원소 인덱스는 $0$이다. $1$부터 세는 편이 더 자연스러워 보이므로 직관에 어긋날 수 있다. 그러나 주소 계산식의 관점에서 **인덱스는 본질적으로 메모리 주소의 오프셋이다**. 첫 원소의 주소 오프셋은 $0$이므로 인덱스가 $0$인 것은 합리적이다. + +배열의 원소 접근은 매우 효율적이며, 어떤 원소든 $O(1)$ 시간에 임의 접근할 수 있다. + +=== "Python" + + ```python title="array.py" + def random_access(nums: list[int]) -> int: + """원소에 임의 접근""" + # 구간 [0, len(nums)-1]에서 숫자 하나를 무작위로 뽑는다 + random_index = random.randint(0, len(nums) - 1) + # 무작위 원소를 가져와 반환한다 + random_num = nums[random_index] + return random_num + ``` + +=== "C++" + + ```cpp title="array.cpp" + /* 원소에 임의 접근 */ + int randomAccess(int *nums, int size) { + // 구간 [0, size)에서 무작위로 수 하나 선택 + int randomIndex = rand() % size; + // 무작위 원소를 가져와 반환한다 + int randomNum = nums[randomIndex]; + return randomNum; + } + ``` + +=== "Java" + + ```java title="array.java" + /* 원소에 임의 접근 */ + int randomAccess(int[] nums) { + // 구간 [0, nums.length)에서 숫자 하나를 무작위로 뽑는다 + int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length); + // 무작위 원소를 가져와 반환한다 + int randomNum = nums[randomIndex]; + return randomNum; + } + ``` + +=== "C#" + + ```csharp title="array.cs" + /* 원소에 임의 접근 */ + int RandomAccess(int[] nums) { + Random random = new(); + // 구간 [0, nums.Length)에서 무작위로 수 하나 선택 + int randomIndex = random.Next(nums.Length); + // 무작위 원소를 가져와 반환한다 + int randomNum = nums[randomIndex]; + return randomNum; + } + ``` + +=== "Go" + + ```go title="array.go" + /* 원소에 임의 접근 */ + func randomAccess(nums []int) (randomNum int) { + // 구간 [0, nums.length)에서 숫자 하나를 무작위로 뽑는다 + randomIndex := rand.Intn(len(nums)) + // 무작위 원소를 가져와 반환한다 + randomNum = nums[randomIndex] + return + } + ``` + +=== "Swift" + + ```swift title="array.swift" + /* 원소에 임의 접근 */ + func randomAccess(nums: [Int]) -> Int { + // 구간 [0, nums.count)에서 숫자 하나를 무작위로 뽑는다 + let randomIndex = nums.indices.randomElement()! + // 무작위 원소를 가져와 반환한다 + let randomNum = nums[randomIndex] + return randomNum + } + ``` + +=== "JS" + + ```javascript title="array.js" + /* 원소에 임의 접근 */ + function randomAccess(nums) { + // 구간 [0, nums.length)에서 숫자 하나를 무작위로 뽑는다 + const random_index = Math.floor(Math.random() * nums.length); + // 무작위 원소를 가져와 반환한다 + const random_num = nums[random_index]; + return random_num; + } + ``` + +=== "TS" + + ```typescript title="array.ts" + /* 원소에 임의 접근 */ + function randomAccess(nums: number[]): number { + // 구간 [0, nums.length)에서 숫자 하나를 무작위로 뽑는다 + const random_index = Math.floor(Math.random() * nums.length); + // 무작위 원소를 가져와 반환한다 + const random_num = nums[random_index]; + return random_num; + } + ``` + +=== "Dart" + + ```dart title="array.dart" + /* 원소에 임의 접근 */ + int randomAccess(List그림 4-3 배열에 원소를 삽입하는 예
+ +배열의 길이는 고정되어 있으므로 원소를 하나 삽입하면 반드시 마지막 원소가 ‘사라진다’는 점에 주의하자. 이 문제의 해결책은 ‘리스트’ 절에서 다룬다. + +=== "Python" + + ```python title="array.py" + def insert(nums: list[int], num: int, index: int): + """배열의 인덱스 index에 원소 num 삽입""" + # 인덱스 index와 그 뒤에 있는 모든 원소를 한 칸씩 뒤로 이동한다 + for i in range(len(nums) - 1, index, -1): + nums[i] = nums[i - 1] + # index 위치의 원소에 num을 대입한다 + nums[index] = num + ``` + +=== "C++" + + ```cpp title="array.cpp" + /* 배열의 인덱스 index에 원소 num 삽입 */ + void insert(int *nums, int size, int num, int index) { + // 인덱스 index와 그 뒤에 있는 모든 원소를 한 칸씩 뒤로 이동한다 + for (int i = size - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // index 위치의 원소에 num을 대입한다 + nums[index] = num; + } + ``` + +=== "Java" + + ```java title="array.java" + /* 배열의 인덱스 index에 원소 num 삽입 */ + void insert(int[] nums, int num, int index) { + // 인덱스 index와 그 뒤에 있는 모든 원소를 한 칸씩 뒤로 이동한다 + for (int i = nums.length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // index 위치의 원소에 num을 대입한다 + nums[index] = num; + } + ``` + +=== "C#" + + ```csharp title="array.cs" + /* 배열의 인덱스 index에 원소 num 삽입 */ + void Insert(int[] nums, int num, int index) { + // 인덱스 index와 그 뒤에 있는 모든 원소를 한 칸씩 뒤로 이동한다 + for (int i = nums.Length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // index 위치의 원소에 num을 대입한다 + nums[index] = num; + } + ``` + +=== "Go" + + ```go title="array.go" + /* 배열의 인덱스 index에 원소 num 삽입 */ + func insert(nums []int, num int, index int) { + // 인덱스 index와 그 뒤에 있는 모든 원소를 한 칸씩 뒤로 이동한다 + for i := len(nums) - 1; i > index; i-- { + nums[i] = nums[i-1] + } + // index 위치의 원소에 num을 대입한다 + nums[index] = num + } + ``` + +=== "Swift" + + ```swift title="array.swift" + /* 배열의 인덱스 index에 원소 num 삽입 */ + func insert(nums: inout [Int], num: Int, index: Int) { + // 인덱스 index와 그 뒤에 있는 모든 원소를 한 칸씩 뒤로 이동한다 + for i in stride(from: nums.count - 1, to: index, by: -1) { + nums[i] = nums[i - 1] + } + // index 위치의 원소에 num을 대입한다 + nums[index] = num + } + ``` + +=== "JS" + + ```javascript title="array.js" + /* 배열의 인덱스 index에 원소 num 삽입 */ + function insert(nums, num, index) { + // 인덱스 index와 그 뒤에 있는 모든 원소를 한 칸씩 뒤로 이동한다 + for (let i = nums.length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // index 위치의 원소에 num을 대입한다 + nums[index] = num; + } + ``` + +=== "TS" + + ```typescript title="array.ts" + /* 배열의 인덱스 index에 원소 num 삽입 */ + function insert(nums: number[], num: number, index: number): void { + // 인덱스 index와 그 뒤에 있는 모든 원소를 한 칸씩 뒤로 이동한다 + for (let i = nums.length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // index 위치의 원소에 num을 대입한다 + nums[index] = num; + } + ``` + +=== "Dart" + + ```dart title="array.dart" + /* 배열의 인덱스 index에 원소 _num 삽입 */ + void insert(List그림 4-4 배열에서 원소를 삭제하는 예
+ +삭제가 끝난 뒤 원래의 마지막 원소는 ‘의미 없는’ 값이 되므로 따로 수정할 필요가 없다. + +=== "Python" + + ```python title="array.py" + def remove(nums: list[int], index: int): + """인덱스 index에 있는 원소 삭제""" + # 인덱스 index 뒤에 있는 모든 원소를 한 칸씩 앞으로 이동한다 + for i in range(index, len(nums) - 1): + nums[i] = nums[i + 1] + ``` + +=== "C++" + + ```cpp title="array.cpp" + /* 인덱스 index에 있는 원소 삭제 */ + void remove(int *nums, int size, int index) { + // 인덱스 index 뒤에 있는 모든 원소를 한 칸씩 앞으로 이동한다 + for (int i = index; i < size - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "Java" + + ```java title="array.java" + /* 인덱스 index에 있는 원소 삭제 */ + void remove(int[] nums, int index) { + // 인덱스 index 뒤에 있는 모든 원소를 한 칸씩 앞으로 이동한다 + for (int i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "C#" + + ```csharp title="array.cs" + /* 인덱스 index에 있는 원소 삭제 */ + void Remove(int[] nums, int index) { + // 인덱스 index 뒤에 있는 모든 원소를 한 칸씩 앞으로 이동한다 + for (int i = index; i < nums.Length - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "Go" + + ```go title="array.go" + /* 인덱스 index에 있는 원소 삭제 */ + func remove(nums []int, index int) { + // 인덱스 index 뒤에 있는 모든 원소를 한 칸씩 앞으로 이동한다 + for i := index; i < len(nums)-1; i++ { + nums[i] = nums[i+1] + } + } + ``` + +=== "Swift" + + ```swift title="array.swift" + /* 인덱스 index에 있는 원소 삭제 */ + func remove(nums: inout [Int], index: Int) { + // 인덱스 index 뒤에 있는 모든 원소를 한 칸씩 앞으로 이동한다 + for i in nums.indices.dropFirst(index).dropLast() { + nums[i] = nums[i + 1] + } + } + ``` + +=== "JS" + + ```javascript title="array.js" + /* 인덱스 index에 있는 원소 삭제 */ + function remove(nums, index) { + // 인덱스 index 뒤에 있는 모든 원소를 한 칸씩 앞으로 이동한다 + for (let i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "TS" + + ```typescript title="array.ts" + /* 인덱스 index에 있는 원소 삭제 */ + function remove(nums: number[], index: number): void { + // 인덱스 index 뒤에 있는 모든 원소를 한 칸씩 앞으로 이동한다 + for (let i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "Dart" + + ```dart title="array.dart" + /* 인덱스 index에 있는 원소 삭제 */ + void remove(List그림 4-5 연결 리스트의 정의와 저장 방식
+ +위 그림(4-5)에서 연결 리스트를 구성하는 단위는 노드(node) 객체다. 각 노드는 노드의 ‘값’과 다음 노드를 가리키는 ‘참조’라는 두 데이터를 포함한다. + +- 연결 리스트의 첫 노드를 ‘머리 노드’, 마지막 노드를 ‘꼬리 노드’라고 한다. +- 꼬리 노드는 ‘없음’을 가리키며, Java, C++, Python에서는 이를 각각 `null`, `nullptr`, `None`으로 표기한다. +- C, C++, Go, Rust처럼 포인터를 지원하는 언어에서는 위의 ‘참조’를 ‘포인터’로 바꾸어 이해하면 된다. + +다음 코드와 같이 연결 리스트 노드 `ListNode`는 값 외에도 참조(포인터)를 하나 더 저장해야 한다. 따라서 같은 양의 데이터를 저장할 때 **연결 리스트는 배열보다 메모리 공간을 더 많이 차지한다**. + +=== "Python" + + ```python title="" + class ListNode: + """연결 리스트 노드 클래스""" + def __init__(self, val: int): + self.val: int = val # 노드 값 + self.next: ListNode | None = None # 다음 노드를 가리키는 참조 + ``` + +=== "C++" + + ```cpp title="" + /* 연결 리스트 노드 구조체 */ + struct ListNode { + int val; // 노드 값 + ListNode *next; // 다음 노드를 가리키는 포인터 + ListNode(int x) : val(x), next(nullptr) {} // 생성자 + }; + ``` + +=== "Java" + + ```java title="" + /* 연결 리스트 노드 클래스 */ + class ListNode { + int val; // 노드 값 + ListNode next; // 다음 노드를 가리키는 참조 + ListNode(int x) { val = x; } // 생성자 + } + ``` + +=== "C#" + + ```csharp title="" + /* 연결 리스트 노드 클래스 */ + class ListNode(int x) { //생성자 + int val = x; // 노드 값 + ListNode? next; // 다음 노드를 가리키는 참조 + } + ``` + +=== "Go" + + ```go title="" + /* 연결 리스트 노드 구조체 */ + type ListNode struct { + Val int // 노드 값 + Next *ListNode // 다음 노드를 가리키는 포인터 + } + + // NewListNode 생성자: 새 연결 리스트 생성 + func NewListNode(val int) *ListNode { + return &ListNode{ + Val: val, + Next: nil, + } + } + ``` + +=== "Swift" + + ```swift title="" + /* 연결 리스트 노드 클래스 */ + class ListNode { + var val: Int // 노드 값 + var next: ListNode? // 다음 노드를 가리키는 참조 + + init(x: Int) { // 생성자 + val = x + } + } + ``` + +=== "JS" + + ```javascript title="" + /* 연결 리스트 노드 클래스 */ + class ListNode { + constructor(val, next) { + this.val = (val === undefined ? 0 : val); // 노드 값 + this.next = (next === undefined ? null : next); // 다음 노드를 가리키는 참조 + } + } + ``` + +=== "TS" + + ```typescript title="" + /* 연결 리스트 노드 클래스 */ + class ListNode { + val: number; + next: ListNode | null; + constructor(val?: number, next?: ListNode | null) { + this.val = val === undefined ? 0 : val; // 노드 값 + this.next = next === undefined ? null : next; // 다음 노드를 가리키는 참조 + } + } + ``` + +=== "Dart" + + ```dart title="" + /* 연결 리스트 노드 클래스 */ + class ListNode { + int val; // 노드 값 + ListNode? next; // 다음 노드를 가리키는 참조 + ListNode(this.val, [this.next]); // 생성자 + } + ``` + +=== "Rust" + + ```rust title="" + use std::rc::Rc; + use std::cell::RefCell; + /* 연결 리스트 노드 클래스 */ + #[derive(Debug)] + struct ListNode { + val: i32, // 노드 값 + next: Option그림 4-6 연결 리스트에 노드를 삽입하는 예
+ +=== "Python" + + ```python title="linked_list.py" + def insert(n0: ListNode, P: ListNode): + """연결 리스트의 노드 n0 뒤에 노드 P 삽입""" + n1 = n0.next + P.next = n1 + n0.next = P + ``` + +=== "C++" + + ```cpp title="linked_list.cpp" + /* 연결 리스트의 노드 n0 뒤에 노드 P 삽입 */ + void insert(ListNode *n0, ListNode *P) { + ListNode *n1 = n0->next; + P->next = n1; + n0->next = P; + } + ``` + +=== "Java" + + ```java title="linked_list.java" + /* 연결 리스트의 노드 n0 뒤에 노드 P 삽입 */ + void insert(ListNode n0, ListNode P) { + ListNode n1 = n0.next; + P.next = n1; + n0.next = P; + } + ``` + +=== "C#" + + ```csharp title="linked_list.cs" + /* 연결 리스트의 노드 n0 뒤에 노드 P 삽입 */ + void Insert(ListNode n0, ListNode P) { + ListNode? n1 = n0.next; + P.next = n1; + n0.next = P; + } + ``` + +=== "Go" + + ```go title="linked_list.go" + /* 연결 리스트의 노드 n0 뒤에 노드 P 삽입 */ + func insertNode(n0 *ListNode, P *ListNode) { + n1 := n0.Next + P.Next = n1 + n0.Next = P + } + ``` + +=== "Swift" + + ```swift title="linked_list.swift" + /* 연결 리스트의 노드 n0 뒤에 노드 P 삽입 */ + func insert(n0: ListNode, P: ListNode) { + let n1 = n0.next + P.next = n1 + n0.next = P + } + ``` + +=== "JS" + + ```javascript title="linked_list.js" + /* 연결 리스트의 노드 n0 뒤에 노드 P 삽입 */ + function insert(n0, P) { + const n1 = n0.next; + P.next = n1; + n0.next = P; + } + ``` + +=== "TS" + + ```typescript title="linked_list.ts" + /* 연결 리스트의 노드 n0 뒤에 노드 P 삽입 */ + function insert(n0: ListNode, P: ListNode): void { + const n1 = n0.next; + P.next = n1; + n0.next = P; + } + ``` + +=== "Dart" + + ```dart title="linked_list.dart" + /* 연결 리스트의 노드 n0 뒤에 노드 P 삽입 */ + void insert(ListNode n0, ListNode P) { + ListNode? n1 = n0.next; + P.next = n1; + n0.next = P; + } + ``` + +=== "Rust" + + ```rust title="linked_list.rs" + /* 연결 리스트의 노드 n0 뒤에 노드 P 삽입 */ + #[allow(non_snake_case)] + pub fn insert그림 4-7 연결 리스트의 노드 삭제
+ +=== "Python" + + ```python title="linked_list.py" + def remove(n0: ListNode): + """연결 리스트의 노드 n0 바로 뒤에 있는 노드 삭제""" + if not n0.next: + return + # n0 -> P -> n1 + P = n0.next + n1 = P.next + n0.next = n1 + ``` + +=== "C++" + + ```cpp title="linked_list.cpp" + /* 연결 리스트의 노드 n0 바로 뒤에 있는 노드 삭제 */ + void remove(ListNode *n0) { + if (n0->next == nullptr) + return; + // n0 -> P -> n1 + ListNode *P = n0->next; + ListNode *n1 = P->next; + n0->next = n1; + // 메모리 해제 + delete P; + } + ``` + +=== "Java" + + ```java title="linked_list.java" + /* 연결 리스트의 노드 n0 바로 뒤에 있는 노드 삭제 */ + void remove(ListNode n0) { + if (n0.next == null) + return; + // n0 -> P -> n1 + ListNode P = n0.next; + ListNode n1 = P.next; + n0.next = n1; + } + ``` + +=== "C#" + + ```csharp title="linked_list.cs" + /* 연결 리스트의 노드 n0 바로 뒤에 있는 노드 삭제 */ + void Remove(ListNode n0) { + if (n0.next == null) + return; + // n0 -> P -> n1 + ListNode P = n0.next; + ListNode? n1 = P.next; + n0.next = n1; + } + ``` + +=== "Go" + + ```go title="linked_list.go" + /* 연결 리스트의 노드 n0 바로 뒤에 있는 노드 삭제 */ + func removeItem(n0 *ListNode) { + if n0.Next == nil { + return + } + // n0 -> P -> n1 + P := n0.Next + n1 := P.Next + n0.Next = n1 + } + ``` + +=== "Swift" + + ```swift title="linked_list.swift" + /* 연결 리스트의 노드 n0 바로 뒤에 있는 노드 삭제 */ + func remove(n0: ListNode) { + if n0.next == nil { + return + } + // n0 -> P -> n1 + let P = n0.next + let n1 = P?.next + n0.next = n1 + } + ``` + +=== "JS" + + ```javascript title="linked_list.js" + /* 연결 리스트의 노드 n0 바로 뒤에 있는 노드 삭제 */ + function remove(n0) { + if (!n0.next) return; + // n0 -> P -> n1 + const P = n0.next; + const n1 = P.next; + n0.next = n1; + } + ``` + +=== "TS" + + ```typescript title="linked_list.ts" + /* 연결 리스트의 노드 n0 바로 뒤에 있는 노드 삭제 */ + function remove(n0: ListNode): void { + if (!n0.next) { + return; + } + // n0 -> P -> n1 + const P = n0.next; + const n1 = P.next; + n0.next = n1; + } + ``` + +=== "Dart" + + ```dart title="linked_list.dart" + /* 연결 리스트의 노드 n0 바로 뒤에 있는 노드 삭제 */ + void remove(ListNode n0) { + if (n0.next == null) return; + // n0 -> P -> n1 + ListNode P = n0.next!; + ListNode? n1 = P.next; + n0.next = n1; + } + ``` + +=== "Rust" + + ```rust title="linked_list.rs" + /* 연결 리스트의 노드 n0 바로 뒤에 있는 노드 삭제 */ + #[allow(non_snake_case)] + pub fn remove표 4-1 배열과 연결 리스트의 효율 비교
+ +그림 4-8 대표적인 연결 리스트 종류
+ +## 4.2.4 연결 리스트의 대표적인 활용 + +단일 연결 리스트는 보통 스택, 큐, 해시 테이블, 그래프 등의 자료 구조를 구현하는 데 사용된다. + +- **스택과 큐**: 삽입과 삭제를 모두 연결 리스트의 같은 끝에서 수행하면 후입선출 특성이 나타나 스택에 해당한다. 한쪽 끝에서 삽입하고 반대쪽 끝에서 삭제하면 선입선출 특성이 나타나 큐에 해당한다. +- **해시 테이블**: 체이닝은 해시 충돌을 해결하는 대표적인 방법 중 하나로, 충돌하는 모든 원소를 하나의 연결 리스트에 넣는다. +- **그래프**: 인접 리스트는 그래프를 표현하는 흔한 방법이다. 각 정점에 연결 리스트 하나를 연결하고, 그 리스트의 각 원소로 해당 정점과 연결된 다른 정점을 나타낸다. + +이중 연결 리스트는 이전 원소와 다음 원소를 빠르게 찾아야 하는 상황에 자주 사용된다. + +- **고급 자료 구조**: 레드-블랙 트리나 B 트리에서는 노드의 부모 노드에 접근해야 한다. 이중 연결 리스트처럼 노드에 부모를 가리키는 참조를 저장하여 구현할 수 있다. +- **브라우저 방문 기록**: 사용자가 웹 브라우저의 앞으로 또는 뒤로 버튼을 누르면 이전이나 다음에 방문했던 페이지를 알아야 한다. 이중 연결 리스트를 사용하면 이러한 연산이 간단해진다. +- **LRU 알고리즘**: 캐시 교체 알고리즘인 LRU에서는 가장 오랫동안 사용하지 않은 데이터를 빠르게 찾고 노드도 빠르게 추가하고 삭제해야 한다. 이때 이중 연결 리스트가 매우 적합하다. + +원형 연결 리스트는 운영체제의 자원 스케줄링처럼 주기적인 연산이 필요한 상황에 자주 사용된다. + +- **라운드 로빈 스케줄링 알고리즘**: 운영체제의 대표적인 CPU 스케줄링 알고리즘으로, 여러 프로세스를 순환한다. 각 프로세스에 타임 슬라이스를 할당하고, 시간이 다 되면 CPU가 다음 프로세스로 전환한다. 이러한 순환은 원형 연결 리스트로 구현할 수 있다. +- **데이터 버퍼**: 일부 데이터 버퍼도 원형 연결 리스트로 구현할 수 있다. 예를 들어 오디오나 동영상 플레이어에서 데이터 스트림을 여러 버퍼 블록으로 나누어 원형 연결 리스트에 넣으면 끊김 없이 재생할 수 있다. diff --git a/ko/docs/chapter_array_and_linkedlist/list.md b/ko/docs/chapter_array_and_linkedlist/list.md new file mode 100644 index 000000000..aaf8589cd --- /dev/null +++ b/ko/docs/chapter_array_and_linkedlist/list.md @@ -0,0 +1,2301 @@ +--- +comments: true +--- + +# 4.3 리스트 + +리스트(list)는 순서가 있는 원소의 모음을 나타내는 추상적인 자료 구조 개념이다. 원소 접근, 수정, 추가, 삭제, 순회 등의 연산을 지원하며, 사용자가 용량 제한을 신경 쓰지 않아도 된다. 리스트는 연결 리스트나 배열로 구현할 수 있다. + +- 연결 리스트는 원소의 삽입, 삭제, 탐색, 갱신을 지원하고 유연하게 용량을 늘릴 수 있으므로 자연스럽게 리스트로 볼 수 있다. +- 배열도 원소의 삽입, 삭제, 탐색, 갱신을 지원하지만 길이를 바꿀 수 없으므로 길이가 제한된 리스트로 볼 수 있다. + +배열로 리스트를 구현하면 **길이를 바꿀 수 없다는 특성 때문에 실용성이 낮아진다**. 보통 저장할 데이터 양을 미리 알 수 없어 적절한 길이를 정하기 어렵기 때문이다. 길이가 너무 짧으면 필요를 충족하지 못하고, 너무 길면 메모리 공간을 낭비한다. + +이 문제는 동적 배열(dynamic array)로 리스트를 구현하여 해결할 수 있다. 동적 배열은 배열의 장점을 이어받으면서도 프로그램 실행 중에 용량을 동적으로 늘릴 수 있다. + +실제로 **많은 프로그래밍 언어의 표준 라이브러리가 제공하는 리스트는 동적 배열로 구현된다**. Python의 `list`, Java의 `ArrayList`, C++의 `vector`, C#의 `List` 등이 그 예다. 이후 설명에서는 ‘리스트’와 ‘동적 배열’을 같은 개념으로 다룬다. + +## 4.3.1 리스트의 기본 연산 + +### 1. 리스트 초기화 + +보통 ‘초깃값 없음’과 ‘초깃값 지정’의 두 가지 초기화 방식을 사용한다. + +=== "Python" + + ```python title="list.py" + # 리스트 초기화 + # 초깃값 없음 + nums1: list[int] = [] + # 초깃값 지정 + nums: list[int] = [1, 3, 2, 5, 4] + ``` + +=== "C++" + + ```cpp title="list.cpp" + /* 리스트 초기화 */ + // C++의 vector가 이 글에서 설명하는 nums에 해당한다 + // 초깃값 없음 + vector표 4-2 컴퓨터의 저장 장치
+ +그림 4-9 컴퓨터 저장 시스템
+ +!!! tip "참고" + + 컴퓨터의 저장 계층 구조는 속도, 용량, 비용 사이의 정교한 균형을 보여 준다. 이러한 절충은 모든 산업 분야에 널리 존재하며, 서로 다른 장점과 제약 사이에서 최적의 균형을 찾아야 한다. + +전체적으로 **하드 디스크는 많은 데이터를 장기간 저장하고, 메모리는 실행 중인 프로그램이 처리하는 데이터를 임시 저장하며, 캐시는 자주 접근하는 데이터와 명령어를 저장하여** 실행 효율을 높인다. 세 장치는 서로 협력하여 컴퓨터 시스템이 효율적으로 작동하게 한다. + +아래 그림(4-10)과 같이 프로그램이 실행되면 하드 디스크의 데이터를 메모리로 읽어 와 CPU가 계산에 사용한다. 캐시는 CPU의 일부로 볼 수 있으며, **메모리에서 데이터를 지능적으로 불러와** CPU에 빠른 데이터 읽기를 제공한다. 이를 통해 실행 효율을 크게 높이고 더 느린 메모리에 대한 의존을 줄인다. + +{ class="animation-figure" } + +그림 4-10 하드 디스크, 메모리, 캐시 사이의 데이터 흐름
+ +## 4.4.2 자료 구조의 메모리 효율 + +메모리 공간 활용 측면에서 배열과 연결 리스트에는 각각 장점과 한계가 있다. + +한편으로 **메모리는 한정되어 있으며 같은 메모리 영역을 여러 프로그램이 공유할 수 없으므로**, 자료 구조가 공간을 최대한 효율적으로 사용하기를 바란다. 배열 원소는 빈틈없이 붙어 있어 연결 리스트 노드 사이의 참조(포인터)를 저장할 추가 공간이 필요 없으므로 공간 효율이 더 높다. 하지만 배열은 충분한 연속 메모리를 한꺼번에 할당해야 하므로 공간 낭비가 발생할 수 있으며, 용량 확장에도 시간과 공간이 추가로 든다. 반면 연결 리스트는 ‘노드’ 단위로 메모리를 동적으로 할당하고 회수하므로 더 유연하다. + +다른 한편으로 프로그램이 실행되면서 **메모리 할당과 해제가 반복되면 빈 메모리의 단편화가 점점 심해져** 메모리 활용 효율이 낮아진다. 배열은 연속 저장 방식을 사용하므로 상대적으로 단편화를 덜 일으킨다. 반면 연결 리스트의 원소는 분산되어 있으므로 삽입과 삭제가 잦으면 단편화가 더 쉽게 발생한다. + +## 4.4.3 자료 구조의 캐시 효율 + +캐시는 메모리보다 용량은 훨씬 작지만 속도는 훨씬 빨라 프로그램 실행 속도에 매우 중요한 역할을 한다. 용량이 제한되어 있어 자주 사용하는 데이터 일부만 저장할 수 있으므로, CPU가 접근하려는 데이터가 캐시에 없으면 캐시 미스(cache miss)가 발생한다. 이때 CPU는 더 느린 메모리에서 필요한 데이터를 불러와야 한다. + +따라서 **‘캐시 미스’가 적을수록 CPU의 데이터 읽기 및 쓰기 효율이 높아지고**, 프로그램 성능도 좋아진다. CPU가 캐시에서 데이터를 성공적으로 가져오는 비율을 캐시 적중률(cache hit rate)이라고 하며, 캐시 효율을 측정하는 지표로 자주 사용한다. + +캐시는 효율을 최대한 높이기 위해 다음과 같은 데이터 로딩 방식을 사용한다. + +- **캐시 라인**: 캐시는 데이터를 한 바이트씩 저장하고 불러오는 대신 캐시 라인 단위로 처리한다. 캐시 라인 단위 전송은 바이트 단위 전송보다 효율적이다. +- **프리페치**: 프로세서는 순차 접근이나 고정 간격 접근 같은 데이터 접근 패턴을 예측하고, 그 패턴에 따라 데이터를 미리 캐시에 불러와 적중률을 높인다. +- **공간 지역성**: 어떤 데이터에 접근하면 가까운 시일 안에 주변 데이터에도 접근할 가능성이 있다. 따라서 캐시는 데이터를 불러올 때 주변 데이터도 함께 불러와 적중률을 높인다. +- **시간 지역성**: 어떤 데이터에 접근하면 머지않아 다시 접근할 가능성이 높다. 캐시는 이 원리를 이용해 최근 접근한 데이터를 유지함으로써 적중률을 높인다. + +실제로 **배열과 연결 리스트의 캐시 활용 효율은 서로 다르며**, 주로 다음과 같은 차이가 있다. + +- **공간 사용량**: 연결 리스트 원소는 배열 원소보다 더 많은 공간을 차지하므로 캐시에 담을 수 있는 유효 데이터의 양이 적다. +- **캐시 라인**: 연결 리스트의 데이터는 메모리 곳곳에 흩어져 있지만 캐시는 ‘라인 단위’로 불러오므로, 불필요한 데이터를 가져오는 비율이 높다. +- **프리페치**: 배열의 데이터 접근 패턴은 연결 리스트보다 ‘예측 가능성’이 높다. 즉, 시스템이 다음에 불러올 데이터를 더 쉽게 예상할 수 있다. +- **공간 지역성**: 배열은 한곳에 모인 메모리 공간에 저장되므로, 불러온 데이터 주변의 데이터에도 곧 접근할 가능성이 더 높다. + +대체로 **배열은 캐시 적중률이 더 높아 연산 효율에서도 연결 리스트보다 유리한 경우가 많다**. 이 때문에 알고리즘 문제를 풀 때는 배열 기반 자료 구조를 더 선호하는 경우가 많다. + +다만 **캐시 효율이 높다고 해서 모든 상황에서 배열이 연결 리스트보다 좋은 것은 아니다**. 실제로 어떤 자료 구조를 쓸지는 구체적인 요구에 따라 결정해야 한다. 예를 들어 배열과 연결 리스트 모두 ‘스택’을 구현할 수 있지만(다음 장에서 자세히 설명한다), 적합한 상황은 다르다. + +- 알고리즘 문제를 풀 때는 배열 기반 스택을 선호한다. 배열에 일정한 메모리 공간을 미리 할당하기만 하면, 높은 연산 효율과 임의 접근 기능을 얻을 수 있기 때문이다. +- 데이터가 매우 많고 변화가 잦으며 스택의 예상 크기를 가늠하기 어렵다면 연결 리스트 기반 스택이 더 적합하다. 연결 리스트는 많은 데이터를 메모리 여러 곳에 분산 저장할 수 있으며, 배열 용량 확장에 따른 추가 비용도 피할 수 있다. diff --git a/ko/docs/chapter_array_and_linkedlist/summary.md b/ko/docs/chapter_array_and_linkedlist/summary.md new file mode 100644 index 000000000..b8039325c --- /dev/null +++ b/ko/docs/chapter_array_and_linkedlist/summary.md @@ -0,0 +1,90 @@ +--- +comments: true +--- + +# 4.5 요약 + +### 1. 핵심 정리 + +- 배열과 연결 리스트는 두 가지 기본 자료 구조로, 컴퓨터 메모리에 데이터를 저장하는 연속 공간 저장과 분산 공간 저장을 각각 대표한다. 둘의 특징은 서로 보완적이다. +- 배열은 임의 접근을 지원하고 메모리 사용량이 적다. 그러나 원소 삽입과 삭제의 효율이 낮으며 초기화한 뒤 길이를 바꿀 수 없다. +- 연결 리스트는 참조(포인터)를 바꾸어 노드를 효율적으로 삽입하고 삭제하며, 길이도 유연하게 조절할 수 있다. 하지만 노드 접근 효율이 낮고 메모리를 더 많이 사용한다. 대표적인 종류에는 단일 연결 리스트, 원형 연결 리스트, 이중 연결 리스트가 있다. +- 리스트는 삽입, 삭제, 탐색, 갱신을 지원하는 순서 있는 원소의 모음으로, 보통 동적 배열로 구현한다. 배열의 장점을 유지하면서 길이를 유연하게 조절할 수 있다. +- 리스트의 등장으로 배열의 실용성이 크게 높아졌지만, 메모리 공간 일부가 낭비될 수 있다. +- 프로그램이 실행될 때 데이터는 주로 메모리에 저장된다. 배열은 메모리 공간 효율이 더 높고, 연결 리스트는 메모리를 더 유연하게 사용한다. +- 캐시는 캐시 라인, 프리페치, 공간 지역성, 시간 지역성 등의 로딩 방식을 통해 CPU에 빠른 데이터 접근을 제공하여 프로그램 실행 효율을 크게 높인다. +- 배열은 캐시 적중률이 더 높으므로 보통 연결 리스트보다 효율적이다. 자료 구조를 선택할 때는 구체적인 요구와 상황에 맞춰야 한다. + +### 2. Q & A + +**Q**: 배열을 스택에 저장하는지 힙에 저장하는지에 따라 시간 효율과 공간 효율이 달라지는가? + +스택에 저장한 배열도 힙에 저장한 배열도 연속된 메모리 공간에 있으므로, 데이터 연산 효율은 대체로 같다. 다만 스택과 힙의 특성 때문에 다음과 같은 차이가 생긴다. + +1. 할당 및 해제 효율: 스택은 비교적 작은 메모리 영역으로 컴파일러가 자동으로 할당한다. 힙은 더 크며 코드에서 동적으로 할당할 수 있고 단편화도 더 쉽게 발생한다. 따라서 힙의 할당 및 해제 연산은 보통 스택보다 느리다. +2. 크기 제한: 스택 메모리는 비교적 작고 힙의 크기는 대개 사용 가능한 메모리에 의해 제한된다. 따라서 큰 배열을 저장하기에는 힙이 더 적합하다. +3. 유연성: 스택에 저장하는 배열의 크기는 컴파일 시 정해야 하지만, 힙에 저장하는 배열의 크기는 실행 중에 동적으로 정할 수 있다. + +**Q**: 배열은 원소의 자료형이 같아야 한다고 하는데, 연결 리스트에서는 왜 이를 강조하지 않는가? + +연결 리스트는 참조(포인터)로 연결된 노드들로 이루어진다. 각 노드에는 `int`, `double`, `string`, `object` 등 서로 다른 자료형의 데이터를 저장할 수 있다. + +반면 배열 원소는 자료형이 같아야 오프셋을 계산하여 해당 원소의 위치를 구할 수 있다. 예를 들어 배열에 `int`와 `long`이 함께 있으면 원소 하나가 각각 4바이트와 8바이트를 차지한다. ‘원소 길이’가 두 가지이므로 다음 식으로 오프셋을 계산할 수 없다. + +```shell +# 원소 메모리 주소 = 배열 메모리 주소(첫 원소의 메모리 주소) + 원소 길이 * 원소 인덱스 +``` + +**Q**: 노드 `P`를 삭제한 뒤 `P.next`를 `None`으로 설정해야 하는가? + +`P.next`를 바꾸지 않아도 된다. 해당 연결 리스트에서는 머리 노드부터 꼬리 노드까지 순회해도 더 이상 `P`를 만나지 않는다. 즉, `P`는 이미 연결 리스트에서 삭제되었으므로 어디를 가리키든 이 연결 리스트에 영향을 주지 않는다. + +자료 구조와 알고리즘 문제를 푸는 관점에서는 프로그램 논리가 올바르기만 하면 연결을 끊지 않아도 된다. 표준 라이브러리 관점에서는 연결을 끊는 편이 더 안전하고 논리도 명확하다. 연결을 끊지 않은 상태에서 삭제한 노드가 정상적으로 회수되지 않으면, 뒤따르는 노드의 메모리 회수에도 영향을 줄 수 있다. + +**Q**: 연결 리스트의 삽입과 삭제는 시간 복잡도가 $O(1)$이라고 한다. 하지만 먼저 원소를 찾는 데 $O(n)$이 필요한데, 전체 시간 복잡도는 왜 $O(n)$이 아닌가? + +원소를 먼저 찾고 삭제한다면 시간 복잡도는 실제로 $O(n)$이다. 다만 연결 리스트의 $O(1)$ 삽입 및 삭제는 다른 응용에서 장점을 발휘한다. 예를 들어 덱은 연결 리스트로 구현하기에 적합하다. 머리 노드와 꼬리 노드를 항상 가리키는 포인터 변수를 유지하면 매번 삽입과 삭제를 $O(1)$에 수행할 수 있다. + +**Q**: ‘연결 리스트의 정의와 저장 방식’ 그림에서 노드 포인터를 저장하는 연한 파란색 부분은 하나의 메모리 주소를 차지하는가? 아니면 노드 값과 반씩 차지하는가? + +그 그림은 정성적인 설명이다. 정확한 크기는 구체적인 상황에 따라 분석해야 한다. + +- 노드 값이 차지하는 공간은 자료형에 따라 다르다. 예를 들어 `int`, `long`, `double`, 인스턴스 객체 등이 있다. +- 포인터 변수가 차지하는 메모리 크기는 운영체제와 컴파일 환경에 따라 정해지며, 대개 8바이트 또는 4바이트다. + +**Q**: 리스트 끝에 원소를 추가하는 연산은 항상 $O(1)$인가? + +원소를 추가할 때 리스트의 길이를 넘으면 먼저 용량을 늘려야 한다. 시스템이 새 메모리 영역을 요청하고 기존 원소 전체를 옮기므로, 이때의 시간 복잡도는 $O(n)$이다. + +**Q**: ‘리스트는 배열의 실용성을 크게 높였지만 메모리 공간 일부를 낭비할 수 있다’는 설명에서, 공간 낭비는 용량, 길이, 확장 배수 같은 추가 변수의 메모리를 뜻하는가? + +여기서 공간 낭비는 주로 두 가지를 뜻한다. 하나는 리스트에 초기 길이를 설정하지만 그만큼 필요하지 않을 수 있다는 것이다. 다른 하나는 잦은 확장을 피하려고 보통 $\times 1.5$처럼 일정한 계수를 곱해 용량을 늘린다는 것이다. 이때도 빈자리가 많이 생기며, 보통 이를 전부 채우지는 못한다. + +**Q**: Python에서 `n = [1, 2, 3]`을 초기화하면 세 원소의 주소가 이어져 있다. 하지만 `m = [2, 1, 3]`을 초기화하면 원소들의 id가 연속적이지 않고 `n`의 같은 값과 각각 일치한다. 주소가 연속적이지 않아도 `m`은 배열인가? + +리스트 원소를 연결 리스트 노드로 바꾸어 `n = [n1, n2, n3, n4, n5]`라고 하면, 이 다섯 노드 객체도 보통 메모리 곳곳에 흩어져 있다. 그래도 리스트 인덱스가 주어지면 $O(1)$ 시간에 노드의 메모리 주소를 얻어 해당 노드에 접근할 수 있다. 배열에 저장된 것은 노드 자체가 아니라 노드의 참조이기 때문이다. + +많은 언어와 달리 Python에서는 숫자도 객체로 감싸져 있으며, 리스트에는 숫자 자체가 아닌 숫자의 참조가 저장된다. 따라서 두 배열의 같은 숫자가 같은 id를 가지며, 숫자들의 메모리 주소는 연속적일 필요가 없다. + +**Q**: C++ STL의 `std::list`는 이중 연결 리스트를 구현하는데, 일부 알고리즘 책에서는 거의 직접 쓰지 않는 것 같다. 어떤 한계가 있기 때문인가? + +한편으로는 보통 배열로 알고리즘을 구현하는 것을 선호하며, 꼭 필요할 때만 연결 리스트를 사용한다. 주된 이유는 두 가지다. + +- 공간 비용: 원소마다 이전 원소와 다음 원소를 위한 포인터가 두 개 더 필요하므로 `std::list`는 보통 `std::vector`보다 공간을 많이 차지한다. +- 캐시에 불리함: 데이터가 연속적으로 저장되지 않아 `std::list`의 캐시 활용률이 낮다. 일반적으로는 `std::vector`의 성능이 더 좋다. + +다른 한편으로 연결 리스트가 필요한 경우는 주로 이진 트리와 그래프다. 스택과 큐는 연결 리스트 대신 프로그래밍 언어가 제공하는 `stack`과 `queue`를 쓰는 경우가 많다. + +**Q**: `res = [[0]] * n`으로 만든 이차원 리스트에서 각 `[0]`은 서로 독립적인가? + +독립적이지 않다. 이 이차원 리스트의 모든 `[0]`은 실제로 같은 객체를 참조한다. 한 원소를 수정하면 대응하는 원소가 모두 함께 바뀐다. + +각 `[0]`을 독립적으로 만들려면 `res = [[0] for _ in range(n)]`을 사용하면 된다. 이 방식은 서로 독립적인 `[0]` 리스트 객체 $n$개를 초기화한다. + +**Q**: `res = [0] * n`으로 만든 리스트에서 각 정수 0은 서로 독립적인가? + +이 리스트의 모든 정수 0은 같은 객체를 참조한다. Python은 객체 재사용을 극대화하고 성능을 높이기 위해 작은 정수(보통 -5부터 256까지)를 캐시 풀로 관리하기 때문이다. + +모두 같은 객체를 가리켜도 리스트의 각 원소는 독립적으로 바꿀 수 있다. Python의 정수는 ‘불변 객체’이기 때문이다. 원소를 바꾸면 기존 객체 자체가 바뀌는 것이 아니라 다른 객체를 참조하게 된다. + +그러나 리스트 원소가 리스트, 딕셔너리, 클래스 인스턴스 같은 ‘가변 객체’라면, 원소의 내용을 수정할 때 객체 자체가 바뀌므로 이를 참조하는 모든 원소에서 같은 변화가 나타난다. diff --git a/ko/docs/chapter_backtracking/backtracking_algorithm.md b/ko/docs/chapter_backtracking/backtracking_algorithm.md new file mode 100644 index 000000000..25abd2bbe --- /dev/null +++ b/ko/docs/chapter_backtracking/backtracking_algorithm.md @@ -0,0 +1,2003 @@ +--- +comments: true +--- + +# 13.1 백트래킹 알고리즘 + +백트래킹 알고리즘(backtracking algorithm)은 모든 경우를 열거하여 문제를 푸는 방법이다. 초기 상태에서 출발하여 가능한 모든 해결 방법을 완전 탐색하고, 올바른 해를 만나면 기록한다. 해를 찾거나 가능한 선택을 모두 시도해도 찾을 수 없을 때까지 진행하는 것이 핵심이다. + +백트래킹은 보통 '깊이 우선 탐색'으로 해 공간을 순회한다. '이진 트리' 장에서 전위, 중위, 후위 순회가 모두 깊이 우선 탐색이라고 설명했다. 이제 전위 순회를 이용한 백트래킹 문제를 만들어 작동 원리를 차근차근 알아보자. + +!!! question "예제 1" + + 이진 트리가 주어졌을 때 값이 $7$인 모든 노드를 찾아 기록하고, 노드 리스트를 반환하라. + +이 문제에서는 트리를 전위 순회하며 현재 노드의 값이 $7$인지 확인하고, 맞으면 해당 노드의 값을 결과 리스트 `res`에 추가한다. 과정은 아래 그림(13-1)과 코드에 나타나 있다. + +=== "Python" + + ```python title="preorder_traversal_i_compact.py" + def pre_order(root: TreeNode): + """전위 순회: 예제 1""" + if root is None: + return + if root.val == 7: + # 해를 기록한다 + res.append(root) + pre_order(root.left) + pre_order(root.right) + ``` + +=== "C++" + + ```cpp title="preorder_traversal_i_compact.cpp" + /* 전위 순회: 예제 1 */ + void preOrder(TreeNode *root) { + if (root == nullptr) { + return; + } + if (root->val == 7) { + // 해를 기록한다 + res.push_back(root); + } + preOrder(root->left); + preOrder(root->right); + } + ``` + +=== "Java" + + ```java title="preorder_traversal_i_compact.java" + /* 전위 순회: 예제 1 */ + void preOrder(TreeNode root) { + if (root == null) { + return; + } + if (root.val == 7) { + // 해를 기록한다 + res.add(root); + } + preOrder(root.left); + preOrder(root.right); + } + ``` + +=== "C#" + + ```csharp title="preorder_traversal_i_compact.cs" + /* 전위 순회: 예제 1 */ + void PreOrder(TreeNode? root) { + if (root == null) { + return; + } + if (root.val == 7) { + // 해를 기록한다 + res.Add(root); + } + PreOrder(root.left); + PreOrder(root.right); + } + ``` + +=== "Go" + + ```go title="preorder_traversal_i_compact.go" + /* 전위 순회: 예제 1 */ + func preOrderI(root *TreeNode, res *[]*TreeNode) { + if root == nil { + return + } + if (root.Val).(int) == 7 { + // 해를 기록한다 + *res = append(*res, root) + } + preOrderI(root.Left, res) + preOrderI(root.Right, res) + } + ``` + +=== "Swift" + + ```swift title="preorder_traversal_i_compact.swift" + /* 전위 순회: 예제 1 */ + func preOrder(root: TreeNode?) { + guard let root = root else { + return + } + if root.val == 7 { + // 해를 기록한다 + res.append(root) + } + preOrder(root: root.left) + preOrder(root: root.right) + } + ``` + +=== "JS" + + ```javascript title="preorder_traversal_i_compact.js" + /* 전위 순회: 예제 1 */ + function preOrder(root, res) { + if (root === null) { + return; + } + if (root.val === 7) { + // 해를 기록한다 + res.push(root); + } + preOrder(root.left, res); + preOrder(root.right, res); + } + ``` + +=== "TS" + + ```typescript title="preorder_traversal_i_compact.ts" + /* 전위 순회: 예제 1 */ + function preOrder(root: TreeNode | null, res: TreeNode[]): void { + if (root === null) { + return; + } + if (root.val === 7) { + // 해를 기록한다 + res.push(root); + } + preOrder(root.left, res); + preOrder(root.right, res); + } + ``` + +=== "Dart" + + ```dart title="preorder_traversal_i_compact.dart" + /* 전위 순회: 예제 1 */ + void preOrder(TreeNode? root, List그림 13-1 전위 순회로 노드 탐색
+ +## 13.1.1 시도와 되돌리기 + +**백트래킹이라고 부르는 이유는 해 공간을 탐색할 때 '시도'와 '되돌리기' 전략을 사용하기 때문이다**. 탐색 중 더 진행할 수 없거나 조건을 만족하는 해를 얻을 수 없는 상태를 만나면, 직전 선택을 취소하고 이전 상태로 돌아가 다른 선택을 시도한다. + +예제 1에서는 각 노드의 방문이 한 번의 '시도'이며, 리프 노드를 지나거나 부모 노드로 돌아가는 `return`이 '되돌리기'에 해당한다. + +**되돌리기에는 함수 반환만 포함되는 것이 아니다**. 이를 설명하기 위해 예제 1을 조금 확장해 보자. + +!!! question "예제 2" + + 이진 트리에서 값이 $7$인 모든 노드를 찾아 **루트 노드에서 각 노드까지의 경로를 반환하라**. + +예제 1의 코드에 리스트 `path`를 추가하여 방문한 노드의 경로를 기록해야 한다. 값이 $7$인 노드를 방문하면 `path`를 복사하여 결과 리스트 `res`에 추가한다. 순회를 마치면 `res`에 모든 해가 저장된다. 코드는 다음과 같다. + +=== "Python" + + ```python title="preorder_traversal_ii_compact.py" + def pre_order(root: TreeNode): + """전위 순회: 예제 2""" + if root is None: + return + # 시도 + path.append(root) + if root.val == 7: + # 해를 기록한다 + res.append(list(path)) + pre_order(root.left) + pre_order(root.right) + # 되돌리기 + path.pop() + ``` + +=== "C++" + + ```cpp title="preorder_traversal_ii_compact.cpp" + /* 전위 순회: 예제 2 */ + void preOrder(TreeNode *root) { + if (root == nullptr) { + return; + } + // 시도 + path.push_back(root); + if (root->val == 7) { + // 해를 기록한다 + res.push_back(path); + } + preOrder(root->left); + preOrder(root->right); + // 되돌리기 + path.pop_back(); + } + ``` + +=== "Java" + + ```java title="preorder_traversal_ii_compact.java" + /* 전위 순회: 예제 2 */ + void preOrder(TreeNode root) { + if (root == null) { + return; + } + // 시도 + path.add(root); + if (root.val == 7) { + // 해를 기록한다 + res.add(new ArrayList<>(path)); + } + preOrder(root.left); + preOrder(root.right); + // 되돌리기 + path.remove(path.size() - 1); + } + ``` + +=== "C#" + + ```csharp title="preorder_traversal_ii_compact.cs" + /* 전위 순회: 예제 2 */ + void PreOrder(TreeNode? root) { + if (root == null) { + return; + } + // 시도 + path.Add(root); + if (root.val == 7) { + // 해를 기록한다 + res.Add(new List그림 13-2 시도와 되돌리기
+ +## 13.1.2 가지치기 + +복잡한 백트래킹 문제에는 보통 하나 이상의 제약 조건이 있으며, **이 제약 조건을 '가지치기'에 활용할 수 있다**. + +!!! question "예제 3" + + 이진 트리에서 값이 $7$인 모든 노드를 찾아 루트 노드에서 각 노드까지의 경로를 반환하라. **단, 경로에 값이 $3$인 노드가 포함되면 안 된다**. + +이 제약을 만족하려면 **가지치기 연산을 추가해야 한다**. 탐색 중 값이 $3$인 노드를 만나면 더 탐색하지 않고 조기에 반환한다. 코드는 다음과 같다. + +=== "Python" + + ```python title="preorder_traversal_iii_compact.py" + def pre_order(root: TreeNode): + """전위 순회: 예제 3""" + # 가지치기 + if root is None or root.val == 3: + return + # 시도 + path.append(root) + if root.val == 7: + # 해를 기록한다 + res.append(list(path)) + pre_order(root.left) + pre_order(root.right) + # 되돌리기 + path.pop() + ``` + +=== "C++" + + ```cpp title="preorder_traversal_iii_compact.cpp" + /* 전위 순회: 예제 3 */ + void preOrder(TreeNode *root) { + // 가지치기 + if (root == nullptr || root->val == 3) { + return; + } + // 시도 + path.push_back(root); + if (root->val == 7) { + // 해를 기록한다 + res.push_back(path); + } + preOrder(root->left); + preOrder(root->right); + // 되돌리기 + path.pop_back(); + } + ``` + +=== "Java" + + ```java title="preorder_traversal_iii_compact.java" + /* 전위 순회: 예제 3 */ + void preOrder(TreeNode root) { + // 가지치기 + if (root == null || root.val == 3) { + return; + } + // 시도 + path.add(root); + if (root.val == 7) { + // 해를 기록한다 + res.add(new ArrayList<>(path)); + } + preOrder(root.left); + preOrder(root.right); + // 되돌리기 + path.remove(path.size() - 1); + } + ``` + +=== "C#" + + ```csharp title="preorder_traversal_iii_compact.cs" + /* 전위 순회: 예제 3 */ + void PreOrder(TreeNode? root) { + // 가지치기 + if (root == null || root.val == 3) { + return; + } + // 시도 + path.Add(root); + if (root.val == 7) { + // 해를 기록한다 + res.Add(new List그림 13-3 제약 조건에 따른 가지치기
+ +## 13.1.3 기본 틀 코드 + +이제 백트래킹의 '시도, 되돌리기, 가지치기'라는 기본 틀을 추출하여 코드의 범용성을 높여 보자. + +아래 기본 틀 코드에서 `state`는 문제의 현재 상태를, `choices`는 그 상태에서 가능한 선택들을 나타낸다. + +=== "Python" + + ```python title="" + def backtrack(state: State, choices: list[choice], res: list[state]): + """백트래킹 알고리즘의 기본 틀""" + # 해인지 확인 + if is_solution(state): + # 해 기록 + record_solution(state, res) + # 더 이상 탐색하지 않는다 + return + # 모든 선택지 순회 + for choice in choices: + # 가지치기: 선택이 유효한지 확인 + if is_valid(state, choice): + # 시도: 선택하고 상태 갱신 + make_choice(state, choice) + backtrack(state, choices, res) + # 되돌리기: 선택을 취소하고 이전 상태 복원 + undo_choice(state, choice) + ``` + +=== "C++" + + ```cpp title="" + /* 백트래킹 알고리즘의 기본 틀 */ + void backtrack(State *state, vector그림 13-4 return 유지 여부에 따른 탐색 과정 비교
+ +전위 순회 기반 코드에 비해 백트래킹 기본 틀을 사용한 코드는 다소 장황하지만 범용성이 더 좋다. 실제로 **많은 백트래킹 문제를 이 틀 안에서 해결할 수 있다**. 구체적인 문제에 맞게 `state`와 `choices`를 정의하고, 틀 안의 각 메서드만 구현하면 된다. + +## 13.1.4 주요 용어 + +알고리즘 문제를 더 명확히 분석하기 위해 백트래킹에서 자주 쓰는 용어를 정리하고, 예제 3에 대응하는 사례를 아래 표(13-1)에 나타냈다. + +표 13-1 백트래킹 알고리즘의 주요 용어
+ +그림 13-15 4-퀸 문제의 해
+ +아래 그림(13-16)은 세 가지 제약 조건을 보여 준다. **여러 퀸이 같은 행, 같은 열, 같은 대각선에 있으면 안 된다**. 대각선은 주대각선 방향 `\`과 부대각선 방향 `/`의 두 종류로 나뉜다. + +{ class="animation-figure" } + +그림 13-16 n-퀸 문제의 제약 조건
+ +### 1. 한 행씩 배치하는 전략 + +퀸 수와 체스판의 행 수가 모두 $n$이므로 **각 행에는 퀸을 정확히 하나씩 놓아야 한다**는 사실을 쉽게 도출할 수 있다. + +따라서 첫 행부터 마지막 행까지 매 행에 퀸 하나씩 놓는 전략을 사용할 수 있다. + +아래 그림(13-17)은 4-퀸 문제에서 한 행씩 배치하는 과정이다. 공간 제약 때문에 첫 행의 탐색 가지 중 하나만 펼쳤으며, 열과 대각선 제약을 만족하지 않는 배치는 모두 가지치기했다. + +{ class="animation-figure" } + +그림 13-17 한 행씩 배치하는 전략
+ +본질적으로 **행별 배치 전략 자체가 가지치기 역할을 한다**. 같은 행에 여러 퀸이 놓이는 모든 탐색 가지를 피하기 때문이다. + +### 2. 열과 대각선 가지치기 + +열 제약을 만족하기 위해 길이 $n$의 불리언 배열 `cols`에 각 열의 퀸 존재 여부를 기록할 수 있다. 배치를 결정하기 전에 `cols`로 이미 퀸이 있는 열을 가지치기하고, 백트래킹 중 `cols`의 상태를 동적으로 갱신한다. + +!!! tip "참고" + + 행렬의 시작점은 왼쪽 위이며, 행 인덱스는 아래로 갈수록, 열 인덱스는 오른쪽으로 갈수록 커진다. + +대각선 제약은 어떻게 처리할까? 한 칸의 행과 열 인덱스를 $(row, col)$이라고 하자. 주대각선 방향의 대각선 하나를 고르면, 그 위의 모든 칸에서 행 인덱스와 열 인덱스의 차가 같다. **즉, 같은 주대각선 방향 대각선에서는 $row - col$이 일정하다**. + +따라서 두 칸이 $row_1 - col_1 = row_2 - col_2$를 만족하면 반드시 같은 주대각선 방향 대각선에 있다. 이 규칙을 이용하여 아래 그림(13-18)의 배열 `diags1`에 각 대각선의 퀸 존재 여부를 기록할 수 있다. + +마찬가지로 **같은 부대각선 방향 대각선의 모든 칸에서는 $row + col$이 일정하다**. 배열 `diags2`를 이용하여 이 방향의 제약도 처리할 수 있다. + +{ class="animation-figure" } + +그림 13-18 열 제약과 대각선 제약 처리
+ +### 3. 코드 구현 + +$n$ 차 정방행렬에서 $row - col$의 범위는 $[-n + 1, n - 1]$, $row + col$의 범위는 $[0, 2n - 2]$이다. 따라서 두 방향의 대각선 수는 각각 $2n - 1$ 개이며, 배열 `diags1`과 `diags2`의 길이도 모두 $2n - 1$이다. + +=== "Python" + + ```python title="n_queens.py" + def backtrack( + row: int, + n: int, + state: list[list[str]], + res: list[list[list[str]]], + cols: list[bool], + diags1: list[bool], + diags2: list[bool], + ): + """백트래킹 알고리즘: n-퀸""" + # 모든 행에 배치했으면 해를 기록한다 + if row == n: + res.append([list(row) for row in state]) + return + # 모든 열을 순회한다 + for col in range(n): + # 해당 칸이 속한 주대각선과 부대각선을 계산한다 + diag1 = row - col + n - 1 + diag2 = row + col + # 가지치기: 해당 칸이 속한 열, 주대각선, 부대각선에 퀸이 있으면 안 된다 + if not cols[col] and not diags1[diag1] and not diags2[diag2]: + # 시도: 해당 칸에 퀸을 놓는다 + state[row][col] = "Q" + cols[col] = diags1[diag1] = diags2[diag2] = True + # 다음 행에 배치한다 + backtrack(row + 1, n, state, res, cols, diags1, diags2) + # 되돌리기: 해당 칸을 빈칸으로 되돌린다 + state[row][col] = "#" + cols[col] = diags1[diag1] = diags2[diag2] = False + + def n_queens(n: int) -> list[list[list[str]]]: + """n-퀸 문제 풀기""" + # n*n 크기의 체스판을 초기화한다. 'Q'는 퀸, '#'은 빈칸을 나타낸다 + state = [["#" for _ in range(n)] for _ in range(n)] + cols = [False] * n # 열에 퀸이 있는지 기록한다 + diags1 = [False] * (2 * n - 1) # 주대각선에 퀸이 있는지 기록한다 + diags2 = [False] * (2 * n - 1) # 부대각선에 퀸이 있는지 기록한다 + res = [] + backtrack(0, n, state, res, cols, diags1, diags2) + + return res + ``` + +=== "C++" + + ```cpp title="n_queens.cpp" + /* 백트래킹 알고리즘: n-퀸 */ + void backtrack(int row, int n, vector표 13-2 모든 순열의 예시
+ +그림 13-5 모든 순열의 재귀 트리
+ +### 1. 중복 선택 가지치기 + +각 원소를 한 번만 선택하도록 불리언 배열 `selected`를 도입하자. `selected[i]`는 `choices[i]`를 이미 선택했는지 나타내며, 이를 바탕으로 다음과 같이 가지치기한다. + +- `choices[i]`를 선택하면 `selected[i]`를 $\text{True}$로 설정하여 이미 선택했음을 표시한다. +- 선택지 리스트 `choices`를 순회할 때 이미 선택한 모든 노드를 건너뛰어 가지치기한다. + +아래 그림(13-6)처럼 첫 번째에 1, 두 번째에 3, 세 번째에 2를 선택한다면, 두 번째에서는 원소 1의 가지를, 세 번째에서는 원소 1과 3의 가지를 잘라 내야 한다. + +{ class="animation-figure" } + +그림 13-6 모든 순열의 가지치기 예시
+ +위 그림(13-6)에서 이 가지치기가 탐색 공간의 크기를 $O(n^n)$에서 $O(n!)$로 줄이는 것을 볼 수 있다. + +### 2. 코드 구현 + +위 내용을 정리했으니 기본 틀 코드의 '빈칸을 채울' 수 있다. 전체 코드를 짧게 만들기 위해 각 함수를 따로 구현하지 않고 `backtrack()` 함수 안에 직접 작성한다. + +=== "Python" + + ```python title="permutations_i.py" + def backtrack( + state: list[int], choices: list[int], selected: list[bool], res: list[list[int]] + ): + """백트래킹 알고리즘: 모든 순열 I""" + # 상태의 길이가 원소 개수와 같으면 해를 기록한다 + if len(state) == len(choices): + res.append(list(state)) + return + # 모든 선택지를 순회한다 + for i, choice in enumerate(choices): + # 가지치기: 원소를 중복하여 선택할 수 없다 + if not selected[i]: + # 시도: 선택하고 상태를 갱신한다 + selected[i] = True + state.append(choice) + # 다음 선택을 진행한다 + backtrack(state, choices, selected, res) + # 되돌리기: 선택을 취소하고 이전 상태로 되돌린다 + selected[i] = False + state.pop() + + def permutations_i(nums: list[int]) -> list[list[int]]: + """모든 순열 I""" + res = [] + backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res) + return res + ``` + +=== "C++" + + ```cpp title="permutations_i.cpp" + /* 백트래킹 알고리즘: 모든 순열 I */ + void backtrack(vector그림 13-7 중복된 순열
+ +중복된 순열은 어떻게 제거할까? 가장 직접적으로는 해시 집합을 이용해 결과에서 중복을 제거할 수 있다. 하지만 이 방법은 충분히 간결하지 않다. **중복된 순열을 만드는 탐색 가지는 불필요하므로 미리 알아내어 잘라 내야 하며**, 그러면 알고리즘의 효율을 더 높일 수 있다. + +### 1. 같은 값의 원소 가지치기 + +아래 그림(13-8)에서 첫 번째 선택으로 $1$을 고르든 $\hat{1}$을 고르든 같다. 두 선택 아래에서 만들어지는 모든 순열이 중복되므로 $\hat{1}$을 가지치기해야 한다. + +마찬가지로 첫 번째에 $2$를 선택한 뒤에도 두 번째의 $1$과 $\hat{1}$이 중복 가지를 만들므로 두 번째의 $\hat{1}$도 잘라 내야 한다. + +본질적으로 **한 차례의 선택에서 값이 같은 여러 원소를 한 번만 선택하도록 보장하는 것**이 목표다. + +{ class="animation-figure" } + +그림 13-8 중복된 순열 가지치기
+ +### 2. 코드 구현 + +앞 문제의 코드를 바탕으로 매 차례의 선택에서 해시 집합 `duplicated`를 만들어 이미 시도한 원소를 기록하고 중복 원소를 가지치기한다. + +=== "Python" + + ```python title="permutations_ii.py" + def backtrack( + state: list[int], choices: list[int], selected: list[bool], res: list[list[int]] + ): + """백트래킹 알고리즘: 모든 순열 II""" + # 상태의 길이가 원소 개수와 같으면 해를 기록한다 + if len(state) == len(choices): + res.append(list(state)) + return + # 모든 선택지를 순회한다 + duplicated = set[int]() + for i, choice in enumerate(choices): + # 가지치기: 원소를 중복하여 선택할 수 없으며, 값이 같은 원소도 중복하여 선택할 수 없다 + if not selected[i] and choice not in duplicated: + # 시도: 선택하고 상태를 갱신한다 + duplicated.add(choice) # 선택한 원소의 값을 기록한다 + selected[i] = True + state.append(choice) + # 다음 선택을 진행한다 + backtrack(state, choices, selected, res) + # 되돌리기: 선택을 취소하고 이전 상태로 되돌린다 + selected[i] = False + state.pop() + + def permutations_ii(nums: list[int]) -> list[list[int]]: + """모든 순열 II""" + res = [] + backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res) + return res + ``` + +=== "C++" + + ```cpp title="permutations_ii.cpp" + /* 백트래킹 알고리즘: 모든 순열 II */ + void backtrack(vector