혜머니

[차크라 명상] 차크라 명상의 이론과 실습

혜머니 — Tue, 2 Jun 2026 01:00:49 +0900

1. 소개

- 차크라 명상 : 고대 인도와 티베트의 명상법에 토대를 둔 것

- 차크라들은 만뜨라, 향, 아사나, 얀뜨라에 반응하는 우리 몸 안에 있는 에너지 센터

- 본 명상을 통해 꾼달리니라고 불리는 잔재적 영적 에너지가 꺠어나 차크라를 따라 흐르게 되며, 이를 통해 고차적인 인간 의식의 차원이 열리게 됨

2. 준비

(1) 명상좌로 앉기

(2) 편안한 마음으로 눈 감기

(3) 약 7회 심호흡하기

(4) 각 차크라의 이름이 낭송될 때 그 부위에 마음 집중하기

(5) 각 차크라의 비자 만뜨라 7회 낭송하기

(6) 꾼달리니 아로하남 이라는 7번의 멘트를 듣거나 함께 찬팅할 때 각 차크라 부위를 가득 채운 빝나는 황금물을 시각화하기

(7) 다음 차크라 낭송 시, 해당 차크라로 주의 이동하기

(8) 각 차크라에 대하여 동일한 방법으로 실시

(9) 한 차크라에서 다음 차크라로 주의를 옮길 때 빛나는 황금물로 끊어지지 않은 채로 옮겨갈 수 있도록 하기

(10) 사하스라라에서 머리를 완전히 가득 채우고 마치 샘물처럼 머리의 중심에서 분출하는 꾼달리니를 시각화하고 느끼기

> 이와 같은 명상 상태를 한 동안 유지한 후에 천천히 사와사나로 누워 신체의 각 부위에 활기를 불어넣는 꾼달리니 에너지 자각하기

> 옴 (차크라) > 비자 만뜨라 * 7 > 옴 꾼달리니 아로하남

차크라	위치	의미	비자만뜨라
물라다라	회음	토대, 뿌리	Lam(랑)
스와디슈타나	성기	자아의 거주지	Vam(방)
마니뿌라	배꼽부위	보석의 도시	Ram(랑)
아나하타	심장부위	두드리지 않은	Yam(양)
비슛다	목	순수	Ham(항)
아갸	양 미간	명령, 지시	Aum(옴)
사하스라라	정수리	천개의 꽃잎	옴 샤띠얌 옴

[시스템 프로그래밍 Linux] 네트워크 설정

혜머니 — Mon, 1 Jun 2026 00:27:15 +0900

1. 네트워크 기초

(1) TCP/IP 프로토콜과 MAC 주소

- 프로토콜 : 컴퓨터와 컴퓨터 사이에 데이터를 어떻게 주고받을 것인지를 정의한 통신 규약

- 같은 프로토콜을 사용하는 기기 간에는 통신이 가능함

응용/표현/세션 계층	- TCP/IP 프로토콜은 5계층으로 구성됨 - 계층별로 수행하는 역할이 구분됨 - 계층별로 다양한 서비스를 제공하는 프로토콜이 지원됨 - TCP/IP 프로토콜은 다양한 프로토콜의 집합임 이 중 전송 계층의 TCP와 네트워크 계층의 IP로 전체 프로토콜을 대표하여 TCP/IP 프로토콜이라 일컬음
전송 계층
네트워크 계층
링크 계층
물리 계층

계층	기능	프로토콜	전송 단위
응용 계층	서비스 제공 응용 프로그램	DNS, FTP, HTTP, SSH, TELNET	메세지
전송 계층	응용 프로그램으로 데이터 전달, 데이터 흐름 제어 및 전송 신뢰성 담당	TCP, UDP	세그먼트
네트워크 계층	주소 관리 및 경로 탐색	IP, CMP	패킷
링크 계층	네트워크 장치 드라이버	ARP	프레임
물리 계층	케이블 등 전송 매체	구리선, 광케이블, 무선	비트

- MAC : Media Access Control의 약자

- MAC 주소 : 하드웨어를 위한 주소, 이더넷 주소, 하드웨어 주소, 물리 주소라고도 함

- MAC 주소는 각 하드웨어를 구별하는 역할을 수행함

- 네트워크 인터페이스 카드(랜카드)에 저장된 주소라고 생각하면 됨

- MAC 주소는 네트워크 인터페이스 카드가 만들어질 때 부여

- 원칙적으로 수정 불가, 일부 네트워크 인터페이스 카드의 경우 사용자가 MAC 주소를 수정할 수 있도록 허용

- 특별한 경우가 아니면 수정하지 않는 것이 좋음

- MAC 주소는 :이나 -으로 구분되는 여섯개의 16진수로 구성 (48bit)

- 앞의 세자리는 제조사 번호이고, 뒤의 세자리는 일련번호임

- 제조사 번호는 국제 표준 기구인 IEEE에서 지정 : MAC 주소로 제조사 확인 가능

(2) IP 주소

- IP 주소 = 네트워크 주소 + 호스트 주소

- 컴퓨터가 인터넷에 연결되려면 IP 주소가 할당되어 있어야 함

- 우리가 보통 인터넷 주소라고 부르는 것이 IP (internet Protocol) 주소임

- IP 주소는 인터넷으로 연결된 네트워크에서 각 컴퓨터를 구분하기 위해 사용됨

- IP 주소는 1 바이트 크기의 네 개 숫자로 구성되며 총 4바이트임

- TCP/IP 프로토콜의 3~5 계층은 IP 주소를 사용함

- IP 주소는 네트워크를 구분하는 네트워크 주소 부분과 해당 네트워크 안에서 특정 컴퓨터를 식별하는 호스트 주소 부분으로 나뉨

- 총 32B(4B) 중 몇 비트를 네트워크 부분으로 사용하고 나머지 몇 비트를 호스트 부분으로 사용하는지에 따라 A/B/C 클라스로 구분

- 이 가운데 주로 접하게 되는 C 클라스는 앞의 3바이트가 네트워크 부분이고 1바이트만 호스트 부분임

- 호스트 부분으로 사용할 수 있는 숫자는 0~255임

- 0은 네트워크 주소를 나타내는데 사용하고 255는 브로드 캐스트 주소로 사용함

- 1~254를 호스트 주소로 할당할 수 있음

- 192.168.100.5 같은 형식의 IP 주소를 IPv4(IP 버전 4)라고 하는데, 이 주소는 고갈되어 더 이상 새로운 주소를 할당받을 수 없음

- 이를 대체하기 위해 개발된 주소는 IPv6(IP 버전 6)

- 넷마스크 : IP 주소에서 네트워크 부분을 알려주는 역할을 함, 하나의 네트워크를 작은 네트워크(서브넷)으로 분리할 때도 사용하므로 서브넷 마스크라고 부르기도 함

- C 클래스 IP 주소의 경우 기본 넷 마스크가 255.255.255.0

- IP 주소와 넷 마스크를 10진수에서 2진수로 바꾼 다음 두 값을 가지고 AND 연산을 수행

- 네트워크 부분만 남고 호스트 부분은 0이 됨

- 넷마스크 : IP 주소와 AND 연산을 수행하여 네트워크 부분만 남기는 역할

- 브로드캐스트 주소 : 같은 네트워크에 있는 모든 컴퓨터에 메세지를 보낼 때 사용하는 것으로 호스트 부분을 모두 1로 설정함

- 컴퓨터가 인터넷에 연결하려면 IP 주소가 있어야하며, 이 주소를 사용하여 메일도 보내고 웹 사이트에 접속함

- 컴퓨터는 숫자를 이해하지만 사람은 문자나 이름을 더 잘 기억하므로 호스트 이름이 등장함

- 호스트 이름도 IP 주소처럼 2부분으로 구성됨

- 네이버 호스트 이름 : www.naver.com (www = 호스트 부분) (naver.com = 네트워크 부분)

- 개인용 PC는 호스트 이름을 붙일 필요가 없음

- 웹 서버와 같이 네트워크 서비스를 제공하는 서버 컴퓨터는 용도에 따라 호스트 이름을 붙여서 사용해야 함

- 포트 번호 : 보통 주소에 포한되지 않지만 각 서비스를 구분하는 번호

- 사용자가 네트워크 서비스를 이용할 때 사용자 패킷은 IP 주소를 보고 해당 서버 컴퓨터를 찾아감

- 서버 컴퓨터에 도착한 사용자 패킷은 어떤 서비스를 요청했는지 확인한 다름 해당 데몬에 패킷을 전달함

- 웹 서비스를 요청했다면 웹 서버 데몬(httpd)에 전달하는 것 > 사용자가 어떤 서비스를 요청했는지 구분해주는 것이 포트 번호

- TCP/IP 프로토콜의 4계층인 전송 계층에서 사용하는 것이 포트 번호, 전송 계층이 하는 일은 해당 프로그램에 데이터가 정호가하게 전달되도록 하는 것

- 포트 번호 보는 법 : /etc/services 파일의 역할은 서비스별로 포트 번호가 무엇인지 정의하는 것

- /etc/services 파일에 저장된 포트 번호는 국제 표준의 포트 번호임

- 사용자가 개발한 네트워크 프로그램은 이 파일에 정의되지 않은 번호를 사용하여 서비스를 제공할 수 있음

2. 네트워크 설정

(1) 네트워크 설정하기

- 네트워크 사용하기 위해 설정해야할 주소 : IP, 넷마크스와 브로드캐스트 주소, 게이트웨이 주소, DNS 주소

- 사용자가 임의로 설정하여 사용할 수 있는 것이 아님

- 반드시 해당 기관의 네트워크 관리자에게 문의하여 정확한 주소를 받아야 함

- 하나라도 틀리면 네트워크 연결에 문제가 밸상할 수 있기 때문

- 네트워크 관리자가 네트워킹 서비스를 제공함

- 네트워크 관리자는 네트워크 제어와 설정을 관리하는 데몬

- 네트워크 관리자를 사용하여 IP 주소 설정, 고정 라우터, DNS 설정 등을 수행할 수 있음

- nmcli 명령 : 네트워크 관리자를 사용하는 명령 기반 도구

- [설정]-[네트워크] : 그놈에서 제공하는 GUI 기반 도구

- nm-connection-editor : 네트워크 관리자를 사용하는 GUI 기반 도구, [제어판]-[네트워크]에서 설정할 수 없는 부분도 설정 가능

