SundayJun9, database overview, sql and database programming

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']

데이터베이스에서의 자료구조 사용 사례

  1. 인덱스 (Index):
    • B-트리, B+트리: 인덱스를 구성하여 데이터 검색 속도를 향상.
    • 해시 인덱스: 고정된 크기의 데이터 검색에 유리.
  2. 트랜잭션 로그 (Transaction Log):
    • 연결 리스트, 배열: 변경 내역을 기록하여 데이터 복구 및 일관성 유지.
  3. 버퍼 캐시 (Buffer Cache):
    • 해시 테이블, 큐: 자주 사용되는 데이터를 캐시하여 접근 속도 향상.
  4. 관계형 데이터 모델 (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']

데이터베이스 자료구조의 사용 사례 요약

  1. 인덱스 (Index):
    • B-트리, B+트리: 데이터 검색 속도 향상.
    • 해시 인덱스: 고정된 크기의 데이터 검색에 유리.
  2. 트랜잭션 로그 (Transaction Log):
    • 연결 리스트, 배열: 변경 내역 기록.
  3. 버퍼 캐시 (Buffer Cache):
    • 해시 테이블, 큐: 자주 사용되는 데이터 캐시.
  4. 관계형 데이터 모델 (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

TitleTypeExcerpt