• 비유: 이미 반쯤 정리된 책 더미에서, 잘 정리된 작은 묶음(덩어리) 들을 찾아 붙여서 끝내기.

• 장점: 거의 정리돼 있으면 엄청 빠름(⚡), 보통 때도 빠름.

• 동점 처리: 같은 값이면 원래 순서 그대로 유지(안정 정렬).

• 한 줄로: 파이썬이 기본으로 쓰는 똑똑한 실전 왕.

2) Heap Sort (힙정렬)

• 비유: 모래언덕(힙) 꼭대기에 가장 작은 돌이 항상 올라오게 만든 뒤, 하나씩 꺼내 바구니에 담기.

• 장점: 항상 꾸준히 빠른 편(🙂~⚡), 최악 상황에서도 너무 느려지지 않음.

• 주의: 같은 값의 원래 순서는 바뀔 수 있음(보통 비안정).

• 한 줄로: 상위 몇 개 뽑기(Top-K) 같은 데도 잘 맞는 튼튼한 방법.

3) Merge Sort (합병정렬)

• 비유: 더미를 반으로 쪼개고, 각각 정리한 뒤 두 묶음을 합치기(작은 것부터 차례대로 섞기).

• 장점: 크기가 커도 속도가 일정하고 믿음직(🙂~⚡), 디스크 파일 같은 큰 자료에도 잘 맞음.

• 주의: 임시 바구니(추가 메모리)가 필요함.

• 동점 처리: 보통 원래 순서 지킴(안정 정렬로 구현 가능).

• 한 줄로: 쪼개고 합치는 착실한 방법.

4) Quick Sort (퀵정렬)

• 비유: 기준막대(피벗) 하나를 뽑아 작은 것 / 같은 것 / 큰 것으로 세 무더기로 나누고, 작은 무더기·큰 무더기를 다시 같은 방식으로 나누기.

• 장점: 평균적으로 아주 빠름(⚡), 코드 아이디어가 간단함.

• 주의: 운이 나쁘면 느려질 수 있음(🐢), 보통 동점 순서는 안 지킴.

• 한 줄로: 평균은 번개, 가끔 운 나쁘면 거북이.

5) Insertion Sort (삽입정렬)

• 비유: 카드놀이처럼 손에 든 카드를 알맞은 자리에 하나씩 끼워 넣기.

• 장점: 거의 정리된 상태에선 아주 빠름(⚡), 작은 개수에 좋음. 동점 순서 지킴(안정).

• 주의: 많이 섞여 있고 개수가 크면 느림(🐢).

• 한 줄로: 조금만 섞였을 때 최강, 많이 섞이면 느림.

6) Selection Sort (선택정렬)

• 비유: 남은 것들 중 제일 작은 것만 골라 앞에 붙이기, 그리고 반복.

• 장점: 바꾸는 횟수(교환)가 적음.

• 주의: 비교가 너무 많아 느림(🐢), 보통 동점 순서 안 지킴.

• 한 줄로: 교환은 적지만 속도는 느린 기본기용.

7) Bubble Sort (버블정렬)

• 비유: 이웃끼리 비교해서 큰 것을 뒤로 뒤로 밀어 올려 보내기(거품이 “보글보글” 올라가듯).

• 장점: 아주 간단, 한 바퀴 돌 때 아무 것도 안 바뀌면 바로 끝낼 수 있음.

• 주의: 전체적으로 매우 느림(🐢), 하지만 동점 순서는 지킴(안정).

• 한 줄로: 가장 쉬운 대신 가장 느린 연습용.

# 파이썬 내장 정렬(Timsort)로 정렬한 뒤 소요 시간을 출력

import random

import time

# 재현 가능성을 위해 시드 고정(원하면 변경/삭제)

SEED = 20251107

random.seed(SEED)

# A 생성: 1..1000 무작위 순열

A = list(range(1, 1001))

random.shuffle(A)

# Timsort로 정렬(파이썬의 sorted()/list.sort()는 Timsort 사용)

t0 = time.perf_counter()

A_sorted = sorted(A) # 오름차순

t1 = time.perf_counter()

elapsed = t1 - t0

print(f"정렬 소요 시간: {elapsed*1e6:.0f} µs ({elapsed*1e3:.3f} ms)")

# (검증용) 앞/뒤 일부 출력

print("정렬 결과 앞 10개:", A_sorted[:10])

print("정렬 결과 뒤 10개:", A_sorted[-10:])

# Heap Sort(힙 정렬, in-place)로 정렬한 뒤 소요 시간을 출력합니다.