- ip 명령 : 네트워크를 설정하는 명령을 제공

- 네트워크 관리자는 로키 리눅스 설치 시 기본적으로 설치됨

- 설치되지 않은 경우는 dnf 명령으로 설치됨

- 네트워크 관리자는 시스템이 부팅될 때 자동으로 동작함

- 네트워크 관리자가 동작하고 있는지 systemctl status 명령으로 확인 가능

- 만약 네트워크 관리자 상태가 inactive 상태라면 다음 명령으로 동작시킴

: systemctl start NetworkManager

- 시스템이 부팅될 때 네트워크 관리자가 동작하게 하려면 다음과 같이 enable 명령을 실행 함

: systemctl enable NetworkManager

- 네트워크 관리자는 네트워크 설정 정보를 연결 프로파일에 저장함

- 사용자는 네트워크 관리자를 직접 제어하지 않고, 명령 기반 도구나 GUI 기반 도구를 사용함

- nmcli은 네트워크 관리자를 사용하는 명령 기반 도구임

- 그놈의 [설정]-[네트워크]나 nmconnection-editor는 GUI 기반 도구임

- 이러한 도구를 사용하여 네트워크 설정을 변경하면 네트워크 관리자가 자동으로 인식함

- ip 명령으로도 네트워크를 설정할 수 있지만, 이 명령으로 네트워크 설정을 변경하면 네트워크 관리자가 자동으로 인식하지 못함

- 그놈 : 윈도의 제어판 처럼 시스템과 네트워크 설정을 위한 기능을 제공

(2) nmcli 명령 : nmcli [옵션] [명령] [서브 명령]

- nmcli 명령은 네트워크를 설정하는 명령은 네트워크 관리자와 함께 설치됨

- nmcli 명령으로 유선 네트워크 뿐 아니라 와이파이 등의 무선 네트워크 보안 등 네트워크와 관련된 거의 모든 설정을 관리할 수 있음

- nmcli는 명령행에서 사용하는 명령은 물론이고 대화식 인터페이스도 제공함

* -t 실행 결과를 간단하게 출력

* -p 사용자가 읽기 좋게 출력

* -v nmcli의 버전을 출력

* -h 도움말 출력

[명령] [서브 명령]

[general] [status|hostname] 네트워크 관리자가 전체적인 상태를 출력하고, 호스트명을 읽거나 변경 가능

- 네트워크의 전체적인 상태는 nmcli의 general 명령으로 확인 가능

- nmcli를 사용할 때 명령을 줄여서 사용할 수 있음

- general 대신 gen만 입력해도됨 (status없어도 같은 결과 출력)

[networking] [on|off|connectivity] 네트워크를 시작, 종료하고 연결 상태를 출력함

- connextivity : 서브 명령으로 네트워크 연결 상태를 알려줌

> 출력 : none(없음) limited(연결되어있지만 인터넷 연결되지 않음) full(네트워크 연결됨 인터넷 사용 가능) unknown(알 수 없음)

- show : 메모리와 디스크에 저장된 네트워크 연결 프로파일을 출력함, 거브 명령을 지정하지 않으면 기본값이 show임

> 출력 : 이름, UUID, 유형, 연결 장치 이름

- up : 네트워크 연결 시작

- down : 네트워크 연결 중지

- modify : 연결 프로파일에서 속성을 추가, 수정, 삭제함

- 추가 시 +, 삭제 시 -로 진행 수정은 미사용

- add : 새로운 연결 생성

- 동적 IP 연결 : nmcli connection add type ethernet con-name connection-name ifname interface-name

- delete : 연결 설정 삭제

- reload : 연결과 관련된 파일을 디스크에서 다시 읽어옴

- load : 디스크에서 하나 이상의 연결 파일을 읽어옴

[device] [status|show] 네트워크 장치의 상태를 출력함

(3) ip 명령 : ip [옵션] [객체] [서브 명령]

- ip 명령을 사용하여 네트워크 상태 확인, IP 주소 설정, 게이트 웨이 설정 가능

- ip 명령으로 설정한 것은 시스템을 재시작하면 사라짐

- 시스템을 다시 시작한 후에도 설정한 내용이 적용되게 하려면 설정 파일을 수정해야 함

* -V 버전 출력

* -s 자세한 정보 출력

[address] [add|del|show|help] : 장치의 IP 주소 관리

- show 출력 > link/ether(이더넷 주소), inet(IPv4 주소), inet6(IPv6 주소)

[route] [add|del|help] : 라우팅 테이블 관리(ip-route)

- 인터넷은 네트워크와 네트워크를 연결한 것, 연결점이 되는 장치를 게이트웨이라고 하며, 데이트웨이도 하나의 컴퓨터이며 라우터라 불림

- 게이트웨이는 패킷을 보고 같은 네트워크로 보내는 것이 아니면 외부로 전송함

- 게이트 웨이 주소가 설정되어있지 않으면 같은 네트워크가 아닌 네트워크는 전송 불가

[link] [set] : 네트워크 인터페이스 활성화

(4) ifconfig 명령 : ifconfig [인터페이스명] [옵션] [값]

- 네트워크 인터페이스의 IP 주소를 설정함

* -a 시스템의 전체 인터페이스에 대한 정보 출력

* -up/down 인터페이스 활성화/비활성화

* netmask [주소] 넷마스크 주소를 설정

* broadcast [주소] 브로드캐스트 주소 설정

- 옵션 없이 inconfig 시 전체 설정 내용 출력

- IP 주소와 넷마스크, 브로트 캐스트 주소는 사용자의 네트워크 환경에 따라 다르게 출력

- 보통 시스템에서 네트워크 인터페이스는 하나이지만 경우에 따라 두개 이상 장착도 가능

- 네트워크 인터페이스 IP 주소를 수작업으로 설정하려면 IP 주소와 넷마스크를 함께 설정해야 함

- 서브넷으로 나누지 않고 기본 C 클래스를 사용한다면 넷마스크나 브로드 캐스트 주소 생략 가능

: ifconfig 인터페이스명 IP 주소 netmask 넷마스크주소 broadcast 브로드캐스트주소

- ifconfig 명령으로 ip 주소를 다른 것으로 설정하면 게이트 웨이 경로 등 네트워크 정보를 잃어버릴 수 있음

(5) 게이트웨이 설정하기 : route [명령]

- 게이트 웨이 연결 정보를 관리하는 라우팅 테이블을 편집하는 명령임

- 라우팅 테이블이 제대로 설정되어있지 않으면 외부 네트워크와 연결 불가

[add] 라우팅 경로나 기본 게이트웨이를 추가함

[del] 라우팅 경로나 기본 게이트웨이를 삭제함

- Destination : 라우팅 대상 네트워크나 호스트의 주소

- Gateway : 게이트웨이 주소 또는 설정되어있지 않으면 * 출력

- Genmask : 대상 네트워크의 넷 마스크, 255.255.255.255 = 대상이 호스트, 0.0.0.0 = 기본(default) 경로

[자료구조] 탐색 트리

혜머니 — Fri, 29 May 2026 19:49:32 +0900

1. 이진 탐색 트리

(1) 정의

- 탐색 트리 : 탐색을 위한 트리 기반의 자료 구조

- 이진 탐색 트리 : 효율적인 탐색을 위한 이진 트리 기반의 자료 구조, 삽입/삭제/탐색의 시간복잡도는 O(log(2)n)이다.

- 이진 탐색 트리의 특징 :

모든 노드는 유일한 키를 가짐, 왼쪽 서브트리의 키 < 루트의 키 < 오른쪽 서브트리의 키, 왼쪽과 오른쪽 서브트리도 이진탐색트리

(2) 노드 구조

class BSTNode :
    def __init__(self, key, value) :
        self.key = key
        self.value = value
        self.left = None
        self.right = None

(3) 탐색

- 순환 구조 혹은 반복 구조로 구현

# 순환 구조
def search_bst(n, key) :
    if n == None :
        return None
    elif key == n.key :
        return n
    elif key < n.key :
        return search_bst(n.left, key)
    else :
        return search_bst(n.right, key)

# 탐색(반복) 구조
def search_bst_iter(n, key) :
    while n != None :
        if key == n.key :
            return n
        elif key < n.key :
            n = n.left
        else :
            n = n.right
    return None

- '키'가 아닌 '값'을 이용한 탐색 시 모든 노드의 검사 필요

- 최대와 최소 노드 탐색

def search_max(n) :
    while n!= None and n.right != None :
        n = n.right
    return n

def search_min(n) :
    while n!= None and n.left != None :
        n = n.left
    return n

(4) 삽입 연산

- 탐색이 실패한 위치에 노드 삽입

# 순환 구조 이용
def insert_bst(r, n) :
    if n.key < r.key :
        if r.left is None :
            r.left = n
            return True
        else :
            return insert_bst(r.left, n)
    elif n.key > r.key :
        if r.right is None :
            r.right = n
            return True
        else :
            return insert_bst(r.right, n)
    else :
        False

(5) 삭제 연산

- 삭제하려는 노드는 3가지 경우로 나누어짐

- 단말 노드일 경우, 하나의 왼쪽이나 오른쪽 서브 트리 중 하나만 가지고 있는 경우

- 두 개의 서브트리를 모두 가지고 있는 경우

# 단말 노드인 경우
def delete_bst_case1(parent, node, root) :
    if parent is None :
        root = None
    else :
        if parent.left == node :
            parent.left = None
        else :
            parent.right = None
    return root

# 한쪽만 가진 경우
def delete_bst_case2(parent, node, root) :
    if node.left is not None :
        child = node.left
    else :
        child = node.right
    if node == root :
        root = child
    else :
        if node is parent.left :
            parent.left = child
        else :
            parent.right = child
    return root

# 양쪽 다 가진 경우
def delete_bst_case3(parent, node, root) :
    succp = node
    succ = node.right
    while (succ.left != None) :
        succp = succ
        succ = succ.left
    if (succp.left == succ) :
        succp.left = succ.right
    else :
        succp.right = succ.right
    node.key = succ.key
    node.value = succ.value
    node = succ

    return root

