sik13579 님의 블로그

[LFS17] xz 패키지 빌드

sik13579 — Mon, 27 Apr 2026 18:01:38 +0900

1. Xz 패키지 역할

Xz는 데이터에서 반복되는 패턴을 찾아내어 극단적으로 크기를 줄여준다

높은 압출률 : gzip 이나 bzip2 보다 훨씬 더 작게 파일을 압출할 수 있다. 저장 공간이 귀한 임시 시스템이나 배포 환경에서 필수적이다.
LFS에서의 역할 : 6장 이후로 넘어가면서 설치할 수많은 거대 패키지(GCC, Glibc 등)의 압축 을 풀 때, 이 xz 라이브러리와 실행 파일이 우리 시스템 안에 이미 준비되어 있어야 한다.

2. Xz 패키지 빌드

1. 소스 준비 및 이동 (lfs 유저)

cd $LFS/sources
tar -xvf xz-5.8.2.tar.xz 
cd xz-5.8.2

2. 설정

./configure --prefix=/usr                     \
            --host=$LFS_TGT                   \
            --build=$(build-aux/config.guess) \
            --disable-static                  \
            --docdir=/usr/share/doc/xz-5.6.1

3. 컴파일 및 설치

make
make DESTDIR=$LFS install

4. 뒷정리

cd $LFS/sources
rm -rf xz-5.8.2

5. 테스트

xz --version
echo "hello LFS xz" > xz-test.txt
xz -k xz-test.txt
ls -l xz-test.txt xz-test.txt.xz

[그림1]

정상적으로 출력되는것을 확인할 수 있습니다.

[LFS16] Tar 패키지 빌드

sik13579 — Mon, 27 Apr 2026 17:51:22 +0900

1. Tar 패키지 역할

Tar의 역할은 아래와 같다.

아카이브(Archive) : 여러 개의 파일과 디렉토리 구조를 깨뜨리지 않고, 하나의 파일(.tar)로 묶어주는 역할만 한다.
압축(Compression) : 여기에 gzip이나 xz같은 친구들이 달라붙어 용량을 줄여주는 것
LFS에서의 역할 : 나중에 chroot로 진짜 루트 권한 환경에 들어갔을 때, 거기서 새로운 패키지 소스를 풀기 위해 가장 먼저 필요한 도구

2. Tar 패키지 빌드

1. 소스 준비 및 이동 (lfs 유저)

cd $LFS/sources
tar -xvf tar-1.35.tar.xz
cd tar-1.35

2. 설정

./configure --prefix=/usr                     \
            --host=$LFS_TGT                   \
            --build=$(build-aux/config.guess)

3. 컴파일 및 설치

make
make DESTDIR=$LFS install

4. 뒷정리

cd $LFS/sources
rm -rf tar-1.35

5.테스트

tar --version  #버전 확인
mkdir tar-test #tar 파일 생성 테스트
echo "hello LFS tar" > tar-test/hello.txt
tar -cf tar-test.tar tar-test
ls -l tar-test.tar

[그림1]

정상적으로 설치 완료 되었습니다.

[LFS15] sed 패키지 빌드

sik13579 — Mon, 27 Apr 2026 17:42:41 +0900

1. Sed의 역할

sed는 파일을 직접 열어 수정하는 일반적인 에디터(Vim, Nano)와는 작동 방식이 완전히 다르다.

비파괴적인 편집 : 원본 파일을 건드리지 않고, 터미널로 출력되는 스트림을 가공해서 보여준다.(물론 -i 옵션을 쓰면 파일도 직접 고친다.)
패턴 매칭 : 특정 단어가 들어간 줄만 지우거나, 정규 표현식을 사용해 복잡한 문자열 패턴을 순식간에 바꿀 수 있다.

2. Sed 패키지 설치

1. 소스 준비 및 이동 (lfs 유저)

cd $LFS/sources
tar -xvf sed-4.9.tar.xz
cd sed-4.9

2. 설정

./configure --prefix=/usr                   \
            --host=$LFS_TGT                 \
            --build=$(build-aux/config.guess)

