- 데이터베이스의 자료구조
- 데이터베이스에서의 자료구조 사용 사례
- 데이터베이스의 자료구조 요약표
- 데이터베이스 자료구조의 사용 사례 요약
- 퀴즈
- Tree Data Structures
- Sorting Algorithms
75 개요, 76 설계, 77 데이터델, 78 개체관계 모델, 79 구조, 80약조건key, ddl dcl dml 절차형sql procedure optimization
데이터베이스의 자료구조
데이터베이스에서 사용되는 자료구조는 데이터를 효율적으로 저장하고 검색하는 데 중요한 역할을 합니다. 주요 자료구조와 그 특징을 정리해보겠습니다.
1. 배열 (Array)
- 정의: 동일한 데이터 타입의 연속된 메모리 블록으로 구성된 자료구조.
- 특징: 인덱스를 사용하여 고정된 크기의 데이터를 빠르게 접근 가능.
- 사용 사례: 데이터베이스의 인덱스 구조, 히스토그램 등.
예시:
arr = [1, 2, 3, 4, 5]
print(arr[2]) # 출력: 3
2. 연결 리스트 (Linked List)
- 정의: 각 노드가 데이터와 다음 노드를 가리키는 포인터를 포함하는 자료구조.
- 특징: 삽입과 삭제가 용이하지만, 인덱스를 사용한 접근 속도가 느림.
- 사용 사례: 데이터베이스의 로그 구조 저장, 메모리 할당 알고리즘 등.
예시:
class Node:
def __init__(self, data):
self.data = data
self.next = None
head = Node(1)
second = Node(2)
head.next = second
print(head.next.data) # 출력: 2
3. 스택 (Stack)
- 정의: LIFO (Last In, First Out) 원칙을 따르는 자료구조.
- 특징: 마지막에 삽입된 데이터가 가장 먼저 제거됨.
- 사용 사례: 데이터베이스 트랜잭션 관리, 역추적 알고리즘 등.
예시:
stack = []
stack.append(1)
stack.append(2)
print(stack.pop()) # 출력: 2
4. 큐 (Queue)
- 정의: FIFO (First In, First Out) 원칙을 따르는 자료구조.
- 특징: 먼저 삽입된 데이터가 먼저 제거됨.
- 사용 사례: 데이터베이스 작업 큐, 인쇄 대기열 등.
예시:
from collections import deque
queue = deque([1, 2, 3])
queue.append(4)
print(queue.popleft()) # 출력: 1
5. 해시 테이블 (Hash Table)
- 정의: 키-값 쌍을 저장하는 자료구조로, 해시 함수를 사용하여 키를 인덱스로 변환.
- 특징: 평균적으로 빠른 데이터 접근 속도를 제공.
- 사용 사례: 데이터베이스 인덱스, 캐싱 등.
예시:
hash_table = {}
hash_table['key1'] = 'value1'
print(hash_table['key1']) # 출력: value1
6. 트리 (Tree)
- 정의: 계층적인 데이터 구조로, 루트 노드에서 시작하여 자식 노드로 확장.
- 특징: 데이터의 계층적 표현이 가능, 탐색과 정렬이 용이.
- 사용 사례: 데이터베이스 인덱스 (B-트리, B+트리), 파일 시스템 등.
예시:
class TreeNode:
def __init__(self, data):
self.data = data
self.children = []
root = TreeNode(1)
child1 = TreeNode(2)
root.children.append(child1)
print(root.children[0].data) # 출력: 2
7. 그래프 (Graph)
- 정의: 노드(정점)와 노드 사이의 연결(간선)으로 이루어진 자료구조.
- 특징: 복잡한 관계를 표현할 수 있음, 네트워크 모델에 적합.
- 사용 사례: 소셜 네트워크, 도로망, 추천 시스템 등.
예시:
graph = {
'A': ['B', 'C'],
'B': ['A', 'D', 'E'],
'C': ['A', 'F'],
'D': ['B'],
'E': ['B', 'F'],
'F': ['C', 'E']
}
print(graph['A']) # 출력: ['B', 'C']
데이터베이스에서의 자료구조 사용 사례
- 인덱스 (Index):
- B-트리, B+트리: 인덱스를 구성하여 데이터 검색 속도를 향상.
- 해시 인덱스: 고정된 크기의 데이터 검색에 유리.
- 트랜잭션 로그 (Transaction Log):
- 연결 리스트, 배열: 변경 내역을 기록하여 데이터 복구 및 일관성 유지.
- 버퍼 캐시 (Buffer Cache):
- 해시 테이블, 큐: 자주 사용되는 데이터를 캐시하여 접근 속도 향상.
- 관계형 데이터 모델 (Relational Data Model):
- 그래프, 트리: 데이터 간의 관계를 표현하고 최적화된 쿼리 성능을 제공.
데이터베이스의 자료구조 요약표
자료구조 | 정의 | 특징 | 사용 사례 | 예시 코드 (Python) |
---|---|---|---|---|
배열 (Array) | 동일한 데이터 타입의 연속된 메모리 블록 | 인덱스를 사용한 빠른 접근, 고정된 크기 | 인덱스 구조, 히스토그램 | arr = [1, 2, 3, 4, 5]\nprint(arr[2]) # 출력: 3 |
연결 리스트 (Linked List) | 노드가 데이터와 다음 노드를 가리키는 포인터 포함 | 삽입/삭제 용이, 인덱스 접근 속도 느림 | 로그 구조 저장, 메모리 할당 알고리즘 | class Node:\n def __init__(self, data):\n self.data = data\n self.next = None\nhead = Node(1)\nsecond = Node(2)\nhead.next = second\nprint(head.next.data) # 출력: 2 |
스택 (Stack) | LIFO (Last In, First Out) 원칙을 따름 | 마지막 삽입 데이터가 먼저 제거됨 | 트랜잭션 관리, 역추적 알고리즘 | stack = []\nstack.append(1)\nstack.append(2)\nprint(stack.pop()) # 출력: 2 |
큐 (Queue) | FIFO (First In, First Out) 원칙을 따름 | 먼저 삽입된 데이터가 먼저 제거됨 | 작업 큐, 인쇄 대기열 | from collections import deque\nqueue = deque([1, 2, 3])\nqueue.append(4)\nprint(queue.popleft()) # 출력: 1 |
해시 테이블 (Hash Table) | 키-값 쌍을 저장, 해시 함수를 사용하여 키를 인덱스로 변환 | 평균적으로 빠른 데이터 접근 속도 제공 | 인덱스, 캐싱 | hash_table = {}\nhash_table['key1'] = 'value1'\nprint(hash_table['key1']) # 출력: value1 |
트리 (Tree) | 계층적 데이터 구조, 루트 노드에서 시작하여 자식 노드로 확장 | 계층적 데이터 표현, 탐색과 정렬 용이 | 인덱스 (B-트리, B+트리), 파일 시스템 | class TreeNode:\n def __init__(self, data):\n self.data = data\n self.children = []\nroot = TreeNode(1)\nchild1 = TreeNode(2)\nroot.children.append(child1)\nprint(root.children[0].data) # 출력: 2 |
그래프 (Graph) | 노드(정점)와 노드 사이의 연결(간선)로 이루어진 구조 | 복잡한 관계 표현 가능, 네트워크 모델에 적합 | 소셜 네트워크, 도로망, 추천 시스템 | graph = {\n 'A': ['B', 'C'],\n 'B': ['A', 'D', 'E'],\n 'C': ['A', 'F'],\n 'D': ['B'],\n 'E': ['B', 'F'],\n 'F': ['C', 'E']\n}\nprint(graph['A']) # 출력: ['B', 'C'] |
데이터베이스 자료구조의 사용 사례 요약
- 인덱스 (Index):
- B-트리, B+트리: 데이터 검색 속도 향상.
- 해시 인덱스: 고정된 크기의 데이터 검색에 유리.
- 트랜잭션 로그 (Transaction Log):
- 연결 리스트, 배열: 변경 내역 기록.
- 버퍼 캐시 (Buffer Cache):
- 해시 테이블, 큐: 자주 사용되는 데이터 캐시.
- 관계형 데이터 모델 (Relational Data Model):
- 그래프, 트리: 데이터 간의 관계 표현, 최적화된 쿼리 성능 제공.
Click to open
퀴즈
Quiz 1: 배열 (Array)
Q1: What is the primary characteristic of an array?
- A) Can store different data types
- B) Stores data in non-contiguous memory locations
- C) Allows random access to elements
- D) Automatically resizes based on the data
Read as: “What is the primary characteristic of an array? Can store different data types; Stores data in non-contiguous memory locations; Allows random access to elements; Automatically resizes based on the data.”
Answer: C) Allows random access to elements
Quiz 2: 스택 (Stack)
Q2: What is the output of the following Python code?
stack = []
stack.append(1)
stack.append(2)
print(stack.pop())
- A) 1
- B) 2
- C) [1, 2]
- D) []
Read as: “What is the output of the following Python code? stack equals empty list; stack append 1; stack append 2; print stack pop.”
Answer: B) 2
Quiz 3: 트리 (Tree)
Q3: In a tree data structure, what is the topmost node called?
- A) Leaf node
- B) Parent node
- C) Child node
- D) Root node
Read as: “In a tree data structure, what is the topmost node called? Leaf node; Parent node; Child node; Root node.”
Answer: D) Root node
데이터베이스에서 자료구조의 중요성과 다양한 자료구조의 사용 사례를 이해하고, 퀴즈를 통해 복습해 보세요.
Tree Data Structures
자료구조 | 정의 | 특징 | 사용 사례 | 예시 코드 (Python) |
---|---|---|---|---|
이진 트리 (Binary Tree) | 각 노드가 최대 두 개의 자식을 갖는 트리 구조 | 탐색, 삽입, 삭제의 평균 시간 복잡도 O(log n) | 검색 트리, 힙 | class Node:\n def __init__(self, key):\n self.left = None\n self.right = None\n self.val = key\nroot = Node(1)\nroot.left = Node(2)\nroot.right = Node(3) |
이진 탐색 트리 (Binary Search Tree, BST) | 왼쪽 자식은 부모보다 작고, 오른쪽 자식은 부모보다 큰 이진 트리 | 정렬된 순서로 데이터 저장, 효율적인 탐색 | 데이터베이스, 파일 시스템 | class BSTNode:\n def __init__(self, key):\n self.left = None\n self.right = None\n self.val = key\n\n# Insert method for BST\n def insert(root, key):\n if root is None:\n return BSTNode(key)\n if key < root.val:\n root.left = insert(root.left, key)\n else:\n root.right = insert(root.right, key)\n return root\n\n# Example usage\nroot = BSTNode(50)\nroot = insert(root, 30)\nroot = insert(root, 20)\nroot = insert(root, 40)\nroot = insert(root, 70)\nroot = insert(root, 60)\nroot = insert(root, 80) |
AVL 트리 (AVL Tree) | 각 노드의 서브트리 높이 차이가 1 이하인 자가 균형 이진 탐색 트리 | 삽입, 삭제 시 자동으로 균형을 유지 | 메모리 관리, 수신기 간섭 제거 | class AVLNode:\n def __init__(self, key):\n self.left = None\n self.right = None\n self.val = key\n self.height = 1\n\n# Function to insert a node\n def insert(root, key):\n # Perform the normal BST insertion\n if not root:\n return AVLNode(key)\n elif key < root.val:\n root.left = insert(root.left, key)\n else:\n root.right = insert(root.right, key)\n\n # Update the height of the ancestor node\n root.height = 1 + max(height(root.left), height(root.right))\n\n # Get the balance factor\n balance = get_balance(root)\n\n # Balance the tree\n if balance > 1 and key < root.left.val:\n return right_rotate(root)\n if balance < -1 and key > root.right.val:\n return left_rotate(root)\n if balance > 1 and key > root.left.val:\n root.left = left_rotate(root.left)\n return right_rotate(root)\n if balance < -1 and key < root.right.val:\n root.right = right_rotate(root.right)\n return left_rotate(root)\n\n return root |
힙 (Heap) | 완전 이진 트리의 일종으로 우선순위 큐 구현에 사용 | 최대 힙과 최소 힙으로 나뉨, 삽입/삭제 O(log n) | 우선순위 큐, 힙 정렬 | import heapq\n# Creating a heap\nheap = []\nheapq.heappush(heap, 3)\nheapq.heappush(heap, 1)\nheapq.heappush(heap, 2)\nprint(heapq.heappop(heap)) # 출력: 1 |
Sorting Algorithms
알고리즘 | 정의 | 특징 | 사용 사례 | 예시 코드 (Python) |
---|---|---|---|---|
버블 정렬 (Bubble Sort) | 인접한 두 원소를 비교하여 정렬하는 단순한 알고리즘 | 구현이 매우 간단하지만, 시간 복잡도는 O(n^2) | 교육 목적, 소규모 데이터 정렬 | def bubble_sort(arr):\n n = len(arr)\n for i in range(n):\n for j in range(0, n-i-1):\n if arr[j] > arr[j+1]:\n arr[j], arr[j+1] = arr[j+1], arr[j]\narr = [64, 34, 25, 12, 22, 11, 90]\nbubble_sort(arr)\nprint(arr) |
선택 정렬 (Selection Sort) | 가장 작은(또는 큰) 원소를 선택하여 순서대로 정렬 | 시간 복잡도는 O(n^2), 메모리 효율적 | 소규모 데이터 정렬 | def selection_sort(arr):\n for i in range(len(arr)):\n min_idx = i\n for j in range(i+1, len(arr)):\n if arr[min_idx] > arr[j]:\n min_idx = j\n arr[i], arr[min_idx] = arr[min_idx], arr[i]\narr = [64, 25, 12, 22, 11]\nselection_sort(arr)\nprint(arr) |
삽입 정렬 (Insertion Sort) | 현재 원소를 올바른 위치에 삽입하여 정렬 | 대부분의 원소가 정렬된 경우 효율적, O(n^2) | 소규모 데이터 정렬, 실시간 데이터 정렬 | def insertion_sort(arr):\n for i in range(1, len(arr)):\n key = arr[i]\n j = i-1\n while j >= 0 and key < arr[j]:\n arr[j+1] = arr[j]\n j -= 1\n arr[j+1] = key\narr = [12, 11, 13, 5, 6]\ninsertion_sort(arr)\nprint(arr) |
퀵 정렬 (Quick Sort) | 분할 정복 알고리즘으로, 피벗을 기준으로 분할하여 정렬 | 평균 시간 복잡도는 O(n log n), 최악 O(n^2) | 대규모 데이터 정렬 | def quick_sort(arr):\n if len(arr) <= 1:\n return arr\n else:\n pivot = arr[len(arr) // 2]\n left = [x for x in arr if x < pivot]\n middle = [x for x in arr if x == pivot]\n right = [x for x in arr if x > pivot]\n return quick_sort(left) + middle + quick_sort(right)\narr = [3, 6, 8, 10, 1, 2, 1]\nprint(quick_sort(arr)) |
병합 정렬 (Merge Sort) | 분할 정복 알고리즘으로, 리스트를 반으로 나눠 정렬 | 안정적인 정렬, 시간 복잡도는 O(n log n) | 연결 리스트 정렬, 외부 정렬 | def merge_sort(arr):\n if len(arr) > 1:\n mid = len(arr) // 2\n L = arr[:mid]\n R = arr[mid:]\n merge_sort(L)\n merge_sort(R)\n i = j = k = 0\n while i < len(L) and j < len(R):\n if L[i] < R[j]:\n arr[k] = L[i]\n i += 1\n else:\n arr[k] = R[j]\n j += 1\n k += 1\n while i < len(L):\n arr[k] = L[i]\n i += 1\n k += 1\n while j < len(R):\n arr[k] = R[j]\n j += 1\n k += 1\narr = [12, 11, 13, 5, 6, 7]\nmerge_sort(arr)\nprint(arr) |
The following wiki, pages and posts are tagged with
Title | Type | Excerpt |
---|