# 통합
def delete_bst(root, node) :
    if root = None : return None

    parent = None
    node = root

    while node != None and node.key != key :
        parent = node
        if key < node.key : node = node.left
        else : node = node.right
    if node == None : return None
    if node.left == None and node.right == None :
        root = delete_bst_case1(parent, node, root)
    elif node.left == None or node.right == None :
        root = delete_bst_case2(parent, node, root)
    else :
        root = delete_bst_case3(parent, node, root)
    return root

(6) 이진 탐색 트리의 성능

- 탐색, 삽십, 삭제 연산의 시간 트리의 높이에 비례함

- 키를 이용한 탐색, 값을 이용한 탐색, 최대/최소 노드 탐색, 삽입, 삭제 모두 O(n)

(7) 이진 탐색 트리 맵 클래스

class BSTMap() :
    def __init__(self) :
        self.root = None
    def isEmpty(self) : return self.root == None
    def clear(self) : self.root = None
    def size(self) : return count_node(self.root)
    def search(self, key) : return search_bst(self.root, key)
    def searchValue(self, key) : return search_value_bst(self.root, key)
    def findMax(self) : return search_max_bst(self.root)
    def findMin(self) : return search_min_bst(self.root)
    def insert(self, key, value=None) :
        n = BSTNode(key, value)
        if self.isEmpty() :
            self.root = n
        else :
            insert_bst(self.root, n)
    def delete(self, key) :
        delete_bst(self.root, key)
    def display(self, msg = 'BSTMap : ') :
        print(msg, end =' ')
        inorder(self.root)
        print()

(8) Test Code

map = BTSMap()
data = [35,18,7,26,12,3,68,22,30,99]
print("삽입 연산 : ", data)
for key in data :
map.insert(key)
map.display("중위 순회 : ")
if map.search(26) != None : print("탐색 26 : 성공")
else : print("탐색 26 : 실패")
if map.search(25) != None : print("탐색 25 : 성공")
else : print("탐색 25 : 실패")

map.delete(3)
map.display("[3 삭제] : ")
map.delete(68)
map.display("[68 삭제] : ")
map.delete(18)
map.display("[18 삭제] : ")

삽입 연산 :  [35, 18, 7, 26, 12, 3, 68, 22, 30, 99]
중위 순회 :  3 7 12 18 22 26 30 35 68 99
탐색 26 : 성공
탐색 25 : 실패
[3 삭제] :  3 7 12 18 22 26 30 35 68
[68 삭제] :  3 7 12 18 22 26 30 35 68
[18 삭제] :  3 7 12 18 22 26 30 35 68

2. AVL 트리

(1) 정의

- Adelson Velskii Landis

- 균형인수 = 왼쪽 서브 트리 높이 - 오른쪽 서브 트리 높이 (AVL은 0, +1, -1 중에 하나인 트리)

- 모든 노드에서 왼쪽 서브 트리와 오른쪽 서브 트리의 높이 차이가 1을 넘지 않는 이진 탐색 트리

- 평균, 최악, 최선의 시간 복잡도는 O(log(2)n)을 보장함

- 삽입과 삭제 시 균형 상태가 깨질 수 있음

(1) AVL 트리의 탐색 연산 = 이진 탐색 트리와 동일

(2) AVL 트리의 삽입 연산

- 삽입 위치에서 루트까지의 경로에 있는 조상 노드들의 균형 인수에 영향을 미침

- 삽입 후에 불균형 상태로(균형 인수가 ±2) 변한 가장 가까운 조상 노드의 서브 트리들에 대하여 재균형

- 삽입 노드부터 균형인수가 ±2가 된 가장 가까운 조상 노드까지 회전

def rotateLL(A) :
    B= A.left
    A.left = B.right
    B.right = A
    return B
def rotateRR(A) :
    B = A.right
    A.right =  B.left
    B.left = A
    return B
def rotateRL(A) :
    B = A.left
    A.left =  B.left
    B.left = A
    return B
def rotateLR(A) :
    B = A.right
    A.right =  B.right
    B.right = A
    return B
def reBalance(parent) :
    hDiff = cal_height_diff(parent)

    if hDiff > 1 :
        if cal_height_diff(parent.left) > 0 :
            parent = rotateLL(parent)
        else :
            parent = rotateLR(parent)
    elif hDiff < -1 :
        if cal_height_diff(parent.right) > 0 :
            parent = rotateRR(parent)
        else :
            parent = rotateRL(parent)
    return parent
def insert_avl(parent) :
    if node.key < parent.key :
        if parent.left != None :
            parent.left = insert_avl(parent.left.node)
        else :
            parent.left = node
        return reBalance(parent)
    elif node.key > parent.key :
        if parent.right != None :
            parent.right = insert_avl(parent.right, node)
        else :
            parent.right = node
        return reBalance(parent)
    else :
        print("중복된 키 에러")

(3) 트리 맵

node = [7,8,9,2,1,5,3,6,4]
map = AVLMap()

for i in node :
map.insert(i)
map.display("AVL(%d) : "%i)

[시스템 프로그래밍 Linux] 파일 시스템

혜머니 — Thu, 28 May 2026 22:43:24 +0900

1. 리눅스 파일 시스템

(1) 사용자 계정 관련 파일

- 파일 시스템 : 운영체제의 주요 기능 중 하나로 다양한 정보가 담긴 파일과 디렉터리 집합을 구조적으로 관리하는 체계

- 내부적으로 어떤 구조를 구성하여 파일과 디렉터리를 관리하는지에 따라 다양한 형식의 파일 시스템이 존재함

- 파일과 디렉터리를 관리하는 파일 시스템이 필요함

- 리눅스는 초기에 미닉스의 파일 시스템을 이용했음

- 곧 ext 파일 시스템으로 알려진 리눅스 고유의 파일 시스템을 만들어 사용하게 됨

- 대용량 파일 시스템용으로 실리콘 그래픽스가 개발한 XFS 파일 시스템도 도입하였음

- ext 파일 시스템은 레미 카드가 개발한 것으로 1992년 4월 리눅스 커널 0.96c에 포함되어 발표되었음

- ext : Extended File System = extfs라고도 함, MFS의 기능을 확장했다는 의미

- MFS에서 16비트의 주소 체계를 사용하여 64MB였던 파일 시스템의 최대 크기를 ext에서 2GB로 늘림

- MFS에서 14B였던 파일 이름 길이를 ext에서 유닉스처럼 255B까지 지원함

- ext 파일 시스템의 문제 : inode의 수정과 데이터의 수정 시간이 지원이 안됨, 링크드 리스트로 파일 시스템을 구성하여 파일 시스템이 복잡해지고 파편화 됨

- 현재 리눅스는 ext 시스템을 사용하지 않음

- ext2 : ext 파일 시스템의 문제를 해결하기 위해 내놓은 것으로 레미 카드가 개발하여 1993년 1월에 공개함

- ext2 파일 시스템의 공식 명칭 : Second Extended File System(Ext2 fs)

- ext2는 ext 기반으로 확장성도 고려하여 제작됨

- 리눅스 커널 2.6.17 이전 버전에서는 ext2 파일 시스템의 최대 크기가 2TB로 제한되었으나 현재는 이론적으로 32TB까지 지원함

- ext2는 ext3 파일 시스템이 도입되기 전까지 사실상 리눅스 표준 파일 시스템으로 사용되었음

- 현재 부팅 가능한 USB 플래시 드라이브와 기타 SSD 장치에 사용됨

- ext3 파일 시스템은 스티븐 트위디가 개발하여 2001년 11월 리눅스 커널 2.4.15에 추가됨

- ext3는 ext2를 기반으로 개발되어 호환 가능함

- ext2 파일시스템의 파일을 별도 변경 없이 ext3 파일 시스템에 바로 이식 가능

- 가장 큰 장점은 저널링 기능을 도입한 것임

- 저널 : 로그 기록, 디스크에 데이터 기록 전 갑자기 전원이 나가거나 시스템 충돌 발생 시 저널의 기록을 보고 빠르게 복구할 수 있음

- 저널링 : 디스크에 기록되는 데이터의 복기 기능을 강화한 것, 데이터를 디스크에 기록하기 전에 먼저 저널에 수정사항을 기록함

- ext3의 단점 : inode의 동적 할당이나 다양한 블록 크기와 같은 최신 파일 시스템 기능이 부족하며, 온라인 조각 모음 기능이 없음, 파일 시스템의 최대 크기는 브록의 크리에 따라 2~32TB까지 지원됨

- ext4 파일시스템 안정판은 2008년 12월 리눅스 커널 2.6.28에 포함되어 공개됨

- ext4는 1EB이상의 볼륨과 16TB의 파일을 지원

- ext2, ext3과 호환성 유지, ext3에서는 서브 디렉터리 개수를 32000개로 제한하였으나, ext4에서는 64000개로 늘어남

- ext4는 온라인 조각 모음 지원

- XFS(실리콘 그래픽스가 고성능 저널링 파일 시스템 개발되어 2000년 GNU GPL로 공개됨, 2001년 리눅스에 이식되어 현재 대부분의 리눅스 배포판에서 지원함)

- XFS는 64비트 파일 시스템으로 최대 16EB까지 지원, 로키 리눅스는 XFS 파일 시스템을 기본으로 사용

- 리눅스에서 지원하는 다양한 파일 시스템 : 리눅스에서는 표준 파일 시스템이라고 할 수 있는 ext2, 3, 4외에 유닉스나 윈도우 시스템 등 타 시스템과 호환되도록 DVD, USB같은 외부 저장장치를 사용할 수 있는 다양한 파일 시스템을 지원함

[ 리눅스에서 지원하는 다양한 파일 시스템 ]

- msdos : MS-DOS 파티션을 사용하기 위한 파일 시스템

- iso9660 : CD-ROM, DVD의 표준 파일 시스템이며 읽기 전용으로 사용됨

- nfs : network file system으로 원격 서버의 디스크를 연결할 때 사용함

- ufs : unix file system으로 유닉스 표준 파일 시스템

- vfat : 윈도 95, 98, NT를 지원하기 위한 파일 시스템

- hpfs : HPFS를 지원하기 위한 파일 시스템

- ntfs : 우니도의 NTFS를 지원하기 위한 파일 시스템

- sysv : 유닉스 시스템 V를 지원하기 위한 파일 시스템

- hfs : 맥 컴퓨터의 hfs 파일 시스템을 지원하기 위한 파일 시스템