import random

import time

# 재현 가능성을 위해 시드 고정

SEED = 20251107

random.seed(SEED)

# A 생성: 1..1000 무작위 순열

A = list(range(1, 1001))

random.shuffle(A)

# ---------------------------

# Heap Sort (max-heap, in-place)

# ---------------------------

def siftdown(a, n, i):

"""a[0:n] 구간에서 인덱스 i를 루트로 하는 부분트리를 max-heap이 되도록 내려보냄."""

while True:

left = 2 * i + 1

right = 2 * i + 2

largest = i

if left < n and a[left] > a[largest]:

largest = left

if right < n and a[right] > a[largest]:

largest = right

if largest == i:

break

a[i], a[largest] = a[largest], a[i]

i = largest

def heap_sort(a):

n = len(a)

# 1) build max-heap

for i in range(n // 2 - 1, -1, -1):

siftdown(a, n, i)

# 2) extract max to the end, shrink heap

for end in range(n - 1, 0, -1):

a[0], a[end] = a[end], a[0] # 루트(최댓값)와 끝 교환

siftdown(a, end, 0) # 줄어든 힙 구간에서 재정렬

return a

# 정렬 및 타이밍

B = A[:] # 원본 보존

t0 = time.perf_counter()

heap_sort(B)

t1 = time.perf_counter()

elapsed = t1 - t0

print(f"Heap Sort 소요 시간: {elapsed*1e6:.0f} µs ({elapsed*1e3:.3f} ms)")

print("정렬 결과 앞 10개:", B[:10])

print("정렬 결과 뒤 10개:", B[-10:])

# (참고) heapq로 힙을 만들어 정렬하는 간단 대안 (알고리즘 학습 목적과는 다름)

# import heapq

# H = A[:]

# heapq.heapify(H)

# C = [heapq.heappop(H) for _ in range(len(H))]

# Merge Sort(합병 정렬)로 정렬한 뒤 소요 시간을 출력합니다.

import random

import time

# 재현 가능성을 위해 시드 고정

SEED = 20251107

random.seed(SEED)

# A 생성: 1..1000 무작위 순열

A = list(range(1, 1001))

random.shuffle(A)

# ---------------------------

# Merge Sort (stable, returns new list)

# ---------------------------

def merge(left, right):

i = j = 0

out = []

while i < len(left) and j < len(right):

# 안정성 유지(동점이면 left가 먼저)

if left[i] <= right[j]:

out.append(left[i]); i += 1

else:

out.append(right[j]); j += 1

out.extend(left[i:])

out.extend(right[j:])

return out

def merge_sort(a):

n = len(a)

if n <= 1:

return a[:]

mid = n // 2

left = merge_sort(a[:mid])

right = merge_sort(a[mid:])

return merge(left, right)

# 정렬 및 타이밍

t0 = time.perf_counter()

A_sorted = merge_sort(A)

t1 = time.perf_counter()

elapsed = t1 - t0

print(f"Merge Sort 소요 시간: {elapsed*1e6:.0f} µs ({elapsed*1e3:.3f} ms)")

print("정렬 결과 앞 10개:", A_sorted[:10])

print("정렬 결과 뒤 10개:", A_sorted[-10:])

# Quick Sort(퀵 정렬)로 정렬한 뒤 소요 시간을 출력합니다.

import random

import time

# 재현 가능성을 위해 시드 고정

SEED = 20251107

random.seed(SEED)

# A 생성: 1..1000 무작위 순열

A = list(range(1, 1001))

random.shuffle(A)

# ---------------------------

# Quick Sort (returns new list)

# - 작은 구간은 삽입정렬로 처리(속도 향상)

# - 피벗은 무작위 선택(최악 케이스 회피)

# ---------------------------

_CUTOFF = 32

def insertionsort(a):

a = a[:]

for i in range(1, len(a)):

key = a[i]

j = i - 1

while j >= 0 and a[j] > key:

a[j + 1] = a[j]

j -= 1

a[j + 1] = key

return a

def quick_sort(a):

n = len(a)

if n <= _CUTOFF:

return insertionsort(a)

pivot = a[random.randrange(n)]

left = [x for x in a if x < pivot]

mid = [x for x in a if x == pivot]

right = [x for x in a if x > pivot]

return quick_sort(left) + mid + quick_sort(right)

# 정렬 및 타이밍

t0 = time.perf_counter()

A_sorted = quick_sort(A)

t1 = time.perf_counter()

elapsed = t1 - t0

print(f"Quick Sort 소요 시간: {elapsed*1e6:.0f} µs ({elapsed*1e3:.3f} ms)")

print("정렬 결과 앞 10개:", A_sorted[:10])

print("정렬 결과 뒤 10개:", A_sorted[-10:])

# Insertion Sort(삽입 정렬)로 정렬한 뒤 소요 시간을 출력합니다.

import random

import time

# 재현 가능성을 위해 시드 고정

SEED = 20251107

random.seed(SEED)

# A 생성: 1..1000 무작위 순열

A = list(range(1, 1001))

random.shuffle(A)

# ---------------------------

# Insertion Sort (stable, returns new list)

# ---------------------------

def insertion_sort(a):

arr = a[:] # 원본 보존

for i in range(1, len(arr)):

key = arr[i]

j = i - 1

# key보다 큰 원소들을 한 칸씩 뒤로 민다

while j >= 0 and arr[j] > key:

arr[j + 1] = arr[j]

j -= 1

arr[j + 1] = key

return arr

# 정렬 및 타이밍

t0 = time.perf_counter()

A_sorted = insertion_sort(A)

t1 = time.perf_counter()

elapsed = t1 - t0

print(f"Insertion Sort 소요 시간: {elapsed*1e6:.0f} µs ({elapsed*1e3:.3f} ms)")

print("정렬 결과 앞 10개:", A_sorted[:10])

print("정렬 결과 뒤 10개:", A_sorted[-10:])

# (검증) 파이썬 내장 정렬 결과와 동일한지 확인

assert A_sorted == sorted(A)

# Selection Sort(선택 정렬)로 정렬한 뒤 소요 시간을 출력합니다.

import random

import time

# 재현 가능성을 위해 시드 고정

SEED = 20251107

random.seed(SEED)

# A 생성: 1..1000 무작위 순열

A = list(range(1, 1001))

random.shuffle(A)

# ---------------------------

# Selection Sort (returns new list)

# ---------------------------

def selection_sort(a):

arr = a[:] # 원본 보존

n = len(arr)

for i in range(n - 1):

min_idx = i

for j in range(i + 1, n):

if arr[j] < arr[min_idx]:

min_idx = j

if min_idx != i:

arr[i], arr[min_idx] = arr[min_idx], arr[i]

return arr

# 정렬 및 타이밍

t0 = time.perf_counter()

A_sorted = selection_sort(A)

t1 = time.perf_counter()

elapsed = t1 - t0

print(f"Selection Sort 소요 시간: {elapsed*1e6:.0f} µs ({elapsed*1e3:.3f} ms)")

print("정렬 결과 앞 10개:", A_sorted[:10])

print("정렬 결과 뒤 10개:", A_sorted[-10:])

# (검증) 파이썬 내장 정렬 결과와 동일한지 확인

assert A_sorted == sorted(A)

# Bubble Sort(버블 정렬)로 정렬한 뒤 소요 시간을 출력합니다.

import random

import time

# 재현 가능성을 위해 시드 고정

SEED = 20251107

random.seed(SEED)

# A 생성: 1..1000 무작위 순열

A = list(range(1, 1001))

random.shuffle(A)

# ---------------------------

# Bubble Sort (stable, returns new list)

# ---------------------------

def bubble_sort(a):

arr = a[:] # 원본 보존

n = len(arr)

for i in range(n - 1):

swapped = False

for j in range(n - 1 - i):

if arr[j] > arr[j + 1]:

arr[j], arr[j + 1] = arr[j + 1], arr[j]

swapped = True

if not swapped: # 한 바퀴 동안 교환이 없으면 조기 종료

break

return arr

# 정렬 및 타이밍

t0 = time.perf_counter()

A_sorted = bubble_sort(A)

t1 = time.perf_counter()

elapsed = t1 - t0

print(f"Bubble Sort 소요 시간: {elapsed*1e6:.0f} µs ({elapsed*1e3:.3f} ms)")

print("정렬 결과 앞 10개:", A_sorted[:10])

print("정렬 결과 뒤 10개:", A_sorted[-10:])

# (검증) 파이썬 내장 정렬 결과와 동일한지 확인

assert A_sorted == sorted(A)

그 배치를 분석하여 가장 효율적인 정렬방법이 무엇일지를 판단한다.

판단 후 그 정렬방식을 이용하여 데이터를 효율적으로 정렬한다.

2. 어떠한 정렬방식을 사용해야하는지 판단하는 알고리즘이 필요하다.

내 생각엔 2가지 경우가 있을거같은데