3. 컴파일 및 설치

make
make DESTDIR=$LFS install

4. 뒷정리

cd $LFS/sources
rm -rf sed-4.9

5. 테스트

sed --version
echo "hello LFS" | sed 's/LFS/Linux From Scratch/'

[그림1]

정상적으로 버전 출력 및, 기본 동작 테스트를 완료해보았습니다.

[LFS14] Python3 빌드

sik13579 — Tue, 21 Apr 2026 16:22:37 +0900

1. Python3 패키지 역할

빌드 도구 및 자동화 기반
- LFS 과정에서 일부 패키지들은 내부적으로 Python 스크립트를 사용해서 아래와 같은 작업을 합니다
  - 설정(configure 보조)
  - 테스트 스위트 실행
  - 코드 생성
- 최근 패키지들 meson, ninja, gdb, systemd 계열 등에서 Python 의존성이 있습니다.
- 즉, 컴파일을 돕는 보조 언어 역할을 합니다.
테스트 프레임워크 지원
- 많은 패키지에서 make check 실행 시 Python을 사용
- 테스트 자동화 스크립트들이 Python 기반
- 없으면 테스트 실패 또는 일부가 스킵됨
시스템 유틸리티 스크립트 실행
- 일부 시스템 도구들이 Python으로 작성됨
  - 예: 일부 관리 스크립트, 빌드 헬퍼
- LFS이후 BLFS단계에서 더욱 중요해질 예정

2. Python3 패키지 구성

Python3 패키지는 꽤 많은 구성 요소로 이루어져 있습니다. 간단하게 살펴보겠습니다.

인터프리터
- Python 코드를 실행하는 핵심 엔진

python3 script.py # C로 구현된 CPython

표준 라이브러리
- Python 설치 시 기본 포함되는 라이브러리들
- 대표적으로
  - os → 파일/프로세스 제어
  - sys → 인터프리터 제어
  - subprocess → 외부 프로그램 실행
  - socket → 네트워크
  - json, re, math 등 이있다.
- 별도 설치 없이 바로 사용 가능하며, LFS 빌드/테스트에서 많이 사용된다.
바이트코드 시스템
빌드 및 확장 모듈 시스템
패키지 관리 도구
개발 도구 및 유틸리티
설정 및 환경 파일이 존재합니다.

3. Python3 패키지 설치

1. 소스 준비 및 이동 (lfs 유저)

cd $LFS/sources
tar -xvf Python-3.14.2.tar.xz 
cd Python-3.14.2

2. 설정 (Configure)

./configure --prefix=/usr   \
            --enable-shared \
            --without-ensurepip

--without-ensurepip는 임시 빌드 단계에서 복잡한 패키지 관리자(pip) 설치를 생략하여 빌드 시간을 단축하고 의존성 문제를 방지하기 위함

3. 컴파일 및 설치

make
make DESTDIR=$LFS install

4. 뒷정리

cd $LFS/sources
rm -rf Python-3.14.2

5. 테스트

python3 --version #설치가 잘 됐는지 확인
python3 -c "print('hello')"

[그림1] Python3 설치 테스트

[LFS13] Perl 패키지 빌드

sik13579 — Tue, 21 Apr 2026 15:47:22 +0900

1. Perl 패키지 역할

LFS에서 perl 패키지의 역할은 단순한 언어가 아니라, 시스템 빌드와 테스트를 지원하는 핵심 도구입니다.

주요 역할은 아래와 같습니다.

빌드 지원(Build Support)
- configure, make 과정에서 Perl 스크립트 실행
- 자동화된 빌드 절차 수행
- 예:
  - 일부 패키지의 configure 단계에서 perl 필요
테스트 자동화(Test Suite 실행)
- make check 수행 시 Perl 기반 테스트 실행
- 빌드된 프로그램의 정상 동작 검증
- LFS에서 "정상 시스템" 만들려면 테스트 통과가 핵심
텍스트 처리 및 스크립팅
- 로그 분석, 문자열 처리, 파일 파싱
- 빌드 과정 중 데이터 가공
- 정규표현식(regex) 처리에 매우 강함