- 특수용도의 가상 파일 시스템 : 리눅스에는 디스크가 아닌 메모리에서 생성되어 사용되는 가살 파일 시스템이 있음, 가상 파일 시스템은 일반적으로 특수한 용도여서 필요에 따라 생기거나 없어짐

- swap : 스왑 영역을 관리하기 위한 시스템

- tmpfs : 임시 파일을 저장하기 위한 파일 시스템

- proc : 커널의 현재 상태를 나타내는 파일을 가지고 있음

- ramfs : 램디스크를 지원하는 파일 시스템

- rootfs : 시스템 초기화 및 관리에 필요한 내용을 가지고 있음

- 현재 시스템이 지원하는 파일 시스템 : /proc/filesystem (현재 커널이 지원하는 파일 시스템 종류를 보여줌)

- 1열의 nodev는 해당 파일 시스템이 블록 장치와 연결되어있지 않다는 것으로 가상 파일 시스템임을 의미

- 2열에 나오는 것이 지원하는 파일 시스템

- 특수 용도인 가상 파일 시스템이 대부분임을 알 수 있음

(2) 리눅스 파일 시스템 구조

- 리눅스 파일 시스템은 기본적으로 유닉스 운영체제에서 유래된 공통의 개념을 바탕으로 구현되었음

- 파일은 inode로 관리, 디렉터리는 단순히 파일 목록을 가지고 있는 파일일뿐임, 특수 파일을 통해 장치에 접근할 수 있음

- ext4 파일 시스템은 효율적으로 디스크를 사용하기 위해 저장 장치를 논리적인 블록의 집합으로 구분함

- 일반적으로 블록은 4KB이고, 실제 크기는 시스템 설정에 따라 달라짐

[ext4 파일 시스템의 구조]

- 블록 그룹의 개수는 장치의 크기를 블록 그룹의 크기로 나눈 값임

- 블록 그룹 0 : 파일 시스템의 첫번째 블록 그룹으로 특별하게 그룹 0 패딩과 슈퍼블록, 그룹 디스크립터를 가지고 있음

- 블록 그룹 a : 파일 시스템에서 첫번째 블록 그룹이 아닌 블록 그룹으로 그룹 0 패딩이 없으나, 슈퍼 블록과 그룹 디스크립터의 복사본을 가지고 있음

- 블록 그룹 b : 파일 시스템에서 첫번째 블록 그룹이 아닌 블록 그룹으로 그룹 0 패딩, 슈퍼블록, 그룹 디스크립터가 없고 바로 데이터 블록 비트맵으로 시작함

- 블록 그룹 0은 첫 1024B는 특별 목적으로 사용함 (x86 부트 섹터와 부가 정보를 저장하기 위한 것)

- 슈퍼 블록에는 파일 시스템에 관련된 다양한 정보가 저장됨 (inode의 정보, 블록의 개수 등)

- 슈퍼 블록에 문제가 생기면 전체 파일 시스템을 사용할 수 없게 됨 > 슈퍼 블록을 다른 블록 그룹에 복사해놓고 블록 그룹 0의 슈퍼 블록을 읽을 수 없을 경우 복사본을 사용하여 복구함

- 그룹 디스크립터도 블록 그룹 0에 있는 것으로 슈퍼 블록 다음에 위치 (블록 비트맵 주소, inode 주소 등)

- 그룹 디스크립터도 슈퍼 블록과 함께 다른 블록 그룹에 복사되어, 블록 그룹 0에 문제가 있을 경우 복구하는데 사용

- GDP 예약 블록은 그룹 디스크립터를 확장하기 위한 예약 공간임

- 데이터 블록 비트맵 : 블록 그룹에 포함된 데이터 블록의 사용 여부를 확인하는데 쓰임

- inode 비트맵 : inode 테이블 항목이 사용 중인지 표시

- 비트맵에서 각 데이터 블록과 inode 테이블의 항목은 1비트로 표현됨

- 일반적인 유닉스처럼 리눅스에서도 inode에 파일 정보를 저장함

- 데이터 블록에는 실제 데이터가 저장됨

- 일반 파일은 데이터 블록에 파일 내용을 저장함

- 디렉터리는 데이터 블록에 해당 디렉터리에 있는 파일이나 서브 디렉터리 정보(이름, inode)를 저장함

- inode는 크게 파일 정보를 저장하는 부분(간접 블록), 실제 파일 내용이 저장된 데이터 블록의 주소를 저장하는 부분(직접 블록)

- inode에 저장되는 파일 정보 : 파일 종류, 접근 권한, 크기, 소유자, 접근 및 수정 시간 등

- ls -l 명령으로 inode 정보를 읽어오는 것임

- 데이터 블록의 크기는 시스템 설정에 따라 1~8KB까지 지정 가능

- 한 파일 시스템으로 구성하기 : 디렉터리 계층 구조에서 보이는 모든 디렉터리와 파일은 하나의 파일 시스템에 둘 수도있고, 여러 파일 시스템에 나누어 저장할 수 있음, 하나의 파일 시스텝에 구성할 때는 / 디렉터리에 해당 파일 시스템을 연결함

- 디렉터리 계층 구조를 여러 파일 시스템으로 구분하여 구성할 수 있음

- 파일 시스템 1을 / 디렉터리에 연결, 파일 시스템 2를 /usr 디렉터리에 연결함, 디렉터리 3을 /home 디렉터리에 연결함

- / 디렉터리 연결된 파일 시스템은 루트 파일 시스템임

- 여러 파일 시스템으로 나누어 디렉터리 계층 구조를 구성하면 일부 파일 시스템에 문제가 생기더라도 다른 파일 시스템의 파일은 안전함

2. 파일 시스템 마운트 구조

(1) 마운트 개념과 마운트 설정 파일

- 마운트 : 파일 시스템이 디렉터리 계층 구조와 연결되지 않으면 사용자가 해당 파일 시스템에 접근할 수 없으므로 파일 시스템을 디렉터리 계층 구조의 특정 디렉터리와 연결하는 작업을 뜻함

- 디렉터리 계층 구조에 파일 시스템을 마운트하지 않으면 사용자가 접근할 수 없음 = 마운트 하지 않은 파일 시스템의 디렉터리로 이동 불가

- 마운트 포인트 : 디렉터리 계층 구조에서 파일 시스템이 연결되는 디렉터리, 루트 파일 시스템을 마운트한 / 디렉터리

- 리눅스 시스템을 부팅할 때 파일 시스템을 자동으로 마운트할 수 있음

- CD-ROM, DVD, USB 메모리 같은 이동식 저장장치를 제외하고 대부분의 파일 시스템은 부팅할 때 마운트 되도록 하는 것이 편리함

- 리눅스에서 시스팀에 부팅될 때 자동으로 파일 시스템이 마운트되게 하려면 /etc/fstab 파일의 구성 항목으로 설정 해야 함

- /etc/fstab 파일 : 파일 시스템의 마운트 설정 정보가 있음, 리눅스 시스템은 부팅될 때 이 파일을 읽고 설정 내용에 따라 파일 시스템을 자동으로 마운트함, 이 파일에 오류가 있으면 부팅 중지될 수 있음, 파일 시스템 장치명, 마운트 포인트, 마운트할 때 설정할 옵션을 지정함

- 장치명 : 파일 시스템이 구축된 물리적인 디스크 장치가 3개 있고, 첫번째가 장치명임

- 마운트 포인트 : 마운트 될 마운트 포인트를 설정함

- 파일 시스템의 종류 : etc2,3,4,xfs를 비록해 표에서 제시한 것을 사용 가능

- 옵션 : defaults(일반적인 파일 시스템에 지정하는 속성 rw/nouser/auto/exec/suid), auto(부팅 시 자동으로 마운트), exec(실행 파일이 실행되는 것을 허용), suid(setuid, setgid의 사용을 허용함) ro(읽기 전용 파일 시스템) rw(쓰지 전용 파일 시스템) user(일반 사용자도 마운트 가능) nouser(일반 사용자 마운트 불가, root만 가능) noauto(부팅 시 자동으로 마운트하지 않음) noexec(실행파일 미허용) nosuid(setuid, setgid 미허용) usrquota(사용자별로 디스크 쿼터 설정 가능) grpquota(그룹별로 디스크 쿼터 설정 가능)

- 덤프 관련 설정 : 0 또는 1을 지정 0(dump되지 않은 파일 시스템) 1(데이터 백업 등을 위해 dump 명령 사용 가능 시스템)

- 파일 점검 옵션 : 0(부팅 시 fsck명령으로 파일 시스템을 점검하지 않게하는 설정) 1(루트 파일 시스템) 2(루트 파일 시스템 이외의 시스템)

> 부팅할 때 0으로 지정한 파일 시스템은 fsck 명령을 실행하지 않음, 1인 루트 파일 시스템이 fsck 명령으로 파일 시스템 점검을 수행, 2로 설정된 파일 시스템은 나열된 순서대로 fsck 명령을 사용하여 점검

- UUID : universally unique ID의 약자로 로컬 시스템과 다른 시스템에서 파일 시스템을 유일하게 구분해주는 128비트 숫자

- UUID는 시스템의 하드웨어 정보와 시간 정보를 조합하여 랜덤으로 생성

- 디스크가 추가될 때 부트 로더를 가지고있는 부트 장치의 이름이 바뀌는 것을 반지하기 위해 사용함

- UUID로 지정된 장치는 /dev/disk/by-uuid에서 찾을 수 있음

(2) 마운트 명령 : mount [옵션] [장치명 마운트 포인트]

- 파일 시스템을 마운트함

* -t [파일시스템 종류] 파일 시스템 종류를 지정함

* -o [마운트 옵션] 마운트 옵션을 지정함

* -f 마운트를 할 수 있는지 점검만 함

* -r 읽기만 가능하게 마운트 함 = -o ro

- 옵션이나 인자를 지정하지 않고 mount 명령을 사용하면 다음과 같이 현재 마운트 되어있는 정보가 출력됨

- /etc/mtab 파일을 구성하는 항목은 장치명, 마운트 포인트, 파일 시스템 종류, 옵션, 사용하지 않는 항목 두개(0 0)

- 사용하지 않은 항목 두 개는 /etc/fstab 파일과 호환성을 위해 추가한 것

- 하드디스크를 디렉터리 계층 구조에 연결할 때는 mount [하드디스크 장치 이름] [마운트 포인트] 명령을 이용함

(3) 마운트 해지 명령 : umount [옵션] [장치명 또는 마운트 포인트]

- 파일 시스템을 언마운트함

* -t [파일 시스템 종류] 파일 시스템 종류를 지정함

- umount 명령 실행 시 busy라고 메세지가 출력되는 경우 누군가가 사용중이라는 뜻으로 사용자가 빠져나오기 전까지 해제 불가

3. 파일 시스템 마운트 활용

(1) 리눅스용 USB 메모리 연결하기

- USB 메모리를 마운트 할 때 고려사항 : 이 메모리가 리눅스 용인지, 윈도우 용인지를 구분하는 것

- 리눅스용 USB 메모리 : 리눅스에서 포맷하고 리눅스 파일 시스템을 생성한 메모리

ⓐ USB 메모리를 리눅스 시스템에 인식시키기

- USB 메모리를 USB 슬롯에 꽂고 리눅스 시스템에 인식시킴

- 일반적으로 리눅스 시스템이라면 USB 슬롯에 USB 메모리를 꽂았을 때 바로 인식하고 콘솔 창에 메세지 출력

- VMWare인 경우 USB 메모리를 호스트 OS(윈도우)에 연결할 지 VMWare 가상머신(리눅스)에 연결할지 선택하는 팝업 창이 나타남 (여기서 가상머신을 선택하면 됨)

- mount 명령 실행 시 추가되었는지 확인 가능

- 일단 umount로 메모리 마운트 삭제 가능

ⓑ USB 메모리의 장치명 확인하기

- 리눅스 시스템에 연결된 저장장치명은 fdisk -l 명령으로 확인 가능 (su 명령으로 진행 필요)

- fdisk -l 명령의 실행 결과에는 USB 메모리 뿐만 아니라 기존 하드디스크 정보도 포함됨

- USB 메모리에 파일 시스템을 생성한 뒤 이 장치를 디렉터리에 연결하는 작업(마운트)를 진행함

- mount로 잘 되었는지 재확인

ⓓ 디렉터리 사용하기

- USB 메모리가 디렉터리에 연결되었으므로 사용 가능

- 해당 경로로 이동 후 내용을 보면 lost+found 디렉터리만 있음

- USB 메모리에 파일을 마음대로 생성할 수 있음(예시 : 파일 복사 등)

(2) 윈도우용 USB 메모리 연결하기

- USB 메모리를 그대로 마운트하여 사용할 것이므로 별도의 파일 시스템을 생성하지 않아도 됨

- USB 슬롯에 메모리를 꽂고 장치명을 확인함

ⓐ USB 메모리를 USB 슬롯에 꽂으면 팝업 창이 뜸

- 가상머신에 연결하기를 선택하여 USB 메모리를 리눅스 시스템에 인식시킴

ⓑ USB 메모리가 인식되었으면 USB 메모리의 장치명을 확인함

- fdisk -l 명령의 실행 결과를 보면 USB 메모리의 장치명은 /dev/sda1이고 파일 시스템 종류가 FST32임 확인 가능(예시)

- 실습을 위해 마운트 해제 후 재마운트 시 포맷이 FAT인지 NTFS인지에 따라 마운트 시 파일 시스템의 종류를 vfat으로 할 지 ntfs로 할지 결정 가능

ⓓ USB 메모리가 디렉터리에 연결됐으므로 사용 가능

- USB 메모리를 마운트한 디렉터리를 이동하여 디렉터리 내용을 보면 윈도우에서 생성한 파일이 보임

- 마운트를 해제한 후 윈도우에서 생성된 파일의 내용이 보이는지 확인 시 파일이 한줄로 붙어서 확인하기 어려움

- 리눅스와 윈도우가 [Enter]를 처리하는 방식에 차이가 있기 때문에 나타나는 문제임

- 윈도우 응용 프로그램 중 리눅스의 [Enter] 처리를 인식하는 워드 패드같은 편집기를 사용하면 내용 확인 가능

(3) CD-ROM/DVD 연결하기

ⓐ CD-ROM/DVD 장치를 연결하여 리눅스 시스템에 인식시킴

- USB 메모리 인식하는 방법과 동일

ⓑ 대부분의 경우 자동으로 인식되나, 수동으로 하는 경우 mount 명령 사용

- 장치명으로 /dev/cdrom이나 /dev/sr#을 사용함 (#에는 0, 1, 2)

- 1장에서 iso 파일을 CD-ROM/DVD 장치로 연결했다면 /dev/sr0이 아닌 /dev/sr1 장치로 연결해야 함

- /dev/cdrom은 기본적으로 /dev/sr0의 심볼릭 링크임

- 자동으로 마운트된 CD-ROM/DVD를 언마운트하고 수동으로 연결

ls -l /mnt

[데이터 구조와 활용] 해시 테이블

혜머니 — Tue, 26 May 2026 10:55:54 +0900

1. 해시테이블

(1) 정의

- 키를 사용하여 데이터를 빠르게 검색하고 저장하는 데이터 구조

- 일반적으로 데이터 검색, 삽입, 삭제가 매우 빠르게 평균적으로 O(1) 이루어짐

- 일반적은 배열이나 리스트의 선형 탐색 O(n)보다 매우 빠름

- 해쉬 함수를 사용해 키를 해시(배열 인덱스)로 변환해 데이터를 저장, 검색함

- 해시값은 특정 키를 고정된 길이의 값으로 변환한 결과를 의미함

(2) 핵심 원리 : 해시 함수

- 해시테이블에서 데이터를 저장하고 찾기 위해서는 키를 인덱스로 변환하는 과정이 필요함

- 이 때 사용하는 함수가 해시 함수임

(3) 해시 함수의 조건

- 같은 키를 넣으면 항상 같은 해시 값을 반환함

- 가능한 한 충돌을 최소화하며, 해시 값이 균등하게 분포되어야 함

- 서로 다른 키도 때로는 같은 해시 값을 가질 수 있으며, 이를 충돌이라 함

- 계산 속도가 빠르고 효율적이어야 함

(4) 해시 함수 vs 암호학적 해시 함수의 비교

- 두 함수는 기본 목적(데이터 변환)은 유사하나 세부 목적과 요구조건(속도 vs 보안)이 매우 다름

- 암호학적 해시 함수는 충돌 방지와 보안이 최우선이므로 설계가 매우 복잡하고 상대적으로 느림

- 암호학적 해시 함수 예시 : SHA-256, SHA-3 등

(5) 해시 충돌

- 서로 다른 두 개 이상의 키가 같은 해시 값을 갖게 되는 현상

- 충돌이 발생하면 키가 저장될 위치가 중복되어 문제가 발생함

- 같은 위치에 두 개의 키를 저장할 수 없으므로 충돌이 발생함, 충돌이 발생하면 키를 찾을 때 추가적인 탐색 과정이 필요함

(6) 충돌 해결 방법 1 : 체이닝 방식

- 체이닝 방식은 각 배열 인덱스 위치에 여러 키들을 연결 리스트 형태로 저장

- 충돌이 발생해도 같은 인덱스에 키를 이어 붙이는 방식이므로 구현이 단순함

- 많은 언어에서 체이닝을 기본으로 사용(파이썬은 아님)

- 충돌 발생 시 리스트에서 키를 하나씩 비교하며 탐색(선형 탐색)

- 해시 값이 같은 위치에서 실제 키가 존재하는지 확인해야 함

def hash_func(key) :
    return key % 5

hash_table = [[]for i in range(5)]
keys = [1,6,11]

for key in keys :
    index = hash_func(key)
    hash_table[index].append(key)

print(hash_table)

(7) 충돌 해결 방법 2 : 오픈 어드레싱 방식

- 충돌이 발생하면 해시 테이블 내에서 다음 번 슬롯을 찾아 키를 저장함

- 별도의 연결 리스트를 사용하지 않으므로, 메모리 사용량이 적음

- 파이썬 dist, set 데이터 구조는 오픈 어드레싱 방식을 사용해 충돌을 처리함

- 충돌 발생 시 해시 테이블 내부의 다른 빈 슬롯을 찾아 키를 저장함

- 가장 간단한 방식인 선형 탐사를 기반으로 설명함

- 실제 파이썬의 dict와 set은 이보다 더 복잡한 perturbation 기반 방식 사용

def hash_func(key) :
    return key % 5

hash_table = [None]*5
keys = [1,6,11]

for key in keys :
    index = hash_func(key)
    while hash_table[index] is not None :
        index = (index+1)%5
    hash_table[index] = key

print(hash_table)

(8) 체이닝 방식 vs 오픈 어드레싱 방식

방식	체이닝 방식	오픈 어드레싱 방식
충돌 시 저장 방식	같은 인덱스에 리스트로 저장	해시 테이블 내 다른 빈 슬롯에 저장
구조	인덱스별 연결 리스트	전체 테이블 분산 저장
탐색	연결 리스트 선형 탐색	슬롯 이동하며 탐색

(9) 충돌 시 탐색과 시간 복잡도

- 평균적으로는 매우 빠르며, 탐색/삽입/삭제 모두 평균적으로 O(1)의 시간 복잡도를 가짐

- 하지만 충돌이 많이 발생하면, 탐색 경로가 길어지고 최악의 경우 O(n) 시간 복잡도로 성능이 떨어질 수 있음

- 체이닝 방식 : 많은 키가 동일한 해시 값을 가질 경우

- 오픈 어드레스 방식 : 테이블이 거의 가득 찬 상태에서 충돌이 많은 경우

- 적절한 테이블 크기와 해시 함수의 분산 성능이 중요함

(10) 해시값과 실제값 존재 여부 판단 방법

- 해시 테이블에서 키 존재 여부를 판단할 때는 2단계를 거침

ⓐ 해시 값 계산 (충돌 있을 시 ⓑ 진행)

ⓑ 실제 키 비교 - 체이닝/오픈 어드레스

- 해시값은 빠르게 위치를 찾아줄 뿐이며, 실제 값 존재 여부는 반드시 키 비교를 통해서만 판단함

- 실제로 키가 없는데 있는 것으로 잘못 판단하는 경우는 절대 발생하지 않음

- 해시값만 보고 바로 키가 있다고 판단하지 않고, 반드시 실제 키를 다시 비교하기 때문에 오판 가능성은 없음