2. Perl 패키지의 구성

LFS에서 설치되는 Perl 패키지는 단순 실행파일이 아닌, 완전한 스크립트 실행 환경으로 구성됩니다.

주요 구성 요소는 아래와 같습니다.

Perl 인터프리터
- perl 실행 파일
- Perl 스크립트를 실행하는 핵심 엔진
표준 라이브러리(Core Modules)
- 기본 제공 모듈 집합
- 별도 설치 없이 바로 사용 가능
- 예:
  - 파일 처리
  - 문자열 처리
  - 시스템 제어
CPAN 기반 모듈 구조
- Perl 패키지 확장 구조
- 필요 시 추가 모듈 설치 가능
- 모듈 단위로 기능 확장
유틸리티 및 빌드 도구
- Perl 관련 스크립트 도구 포함
- 일부 패키지 빌드/테스트에 사용

3. Perl 패키지 빌드

1. 소스 준비 및 이동 (lfs 유저)

cd $LFS/sources
tar -xvf perl-5.42.0.tar.xz 
cd perl-5.42.0

2. 설정 (Configure)

sh Configure -des                                        \
             -Dprefix=/usr                               \
             -Dvendorprefix=/usr                         \
             -Duseshrplib                                \
             -Dprivlib=/usr/lib/perl5/5.38/core_perl     \
             -Darchlib=/usr/lib/perl5/5.38/core_perl     \
             -Dsitelib=/usr/lib/perl5/5.38/site_perl     \
             -Dsitearch=/usr/lib/perl5/5.38/site_perl    \
             -Dvendorlib=/usr/lib/perl5/5.38/vendor_perl \
             -Dvendorarch=/usr/lib/perl5/5.38/vendor_perl

다른 패키지들과는 조금 다르게 복잡한 설정을 가지고있습니다.

Perl을 /usr기준으로 설치하고, 코어 모듈/사이트 모듈/벤터 모듈은 각각 이경로에 넣으라고 설정하는 것입니다.

명령어가 의미하는 바는 아래와 같습니다.

sh Configure

Perl 패키지의 설정 스크립트를 실행
현재 시스템을 검사하고
Makefile같은 빌드 설정을 생성함

-des

질문하지 말고, 기본값 위주로, 자동으로 설정 진행

3. 컴파일 및 설치

make
make DESTDIR=$LFS install

4. 뒷정리

cd $LFS/sources
rm -rf perl-5.42.0

5. 테스트

perl -v

[그림1] 정상 설치된 모습

which perl #실행 경로 확인

[그림2] 정상적인 경로

perl -e 'print "Perl OK\n";' #간단한 Perl 코드 실행 테스트

[그림3] 테스트 출력 이상없음

이진탐색트리(Binary Search Tree) - 삭제 연산

sik13579 — Mon, 20 Apr 2026 15:38:03 +0900

이진탐색트리의 핵심은 정렬된 상태를 유지하면서 빠르게 탐색하는것 입니다.

배열은 정렬하면 탐색은 빠르지만 삽입/삭제가 느리고, 리스트는 삽입은 빠르지만 탐색이 느립니다.

이 이진탐색트리는 그 중간을 노린 구조입니다.

대표적인 활용케이스는

1. 검색 시스템

값 찾기 : O(log n)
예 : 사용자 ID, 세션, 키-값 조회
내부적으로는 Redis 같은 시스템도 트리/해시 기반 구조를 섞여 사용합니다.

2. 정렬된 데이터 유지

항상 왼쪽< 부모 < 오른쪽
중위 순회(inorder)하면 자동 정렬
예:
- 로그 시간순 정렬
- 점수 랭킹 시스템

3. 범위 검색(Range Query)

10이상 50이하 데이터만 뽑고싶을때
BST는 이런 범위 탐색이 효율적
DB 인덱스에서 핵심 개념

즉, 삽입/삭제/탐색을 모두 적당히 빠르게 처리하면서 정렬 상태를 유지해야 할 때 사용하게되는 구조입니다.