- 그러나 실제로 키가 있는데 빠르게 찾지 못하고 시간이 오래 걸릴 수 있음

- 충돌이 많으면 탐색 시간이 증가하여 성능이 저하될 수 있음

- 키가 있는데 없다고 판단하는 경우는 없고, 다만 탐색 시간이 늘어날 수 있음

(11) 해시 함수의 성능

- 해시 함수는 빠르고 균등하게 분포된 해시값을 생성해야 하며, 잘못된 해시 함수의 선택은 성능이 크게 떨어질 수 있음

(12) 활용 사례

- 해시 테이블은 특정 문제를 해결할 때 필수적인 데이터 구조임

- 회원 관리 시스템에서 회원 ID, PW 정보 등

- 데이터 베이스에서 빠른 검색

- 검색 엔진

- 캐시 등

2. 파이썬의 해시 테이블

(1) 파이썬 내장 해시 테이블 기반 데이터 구조

- dict : 키-값의 쌍으로 이루어짐 (빠른 데이터 검색 및 관리)

- set : key만으로 이루어짐 (빠른 데이터 존재 여부 확인)

(2) 파이썬 set에서의 key

- 파이썬에서 set은 내부적으로 dict과 유사한 방식으로 동작하지만, 값은 없어 키만 저장하는 구조로 구현되어있음

- set에서는 데이터가 곧 키역할을 함

- dict, set 모두 hash('apple')을 사용해 같은 방식으로 탐색 수행

구조	예시
dict	{'apple':100} -> key = 'apple', value = 100
set	{'apple'} -> key = 'apple', value = 없음 또는 더미

(3) 파이썬 dict에서의 value는 어디에 저장될까?

- 해시 테이블의 각 슬롯에는 키와 값이 쌍으로 저장되어있음

- 슬롯마다 키-값 쌍이 함께 저장되고, 탐색은 키를 중심으로 진행되며, 값은 따라오는 구조임

(4) 파이썬 dict 기본 문법 및 주요 메서드

- dict은 키를 통해 데이터를 저장하고, O(1)의 빠른 탐색 속도를 제공함

- 다양한 메서드를 통해 dict을 효율적으로 활용할 수 있음

(5) 파이썬 set 기본 문법 및 주요 메서드

- set은 키로만 구성된 데이터를 저장하고 존재 여부 체크가 O(1) 성능임

- 수학적 집합 연산 수행 가능

(6) dict과 set 리스트의 성능 비교

- dict, set 평균 O(1)의 빠른 탐색 성능 제공

- list 탐색 시 O(n)의 느린 성능 제공

- 실제 데이터가 많아질수록 성능 차이는 매우 커짐

(7) 파이썬의 collections.defaultdict

- 기존은 dict보다 유용하게 활용되는 확장된 형태의 dict임

- 일반적인 dict은 키가 없을 때 key error가 발생함

- collection.defaultdict은 키가 없으면 자동으로 기본값을 생성하여 반환함

- collection.defaultdict (int) == 키가 없을 때 int() 호출 -> 0으로 초기화됨

(8) dict과 set의 주의사항

- dict과 set의 키는 반드시 변경 불가능한(immutable) 데이터 타입만 가능

- 가능 : 수, 문자열, 튜플

- 불가능 : 리스트, 딕셔너리 등

(9) 시간 복잡도

- 평균 O(1), 최악의 경우 O(n)

3. 해시 테이블 활용하기

(1) BOJ 15829

l = int(input())
s = input().rstrip()
h = 0

for i, v in enumerate(s) :
    a = ord(v) - ord('a')
    h += a * (31**i)
    h %= 1234567891

print(h)

5
abcde
3785410

(2) BOJ 7785

n = int(input())
s = set()

for i in range(n) :
    x, y = input().split()
    if y == 'enter' :
        s.add(x)
    else :
        s.remove(x)

a = list(s)
a.sort(reverse = True)
print(*a, sep = '\n')

4
baha enter
askar enter
baha leave
artem enter
askar
artem

[문제 해결 알고리즘] 정렬 알고리즘 ②

혜머니 — Mon, 25 May 2026 10:53:13 +0900

1. 쉘 정렬

(1) 정의

- 배열 뒷부분의 작은 숫자를 앞부분에 빠르게 이동시키고, 동시에 앞부분의 큰 숫자는 뒷부분으로 이동시킨 후, 가장 마지막에 삽입 정렬을 수행하는 알고리즘

(2) 아이디어

- 예시 데이터 : 30 60 90 10 40 80 40 20 10 60 50 30 40 90 80

- 간격(Gap)이 5가 되는 숫자끼리 그룹 생성 : [30 80 50] [60 40 30] [90 20 40] [10 10 90] [40 60 80]

- 그룹 별로 삽입 정렬을 수행 : [30 50 80] [30 40 60] [20 40 90] [10 10 90] [40 60 80]

= 원래 자리 기준으로 보면 30 30 20 10 40 50 40 40 10 60 80 60 90 90 80

> 큰 숫자는 뒷 쪽 그룹에, 작은 숫자는 앞 쪽 그룹에 있는 것을 확인할 수 있음

- 이 후 간격을 5보다 작게 해가며, 더 진행 시 삽입 정렬 수행이 더 빨라짐

- 마지막에는 반드시 간격을 1로 놓고 수행함 = 삽입 정렬

(3) 알고리즘

ⓐ for each gap h = [h0 > h1 > ... > hk = 1]

ⓑ for i = h to n -1 {

ⓓ j = i

ⓕ while(j>=h) and A[j-h] > CurrentElement {

ⓖ A[j] = A[j-h]

ⓗ j = j-h }

ⓘ A[j] = CurrentElement }

ⓙ return 배열 A

(4) 특징

- 쉘 정렬의 수행 속도는 간격 설정에 따라 좌우됨

: 지금까지 알려진 가장 좋은 성능을 가진 간격 = 1, 4, 10, 23, 57, 132, 301, 701 (이후로는 밝혀지지 않음)

- 쉘 정렬의 시간 복잡도는 아직 풀리지 않은 문제임

- 최악의 경우 O(n^2)

- 히바드(Hibbard)의 간격(2^k-1)을 사용하는 경우 시간 복잡도 : O(N^(1.5))

- 많은 실험을 통해 쉘 정렬의 시간 복잡도는 O(n^(1.25))로 알려짐

2. 힙 정렬

(1) 정의

- 힙 : 힙 조건을 만족하는 완전 이진 트리

- 힙 조건 : 각 노드의 값이 자식 노드의 값보다 커야한다는 것

- 노드의 값은 우선순위라고 함

- 힙의 루트에는 가장 높은 우선순위가 저장됨

(값이 작을수록 우선순위가 높은 경우에는 가장 작은 값이 우선 순위에 저장)

- n개의 노드를 가진 힙은 완전 이진 트리이므로 힙의 높이가 log(2)n이며 노드들은 빈 공간없이 배열에 저장할 수 있음

(2) 아이디어

- 힙 정렬 : 힙 자료구조를 이용하는 정렬 알고리즘

- 오름 차순의 정렬을 위해 최대 힙을 구성함

- 힙의 루트에는 가장 큰 수가 저장되므로 루트의 숫자를 힙에 가장 마지막 노드에 있는 숫자와 바꿈

- 가장 큰 수를 배열의 가장 끝으로 이동시킨 것임

- 루트에 새로 저장된 숫자로 인해 위배된 힙 조건을 해결하여 힙 조건을 만족시키고, 힙 크기를 1개 줄임

- 이 과정을 반복하여 나머지 수사를 정렬함

(3) 알고리즘

- 입력 : A[1]부터 A[n]이 저장된 배열 A

- 출력 : 정렬된 배열 A

ⓐ 배열 A의 숫자에 대해서 힙 자료 구조를 만듦

ⓑ heapsize = n

ⓓ A[1]과 A[heapsize] 교환

ⓔ heapsize = heapsize -1

ⓕ Downheap() }

ⓕ return 배열 A

- Downheap

: 루트가 r을 가지고 있다고 가정함

: 루트의 r과 자식 노드들 중에서 큰 것을 비교하여 큰 것과 r을 바꿈

: 다시 r을 자식 노드들 중에서 큰 것과 비교ㅛ하여 힙 조건이 위배되면 앞서 수행한대로 큰 것과 r을 교환함

: 힙 조건이 만족될 때까지 이 과정을 반복함

(4) 특징 O(n)의 시간 복잡도를 가짐

3. 기수 정렬

(1) 정의

- 숫자를 부분적으로 비교하는 정렬 방법

- 제한적인 범위 내에 있는 숫자에 대해서 각 자릿수 별로 정렬하는 알고리즘

- 어느 비교 정렬 알고리즘보다 빠름

- 계좌 번호, 날짜, 주민등록번호 등의 대용량 상용 데이터베이스 정렬에 매우 적절함

(2) 알고리즘

- 입력 : n개의 r진수의 k자리 숫자

- 출력 : 정렬된 숫자

ⓐ for i = 1 to k

ⓑ 각 숫자의 i자리 숫자에 대해 안정한 정렬을 수행함

(3) 특징

- 안정성 : 입력에 중복된 숫자가 있을 때, 정렬된 후에도 중복된 숫자의 순서가 입력에서의 순서와 동일한 경우 정렬 알고리즘이 안정성을 가진다 함

- 시간 복잡도 : for 루프가 k번 반복함 = 한 번 루프가 수행될 때 n개의 숫자의 i자리수를 읽음, r개로 분류하여 개수를 셈, 결과에 따라 숫자가 이동하므로 O(n+r)시간이 걸림 = O(k(n+r)) ; k나 r이 입력인 크기인 n보다 크지 않으면 O(n)임

4. 외부 정렬

(1) 정의

- 입력 크기가 매우 커서 읽고 쓰는 시간이 오래 걸리는 보조 기억 장치에 입력을 저장할 수 밖에 없는 상태에서 수행되는 정렬

- 내부 정렬(입력이 주기억장치=내부 메모리에 있는 상태에서 정렬이 수행함

- 주기억 장치의 용량이 1GB이고 입력의 크기가 100GB라면 어떤 내부 정렬 알고리즘으로도 직접 정렬 불가

- 입력을 분할하여 주 기억 장치에 수용할 만큼의 데이터에 대해서만 내부 정렬을 수행하고 그 결과를 보조 기억 장치에 일단 다시 저장함

- 100GB의 데이터를 1GB씩 주 기억 장치로 읽어들임 > 퀵 정렬과 같은 내부 정렬 알고리즘을 통해 정렬함 > 다른 보조 기억 장치에 저장함

- 반복하면 원래의 잉ㅂ력이 100개의 정렬된 블록으로 분할되어 보조 기억 장치에 저장됨

- 정렬된 블록들을 하나의 정렬된 거대한 100GB 크기의 블록으로 만드는 것임

- 이 과정은 반복적인 합병을 통해 이루어짐

- 블록들을 부분적으로 주기억 장치에 읽어들여 합병을 수행하여 부분적으로 보조 기억 장치에 쓰는 과정이 반복됨

- 1GB 두 개를 합병한 방식으로 2GB+2GB로 4GB를 합병하고 결국에는 100GB 블록 1개가 남을 때까지 반복

- 외부 정렬 알고리즘은 보조 기억 장치에서의 읽고쓰기를 최소화하는 것이 중요함

= 보조 기억 장치의 접근 시간이 주 기억 장치의 접근 시간보다 매우 오래 걸리기 때문

[데이터 구조와 활용] 너비 우선 탐색(BFS)

혜머니 — Fri, 22 May 2026 22:43:17 +0900

1. 너비우선 탐색이란?

- 그래프 탐색 방법 중 하나로 이름 그대로 가장 가까운 정점부터 탐색하고, 그 다음으로 가까운 정점 순서대로 차례차례 탐색을 진행하는 방식

- 지하철에서 환승할 때, 목적지에 가장 적은 수의 역을 통과하는 최적의 경로를 찾는 방식과 유사함

2. BFS 탐색 원리와 큐(Queue)

- BFS는 일반적으로 큐를 통해 구현되며, 선입 선출(FIFO) 방식과 밀접한 관계가 있음

* 큐 : 먼저 넣은 값이 먼저 나오는 데이터 구조임

* BFS 탐색 방식 : 출발점에 가까운 정점부터 순차적으로 방문하며, 탐색이 진행됨

- BFS는 먼저 방문한 정점부터 탐색한다는 점에서 큐의 특성과 일치

3. BFS 사용 사례

- 최단 경로 탐색 : 가중치가 없는 그래프에서 두 정점 사이의 최단 경로(최소 개수의 간선을 통해 연결된 경로)를 찾고자 할 때 유용함

- 그래프의 연결된 요소 찾기 : 그래프 내에서 방문하지 않은 정점부터 BFS 탐색을 진행하고, 탐색 중 방문한 모든 정점이 하나의 연결된 요소이며, 이 과정을 반복하여 연결 요소 개수를 셀 수 있음

- SNS 친구 추천 : 친구 관계를 기준으로 가까운 단계(친구의 친구)부터 탐색하여 친구 추천 사용

- 웹 사이트 구조 탐색(웹 크롤링) : 웹 사이트의 메인 페이지에서 가까운 페이지부터 차례대로 탐색할 때 효율적

4. 구현

import collections

graph = {
    'A' : ['B','C','D'],
    'B' : ['A','E'],
    'C' : ['A','F'],
    'D' : ['A','G'],
    'E' : ['B','F'],
    'F' : ['C','E'],
    'G' : ['D']
    }

visited = set()
order = []
queue = collections.deque()

visited.add('A')
queue.append('A')

while queue :
    v  = queue.popleft()
    order.append(v)

    for n in graph[v] :
        if n in visited :
            continue
        visited.add(n)
        queue.append(n)

print(order)

['A', 'B', 'C', 'D', 'E', 'F', 'G']

5. 큐의 방식 원리 설명

- 큐를 명시적으로 사용하면 BFS가 실제로 어떻게 동작하는지 직관적으로 확인할 수 있음

- 가장 먼저 추가한 정점부터 탐색하여 너비 우선 탐색 방식이 명확하게 드러남

6. BFS의 재귀 구현이 어려운 이유

- DFS와 달리 BFS는 재귀 방식으로 구현이 매우 어려움

- BFS는 가까운 정점부터 탐색하므로, 재귀 호출 스택의 특성상 깊이를 우선적으로 탐색하는 방식과 충돌하기 때문

- 따라서 BFS는 큐를 이용해 반복문으로 구현함

7. BOJ1260

import collections

a, b, c = map(int, input().split())
graph = collections.defaultdict(list)

for _ in range(b):
    x, y = map(int, input().split())
    graph[x].append(y)
    graph[y].append(x)

visited = set()
order = []
queue = collections.deque()

visited.add(c)
queue.append(c)

while queue :
    v  = queue.popleft()
    order.append(v)

    for n in graph[v] :
        if n in visited :
            continue
        visited.add(n)
        queue.append(n)

print(order)

4 5 1
1 2
1 3
1 4
2 4
3 4
[1, 2, 3, 4]

8. BOJ11724

import collections

a, b = map(int, input().split())
graph = collections.defaultdict(list)

for _ in range(b):
    x, y = map(int, input().split())
    graph[x].append(y)
    graph[y].append(x)

visited = [False] * (a+1)
order = []
queue = collections.deque()

res = 0

for i in range(1,a+1) :
    if visited[i] :
        continue
    visited[i] = True
    res += 1
    q = collections.deque()
    q.append(i)
    while q :
        z = q.popleft()
        for g in graph[z] :
            if visited[g] :
                continue
            visited[g] = True
            q.append(g)
print(res)

6 5
1 2
2 5
5 1
3 4
4 6
2

9. BOJ2606

import collections

a = int(input())
b = int(input())
graph = collections.defaultdict(list)

for _ in range(b):
    x, y = map(int, input().split())
    graph[x].append(y)
    graph[y].append(x)

visited = set()
order = []
queue = collections.deque()

visited.add(1)
queue.append(1)

while queue :
    v  = queue.popleft()
    order.append(v)

    for n in graph[v] :
        if n in visited :
            continue
        visited.add(n)
        queue.append(n)

print(len(order)-1)

7
6
1 2
2 3
1 5
5 2
5 6
4 7
5

[차크라명상] 마음의 구조와 명상

혜머니 — Wed, 20 May 2026 21:12:19 +0900

1. 물질 중의 물질 마음
- 상키야의 25원리(tattva) 중 마음의 위치와 의미
: 요가에서 마음(citta)는 buddhi-ahamkara-manas를 총칭하는 용어임
- 이 셋은 근본 물질(prakrtri)의 산물(물질적 전개물) 중에 sattva(순질)이 가장 현저한 가장 미세하고 민감한 물질적 원리임
- 마음 : 인식의 주체인 동시에 인식의 도구이며 또한 인식의 대상이 됨
            수술하는 의사이며, 수술칼인 동시에 수술의 대상이 됨
2. 명상이 왜 필요한가?
- 즉각 반응하는 마음의 오래된 습관을 고치기 위함
- 몸과 마음에서 일어나는 고통스러운 느낌과 핸복한 느낌
- 이에 마음의 반응은 크게 두 가지 좋다 또는 싫다
- 좋다는 반응은 집착으로 이어지고 싫다는 말은 혐오로 귀결됨
[Reaction과 Response의 차이]
(1) Reaction
- 즉각적이고 자동적으로 일어나는 마음의 움직임
- 과거의 습관적 조건(잠재의식, 훈습), 욕망, 두려움, 집착, 혐오 등에 의해 일어남
- 외부 자극 > 무의식적 해석 > 곧바로 감정 행동으로 나타남
- 예시로 누군가 거친 말을 하면 화가 바로 나는 것
(2) Response
- 의식적이고 자각적으로 선택된 마음의 움직임
- 자극과 행동 사이에서 멈춤, 판단 중지가 생기고 그 안에서 알아차림(santi)을 통해 선택이 이루어짐
- 예로 누군가 거친 말을 했을 때 숨을 고르고 상대의 상황을 고려하여 차분히 말하는 것
- 명상을 통해 걸러지는 사띠와 빤냐가 작용하는 상태
3. 마음이 먹고 사는 방식과 명상
- 감각기능과 마음의 관계 : 입과 위장의 관계
- 감각기간을 닫아 위장의 움직임을 쉬게하는 것이 명상
- 마음 단식이라고 할 수 있음
4. 명상이 잘 오게 하는 방법
- 잠(수면)과 명상 : 잠도 명상도 배우거나 가르칠 수 없음, 잠이 오는 것처럼 명상도 오는 것일 뿐
- 어떤 조건에서 잠/명상이 잘 오는가?
   늘 같은 시간, 같은 장소에 눕거나 앉을 때
   환한 곳보다는 어둑어둑한 곳에 눕거나 앉을 때
   시끄러운 곳보다는 어두운 곳에 눕거나 앉을 때
- 잠과 명상의 본질적인 차이
  잠(indra)은 tamas가 현저한 마음 작용, 명상(삼매)는 santtva가 충만한 마음 작용
  잠이하는 마음 작용은 억제/지멸의 대상, 멸상은 분별지(vivenkakhati)를 증장하여 마침내 독존(kaivalya)을 성취하는 직접적인 수단
5. 명상 멀어져 가능 풍경 만들기
- 명상, 참나(purusa, atman) 닮기
  마피 나와 거울에 비친 나의 관계처럼 덜된 나(jivatman)는 참나가 아니지맘 고고샅샅 참나를 닮음
  참나는 행위자가 아님 다만 쿨하게 바라보는 자, 목격자일 뿐임
-  명상은 인식/경험의 대상에 반응하지 않고 집착도 없고 혐오도 없이 쿨하데 바라보는 훈련
- 탈동일화(Disidentification) 또는 멀어져가는 풍경 만들기

[문제 해결 알고리즘] 정렬 알고리즘 ①

혜머니 — Tue, 19 May 2026 21:10:34 +0900

1. 버블 정렬

(1) 정의

- 실제로 많이 사용하지는 않음

- 다른 정렬에 비해 시간복잡도가 높고 연산 처리 속도나 나쁨

- 정렬 알고리즘의 분류 :

기본적인 정렬 알고리즘 = 버블 정렬, 선택 정렬, 삽입 정렬

효율적인 정렬 알고리즘 = 쉘 정렬, 힙 정렬, 합병 정렬, 퀵 정렬, 기수 정렬(입력이 제한된 크기 이내에 숫자로 구성되어 있을 때 효율적)

- 내부 정렬 : 입력의 크기가 주 기억 장치의 공간보다 크지 않은 경우에 수행되는 정렬

- 외부 정렬 : 입력의 크기가 주 기억장치 공간보다 큰 경우, 보조 기억 장치에 있는 입력을 여러번에 나누어, 주 기억 장치에 읽어들인 후 정렬하여 보조 기억 장치에 다시 저장하는 과정을 반복해야 할 때 수행되는 정렬

- 버블 정렬 : 이웃하는 숫자를 비교하여 작은 수를 앞쪽(또는 큰 수를 뒤쪽)으로 이동시키는 과정을 반복하여 정렬하는 알고리즘

- 오름차순으로 정렬한다면 작은 수는 배열의 앞 부분으로 이동하는데, 배열을 상하로 그려보면 정렬하는 과정에서 작은 수가 마치 거품으로 위로 올라가는 것을 연상케함

- 패스 : 입력을 전체적으로 1번 처리하는 것

(2) 알고리즘

- 입력 : 크기가 n인 배열 A

- 출력 : 정리된 배열 A

ⓐ for pass = 1 to n-1

ⓑ for i =1 to n-pass

ⓓ A[i-1] ↔ A[i]

ⓔ return 배열 A

(3) 시간 복잡도 = O(n(n-1)/2) = O(n^2)

2. 선택 정렬

(1) 정의

- 입력 배열 전체에서 최솟값을 선택하여 배열의 0번 원소와 자리를 바꾸고, 다음엔 0번 원소를 제외한 나머지 원소에서 최솟값을 선택하여 배열의 1번 원소와 자리를 바꿈

- 마지막에 2개 원소 중 최솟값을 선택하여 자리를 바꿈으로써 오름차순 정렬의 마무리

(2) 알고리즘

- 입력 : 크키가 n인 배열 A

- 출력 : 정리된 배열 A

ⓐ for i = 0 to n-2 {

ⓑ min = i

ⓓ if(A[j] < A[min]) : min = j

ⓔ A[i] ↔ A[min] }}