아래 그림을 보면서 이해해 봅시다.

[그림1]

[그림1]삭제하고 싶은 노드를 x, x의 자식인 왼쪽 subtree를 a, 오른쪽 subtree를 b라고 칭했을때

x자리에 a subtree를 올리고, a subtree에서 maxnode(가장 높은값을 가진 노드)아래에 b subtree를 붙입니다.

[그림2]

따라서 위 [그림2]와 같은 형태가 되어야합니다.

이것을 Python을 이용하여 구현하면 아래와 같습니다.

class Node:  
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None
        self.parent = None

class BST:
    def __init__(self):
        self.root = None

    def deleteByMerging(self, x):
        a = x.left
        b = x.right
        pt = x.parent

        if a != None:
            c = a
            m = a
            while m.right != None:
                m = m.right
            m.right = b
            if b != None:
                b.parent = m
        else:
            c = b

        if c != None:
            c.parent = pt

        if pt != None:
            if pt.left == x:
                pt.left = c
            else:
                pt.right = c
        else:
            self.root = c
            if c != None:
                c.parent = None

트리 - 힙 insert 연산

sik13579 — Tue, 14 Apr 2026 14:55:44 +0900

1. 힙 이란?(다시 한 번 짚고 넘어가자)

힙은 완전이진트리 형태를 가지면서, 동시에 부모와 자식 사이의 대소관계를 만족하는 자료구조 이다.

따라서, 부모가 자식보다 크기만 하다고 해서 다 힙은 아니다.

예를 들어보자.

이건 완전이진트리라서 힙이 될 수 있다.

이건 부모-자식 크기 관계는 맞아도, 완전이진트리 모양이 아니므로 힙이 아니다.

왜냐하면, 왼쪽 자식의 왼쪽이 비었는데 오른쪽이 차 있으므로, 힙이 아니다.

2. insert 연산 과정

step1. 초기 상태 array = [ 5, 7, 9, 10, 8, 6 ]에서 make_heap()으로 정렬한다.

[그림1]최대 힙 상태의 트리

step2. 마지막 위치에 insert 배열은 array = [10, 8, 9, 7, 5, 6, 14] 상태가 된다.

[그림2] 맨 뒤에 append

step3. heapify_up 시작(핵심), 기준은 부모보다 크면 위로 올라간다

[그림3] 아래서 부터 위로 heapify_up

최종. 결과

[그림4] 최종 결과이다.

3. insert 연산 핵심

insert는 항상 마지막 위치에 삽입한다.
부모와 비교하면서 위로 올라간다(heapify_up)
부모보다 작아지는 순간 멈춘다.

4. heapify_up 핵심

자식끼리 비교하지 않는다.
형제랑 비교하지 않는다.
전체 탐색 하지 않는다.
오직, 현재 노드와 부모 노드만 비교한다.

5. Python으로 구현