ⓕ return 배열 A

(3) 시간 복잡도 = O(n(n-1)/2) = O(n^2)

(4) 특징

- 입력에 민감하지 않은 알고리즘

- 거의 정렬되어 있는지 구분하지 않음

- 역으로 정렬되어 있는지 구분하지 않음

- 랜덤하게 되어있는지 구분하지 않음

- 항상 일정한 시간 복잡도를 나타냄

3. 삽입 정렬

(1) 정의

- 배열을 정렬된 부분(앞부분)과 정렬 안된 부분(뒷부분)으로 나누고 정렬 안된 부분의 가장 왼쪽 원소를 정렬된 부분의 적절한 위치에 삽입하여 정렬되도록 하는 과정을 반복함

(2) 알고리즘

- 입력 : 크기가 n인 배열 A

- 출력 : 정리된 배열 A

ⓐ for i = 1 to n-1

ⓑ CurrentElement = A[i]

ⓓ while (j>=0 and A[j] > CurrentElement) {

ⓔ A[j+1] = A[j] }

ⓕ A[j+1] = CurrentElement }

ⓖ return A

(3) 시간 복잡도 = 최악의 경우 O(n^2)

(4) 특징

- 입력의 상태에 따라 수행 시간이 달라짐

- 입력이 이미 정렬되어 있으면 각각 Current Element가 자신의 왼쪽 원소봐 비교 후 자리 이동 없이 원래 자기 자리에 있게되고 while 루프의 조건이 항상 거짓이므로 원소의 이동도 없음

- n-1 비교만 진행하면 됨

- 최선의 경우 시간 복잡도 = O(n), 삽입 정렬은 거의 정렬된 입력에 대해서 다른 정렬 알고리즘보다 빠르다

- 최악의 경우 시간 복잡도 = O(n^2), 역으로 정렬된 입력에 대해서는 O(n^2)의 시간이 걸림

[자료구조] 트리

혜머니 — Mon, 18 May 2026 12:01:56 +0900

1. 트리와 이진트리

(1) 트리의 개념

- 트리 : 계층적인 자료의 표현에 적합한 구조

- 루트 노드, 부모/자식/형제, 조상/자손, 간선(에지), 단말(자식이 없는 노드)/비단말 노드(자식이 있는 노드)

- 노드의 차수(자식의 개수), 트리의 차수(각 노드의 차수 중 MAX), 레벨(각 층), 트리의 높이(최대 층의 높이)

(2) 이진 트리

- 모든 노드가 2개의 서브 트리를 가진 트리

- 공집합이거나, 루트와 왼쪽 서브트리, 오른쪽 서브트리로 구성된 노드들의 집합(서브 트리들도 모두 이진트리)

- 포화 이진트리 : 각 레벨의 노드가 꽉 차있는 이진 트리

- 완전 이진트리 : 높이가 h이면 레벨 h-1까지는 노드가 꽉 차고, 마지막 레벨 h는 노드가 순서대로 채워진 트리

- 이진 트리의 성질 : 간선의 개수 = 노드의 개수 -1, 높이가 h일 때 최소 노드의 개수 = 2^h -1

n > 노드 n개인 이진 트리 높이 h > log(2)(n+1) 이상

- 순회 연산 : 트리에 속하는 모든 노드를 한번씩 방문하는 것

- 전위 순회 : 레벨 계산, 문서 출력 = 루트 노드(V) 왼쪽 서브 쿼리(L) 오른쪽 서브 쿼시(R) 순으로 사용

- 중위 순회 : 정렬 = LVR

- 후위 순회 : 폴더 용량 계산 = LRV

- 레벨 순회 : 노드를 레벨 순으로 검사, 큐를 사용하고 순환을 사용하지 않음

class Node :
    def __init__(self, elem, link=None) :
        self.data = elem
        self.link = link
class circularQueue :
    def __init__ (self) :
        self.tail = None
    def isEmpty(self) : return self.tail == None
    def clear(self) : self.tail = None
    def peek(self) :
        if not self.isEmpty() :
            return self.tail.link.data
    def enqueue(self, item) :
        node = Node(item, None)
        if self.isEmpty() :
            node.link = node
            self.tall = node
        else :
            node.link = self.tail.link
            self.tail.link = node
            self.tail = node
    def dequeue(self) :
        if not isEmpty() :
            data = self.tail.link.data
            if self.tail.link == self.tail :
                self.tail = None
            else :
                self.tail.link = self.tail.link.link
            return data
    def size(self) :
        if self.isEmpty() : return 0
        else :
            count = 1
            node = self.tail.link
            while not node == self.tail :
                node = node.link
                count += 1
            return count
    def display(self, msg = 'que : ') :
        print(msg, end ='')
        if not self.isEmpty() :
            n = self.tail.link
            while not n == self.tail :
                print(n.data, end=' ' )
                n = n.link
            print(n.date, end =' ' )
        print()

class TNode :
    def __init__(self, data, left, right) :
        self.data = data
        self.left = left
        self.right = right

def preorder(n) :
    if n is not None :
        print(n.data, end=' ')
        preorder(n.left)
        preorder(n.right)

def inorder(n) :
    if n is not None :
        inorder(n.left)
        print(n.data, end=' ')
        inorder(n.right)

def postorder(n) :
    if n is not None :
        postorder(n.left)
        postorder(n.right)
        print(n.data, end=' ')

def levelorder(root) :
    queue = circularQueue()
    queue.enqueue(root)
    while not queue.isEmpty() :
        n = queue.dequeue()
        if n is not None :
            print(n.data, end=' ' )
            queue.enqueue(n.left)
            queue.enqueue(n.right)

d = TNode('D',None,None)
e = TNode('E',None,None)
b = TNode('B',d,e)
f = TNode('F',None,None)
c = TNode('C',f,None)
root = TNode('A',b,c)

print('In-order : ', end = ' ')
inorder(root)
print()
print('Pre-order : ', end = ' ')
preorder(root)
print()
print('post-order : ', end = ' ')
postorder(root)
print()
print('level-order : ', end = ' ')
levelorder(root)
print()

print("노드 개수 : %d 개" %count_node(root))
print("단말 개수 : %d 개" %count_leaf(root))
print("높이 : %d " %cal_height(root))

In-order :  D B E A F C
Pre-order :  A B D E C F
post-order :  D E B F C A
level-order :

- 노드 개수 및 높이 반환 함수

# 전체 노드의 수
def count_node(n) :
    if n is None :
        return 0
    else :
        return 1+count_node(n.left)+count_node(n.right)

# 단말 노드의 수
def count_leaf(n) :
    if n is None :
        return 0
    elif n.left is None and n.right is None :
        return 1
    else :
        return 1+count_leaf(n.left)+count_leaf(n.right)

# 높이
def cal_height (n) :
    if n is None :
        return 0
    hLeft = cal_height(n.left)
    hRight = cal_height(n.right)
    if (hLeft > hRight) :
        return hLeft+1
    else :
        return hRight+1

노드 개수 : 6 개
단말 개수 : 6 개
높이 : 3

2. 힙

(1) 힙의 개념과 연산

- 더미와 모습이 비슷한 완전 이진 트리 기반의 자료 구조

- 가장 큰, 작은 값을 빠르게 찾아내도록 만들어진 자료구조

- 최대 힙 : 부모 노드의 키 값이 자식 노드의 키 값보다 크거나 같은 완전 이진 트리

- 최소 힙 : 부모 노드의 키 값이 자식 노드의 키 값보다 작거나 같은 완전 이진 트리

- 삽입(upheap) : 일단 말단에 놓고 비교하며 위로 올림, 시간 복잡도 최악의 경우 O(log(2)n)

> 루트까지 올라가야 하므로 트리 높이에 해당하는 비교 및 이동 연산

- 삭제(downheap) : 말단을 일단 위로 올리고 비교하며 아래로 내림 O(log(2)n)

> 가장 아래까지 내려가야 하므로 트리 높이에 해당하는 비교 연산이 필요

- 구조 : 보통 배열을 이용하여 구현, 완전 이진 트리는 각 노드에 번호를 붙여 배열의 인덱스로 표현

- 힙의 응용 : 허프만 코드 = 이진 트리를 이용하여 글자별 빈도가 다른 메시지의 내용을 압축