class MaxHeap:
    def __init__(self):
        self.array = [] #빈 배열 생성
        
    def heapify_up(self, k):
        while (k > 0) and (self.array[(k - 1 ) // 2] < self.array[k]):
            self.array[k], self.array[(k - 1) // 2] = self.array[(k - 1) // 2], self.array[k]
            k = (k - 1) // 2
            
    def insert(self, k):
        self.array.append(k) 
        self.heapify_up(len(self.array) - 1)

트리(tree)란?

sik13579 — Thu, 9 Apr 2026 20:22:54 +0900

1. 트리(Tree)

여태까지 봤던 배열, 스택, 큐, 연결 리스트는 대부분 선형 구조이다. 즉 "앞 - 뒤"로 이어지는 구조였음
그런데 트리는 다르게, 계층적 관계를 표현하는 비선형 자료구조이다. 예를 들면 폴더 구조, 조직도, 가족관계, HTML DOM 구조 같은 것을 표현할 때 트리가 잘 맞는다. 트리는 노드와 간선으로 이루어지고, 보통 하나의 루트에서 아래로 가지가 뻗는 형태로 설명된다.

2. 트리는 왜 필요할까?

학생 명단을 저장하는 건 배열로도 가능하다.
하지만 "학과장 아래 교수들, 교수 아래 조교들, 조교 아래 학생들" 처럼 상하관계가 있으면 배열은 불편하다.
연결 리스트도 한 줄로만 이어지기 때문에 "누가 누구 밑에 있는가"를 표현하기엔 한계가 있다.
트리는 바로 이런 부모-자식 관계, 즉 계층 구조를 표현하려고 쓰는 자료구조이다.

3. 트리의 가장 중요한 구성요소

여기서

A : 루트 노드(root node)
B, C, D : A의 자식 노드(child)
A : B, C, D의 부모 노드(parent)
E, F : B의 자식
E, F, G, C : 자식이 없으면 리프 노드(leaf node, 단말 노드)

트리는 일반적으로 이런 용어들을 사용해 설명한다 : 루트, 부모, 자식, 형제, 리프, 서브트리, 레벨, 높이. 이런 용어들이 트리 이해의 기본

[그림1] 트리의 구조

4. 핵심 용어

루트(root)
트리의 맨 위에 있는 시작점
부모가 없는 유일한 노드다. 보통 트리는 하나의 루트를 가진다고 설명한다.
부모(parent) / 자식(child)
A 밑에 B가 있으면, A는 B의 부모, B는 A의 자식이다. 이 관계가 트리의 핵심
형제(sibling)
같은 부모를 가지는 노드들, 예를 들어 B, C, D는 형제다.
리프(leaf)
자식이 하나도 없는 노드. 말단 노드라고도 불른다. E, F, C, G 같은 애들이다.
서브트리(subtree)
트리 안의 작은 트리라고 생각하면 된다. 예를 들어, B를 루트로 보고 E, F를 포함하면 그 자체가 하나의 서브트리가 된다.
레벨(level)
층 수 라고 생각하면 쉽다. A가 0level, 그 아래가 한 단계씩 내려간다. 교재마다 루트를 0으로 보기도 하고 1로 보기도 해서 기준만 일관되면 된다.
높이(height)
트리의 최대 깊이. 루트에서 가장 깊은 리프까지 몇 단계 내려가는지 보는 개념이다.
링크(Link, Edge)
트리를 구성하는 노드와 노드 사이를 연결하는 선(Line)

5. 트리의 특징

트리는 "사이클이 없는 연결 구조다"
즉, 아래로 내려가다가 다시 자기 자신으로 돌아오는 고리가 없다.
그래서 계층 구조를 표현하기 좋다. 일반적인 설명에서는 트리를 사이클이 없는 연결 그래프의 한 종류로 보기도 한다.

그리고, 보통 한 노드는 부모를 하나만 가진다.
자식은 여러 명일 수 있지만, 부모는 하나라는 게 포인트이다. 그래야 "상하관계"가 깔끔하게 유지된다.

6. 선형 구조와 비교

배열 / 연결 리스트

앞뒤 순서 표현에는 좋다.
계층 구조 표현은 불편하다.

트리

상하 관계 표현에 강하다
탐색 방향이 여러 갈래로 갈 수 있다.
비선형 구조이다.

즉, 배열은 "줄 세우기", 트리는 "조직도 만들기"라고 생각하면 된다.

7.예시로 이해하기

폴더 구조
C:
│─ Users
│ ├─ CAT
│ └─ Public
└─ Program Files
완전한 트리 구조를 가진 형태이다. 상위 폴더 밑에 하위 폴더, 그 밑에 파일이나 폴더가 또 생긴다.
실제로 트리는 디렉터리 구조를 설명할 때 대표적으로 등장한다.
조직도
대표 → 팀장 → 팀원 이것도 트리이다.
HTML 문서 구조
html 아래 head, body 그 아래 div, p , span 이런 것도 트리 구조로 볼 수 있다. 즉, 트리는 컴퓨터 안에서 엄청 자주 나온다.

8. 마무리 정리

트리(Tree)는 노드와 간선으로 이루어진 비선형 자료구조이며, 부모-자식 관계를 통해 계층적인 데이터를 표현하는 데 적합하다. 루트, 부모, 자식, 형제, 리프, 서브트리, 레벨, 높이 같은 기본 용어를 정확히 이해하는 것이 중요하고, 폴더 구조나 조직도처럼 상하 관계가 있는 데이터를 다룰 때 매우 유용하다. 또한 트리는 사이클이 없고, 일반적으로 각 노드는 하나의 부모만 가진다는 특징을 가진다.

트리 - 힙 make_heap 연산

sik13579 — Thu, 9 Apr 2026 20:13:34 +0900

1.make_heap이 무엇인가?

make_heap은 힙이 아닌 배열(또는 완전이진트리 형태의 데이터)을 힙 성질을 만족하도록 바꾸는 연산이다.
이 과정을 부모-자식 비교를 통해 재배치하는것. 보통 heapify_down을 반복해서 수행한다

A = [3, 8, 2, 5, 1, 7, 6] 이런 형태의 배열이 있다고 해보자.
이건 그냥 배열이지, 아직 힙이라는 보장은 없다. 이걸 최대 힙 또는 최소 힙 조건에 맞게 다시 정리하는게 make_heap이다.

2. 왜 make_heap이 필요할까?

힙은 보통 우선순위 큐에 쓰이는데, 처음부터 데이터가 힙 상태로 들어오는게 아니라 그냥 막 들어온 배열인 경우가 많다.
그럴 때 이 전체 데이터를 한 번에 힙 구조로 바꿔야 이후 find_max, delete_max, insert 같은 연산을 효율적으로 할 수 있다.

3. make_heap은 위에서부터가 아니라 아래서부터 고친다.

이게 제일 핵심이다. make_heap은 보통 아래쪽 내부 노드부터 시작해서 위로 올라오면서 고친다.
heapify_down을 이용해 배열을 힙으로 만들고, 각 부모 노드에 대해 아래로 내려가며 재배치하는 방식이다.
왜 아래에서부터 해야하는가?
부모를 고치려면 자식 쪽이 어느 정도 정리돼 있어야 하기 때문이다.
그래야 부모가 내려갈 위치를 올바르게 결정할 수 있다.

이걸 다른식으로 말하면 리프(leaf)는 이미 힙이다.
예를 들어 값이 8 하나만 있는 노드가 있다면, 그 노드는 최소 힙이냐 최대 힙이냐를 따질 필요도 없이 이미 조건을 어기지 않는다.
그래서 make_heap은 이렇게 생각하면 된다.

맨아래 노드들은 이미 괜찮다.
그 부모를 본다.
부모가 자식들과의 관계를 어기면 자리를 바꾼다.
그걸 한 층씩 위로 올라가며 반복한다.
마지막에 루트까지 정리되면 전체가 힙이 된다.

즉 "작은 부분부터 힙으로 만들고, 그걸 합쳐서 전체 힙을 만든다."

4. heapify_down이 뭔가?

heapify_down은 어떤 노드 하나가 힙 성질을 어겼을 때, 그 노드를 아래로 내려 보내면서 제자리 찾게하는 연산이다.

최대 힙 기준으로 설명해보자면
어떤 부모 노드가 있는데, 그 자식들보다 값이 작다? 그럼 최대 힙 조건을 어긴 것이다.
이때는 그 부모를 아래로 내려보내야 한다.
방법은 아래와 같다.

왼쪽 자식, 오른쪽 자식 중 더 큰 자식을 찾는다.
부모와 비교한다.
부모가 더 작으면 더 큰 자식과 자리를 바꾼다.
바꾼 뒤, 부모가 내려간 그 자리에서 다시 같은 작업을 반복한다.

즉, 부모가 자기보다 더 강한 자식을 만나면 계속 아래로 밀려나는 거다.

5. 예제 (miro를 통해 작성해보자)

배열 A = [4, 1, 7, 3, 8, 5]
완전이진트리로 보면 아래의 형태와 같다.

이 상태에서 최대 힙으로 만들고 싶다. 최대 힙이면 부모가 자식보다 커야 한다.
그런데 지금 보면

1의 자식이 3,8이다.
1은 8보다 작다

즉, 여기서 이미 힙 조건이 깨져 있다.

아래 그림으로 heapify_down 연산 이해해 보자

[그림1] heapify_down 연산

6.make_heap의 본질

make_heap은 단순히 "바꾸는 기술"이 아니다.

사고 방식이 있는데 그것은
"큰 문제를 한 번에 해결하지 말고, 아래쪽은 작은 부분부터 힙으로 만든 다음, 그것을 위로 합쳐라."

즉,

리프는 이미 힙
리프의 부모를 힙으로 만듦
그 위 부모를 힙으로 만듦
결국 루트까지 올라가면서 전체가 힙

이런 구조이다.
그래서 make_heap은 bottom-up 방식 이라고 부른다.

아래에서, 최대 힙을 어떻게 구현했는가 확인할 수 있다.

class Maxheap:
    def __init__(self):
        self.array = [] 

    def heapify_down(self, k, n): 
        while 2 * k + 1 < n: 
            left = 2 * k + 1 
            right = 2 * k + 2 
            larger = left 

            if right < n and self.array[right] > self.array[left]:
                larger = right 

            if self.array[k] >= self.array[larger]: 
                break 

            self.array[k], self.array[larger] = self.array[larger], self.array[k] 
            k = larger 
    
    def make_heap(self):
        n = len(self.array)
        for k in range((n - 2) // 2, -1, -1): 
            self.heapify_down(k, n)

#최대 힙 예시
H = Maxheap()
H.array = [7, 4, 5, 3, 8, 9]
H.make_heap()
print(H.array) # [9, 8, 7, 3, 4, 5] 최대 힙 형태로 바뀌었음

연결 리스트 - 환형 연결 리스트(Circular Linked List)

sik13579 — Wed, 8 Apr 2026 01:42:56 +0900

환형 연결 리스트의 경우에는 노드 하나가 head와 tail을 동시에 갖고 있는 구조입니다.

class Node: # 환형 연결 리스트의 노드 정의 노드가 head와 tail이 동시에 존재함 
    def __init__(self, data=None):
        self.data = data
        self.next = self
        self.prev = self

따라서, 위와 같이 노드를 정의해줍니다.

환형 연결 리스트에서는 제일 중요한 파트가 splice 연산입니다.

조건은 아래와 같습니다.

조건 1. a ->... -> b a와 b사이에 값이 존재해야 함

조건 2. a와 b사이에 head 노드가 없어야 함, 마찬가지로 a와 b사이에 x노드가 있으면 안 된다.

a와 b사이에 있는 만큼을 cut 해서 어딘가에 위치한 노드 x 그리고 노드 xn(x.next)사이로 붙여 넣는

Splice(a, b, x)를 하면 ap노드의 다음이 bn이된다(cut되서 a와 b노드가 나갔기 때문)
x노드의 xn은 a노드가 되고 ... 를거쳐 b 그리고 bn은 xn이 된다 총 6개의 링크가 바뀐다.

ㅇSplice 연산을 그림으로 표현해 보았습니다.

보시는 바와 같이 splice 연산은 6번의 링크가 바뀌기 때문에 O(1)으로 표기합니다.

다음은 , 환형 연결 리스트에서 search를 그림으로 시각화해보았습니다.

환형 연결 리스트의 search 메서드 시각화

환형 연결 리스트에서 탐색을 하는 것은 매우 비효율적입니다.
더미 노드 다음인 head 노드부터 시작하여 끝까지 탐색을 데이터가 n개라 했을 때 결국 시간복잡도는 O(n)이 되어 비효율적이게 됩니다. 만약, 노드가 없으면 다시 head로 돌아오고, 해당 head로 돌아오면 None을 반환합니다.

다음은, 환형 연결 리스트에서 remove를 그림으로 시각화해보았습니다.

환형 연결 리스트 remove를 시각화

환형 연결 리스트를 구현해 보았습니다.

class Node: # 환형 연결 리스트의 노드 정의 노드가 head와 tail이 동시에 존재함 
    def __init__(self, data=None):
        self.data = data
        self.next = self
        self.prev = self
    
class CircularLinkedList:
    def __init__(self):
        self.head = Node()
        self.size = 0
    
    def __len__(self):
        return self.size
    
    def __str__(self):
        if len(self) == 0:
            return "비어있음"
        return " <-> ".join(str(v.data) for v in self) 

    def __iter__(self): #환형이라서 계속 돌기때문에 None처리하지말고, head로 다시 돌아오면 종료되는 구조
        v = self.head.next
        while v != self.head:
            yield v #이것이 핵심 이게 있어야 제너레이터임 여기서 yield는 값을 호출한 쪽으로 넘겨주고, 함수의 실행 상태를 저장한 채 잠시 멈춘다.
            v = v.next 

    def splice(self, a, b, x): #splice 연산 3개의 노드 a,b,x 매우 중요 ***O(1)***
        #조건 1: a -> ... -> b
        #조건 2: a와 b 사이에 head노드가 없어야함, 마찬가지로 a와 b사이에 x노드가 있으면 안된다.
        #a와 b사이에 있는 만큼을 cut해서 어딘가에 위치한 노드x 그리고 노드 xn(x.next)사이로 붙여넣는다
        #Splice(a,b,x)를 하면 ap노드의 다음이 bn이된다(cut되서 a와 b노드가 나갔기때문)
        #x노드의 xn은 a노드가 되고 ... 을거쳐 b 그리고 bn은 xn이된다 총 6개의 링크가 바뀐다.
        
        ap, bn, xn = a.prev, b.next, x.next
        
        # cut
        ap.next = bn 
        bn.prev = ap 
        
        # paste
        x.next = a 
        a.prev = x
        b.next = xn
        xn.prev = b

    def move_after(self, a, x): #노드 a를 노드 x 다음으로 이동  O(1)
        self.splice(a, a, x) #splice연산 a에서 a까지 x다음으로 
    
    def move_before(self, a, x):  # O(1)
        self.splice(a, a, x.prev)

    def insert_after(self, x, data): #O(1)
        self.move_after(Node(data), x) #data(값)을 가진 노드하나 생성하고 x 다음으로 moveafter하고, splice(a,a,x)진행
        self.size += 1

    def insert_before(self, x, data): #O(1)
        self.move_before(Node(data), x)
        self.size += 1

    def push_front(self, data): #O(1)
        self.insert_after(self.head, data) #data값을 만들어서 self.head 다음에 집어 넣어라

    def push_back(self, data): #O(1)
        self.insert_before(self.head, data)

    def search(self, data):  # O(n)
        for v in self: # __iter__() 이용하여 yield v로 하나씩 노드를 넘겨주는 for문 
            if v.data == data: # 현재 보고 있는 노드 v의 데이터 값이, 내가 찾고 싶은 data와 같은가?
                return v
        return None
        #v = self.head.next # dummy노드 다음부터 시작
        #while v != self.head: # None이 아닌 head로 돌아오면 
        #    if v.data == data:
        #        return v
        #    v = v.next
        #return None
    
    def remove(self, x): # O(1)
        if x == None or x == self.head:
            return
        x.prev.next = x.next
        x.next.prev = x.prev
        self.size -= 1

    def pop_front(self): # O(1)
        self.remove(self.head.next)

    def pop_back(self): #O(1)
        self.remove(self.head.prev)

환형 연결 리스트의 경우에 평균이나 최악의 경우에도 삽입과 삭제는 O(1) 상수 시간이라 매우 효율적입니다.

하지만, 접근과 탐색에 있어서는 O(n) 매우 비효율적입니다.
따라서 환형 연결 리스트는 순차적인 순환 처리나 반복 구조와 같이 특정 위치를 빠르게 삽입/삭제해야 하는 상황에서 강점을 가지며, 탐색보다는 구조적인 흐름 제어에 적합한 자료구조라고 할 수 있습니다.