pridiot

[백준][Java, 2588] 곱셈

Pridiot — Fri, 17 Sep 2021 19:30:47 +0900

2588번: 곱셈

첫째 줄부터 넷째 줄까지 차례대로 (3), (4), (5), (6)에 들어갈 값을 출력한다.

www.acmicpc.net

문제

세 자릿수 곱셈에서 (3), (4), (5), (6) 위치에 들어갈 값을 출력

입력

첫째 줄에는 (1)의 위치에 들어갈 세 자리 자연수, 둘째 줄에 (2)의 위치에 들어갈 세 자리 자연수가 주어진다.

출력

첫째 줄부터 넷째 줄 까지 차례대로 (3), (4), (5), (6)의 값을 출력

예제 입력

472
385

예제 출력

코드

1. 입력값을 문자열로 처리하는 경우

import java.util.*;

public class Main {
	public static void main(String[] args) {
		String num1, num2;
		int sum, pos;
	
		Scanner sc = new Scanner(System.in);
		
		num1 = sc.nextLine();
		num2 = sc.nextLine();
		
		for (int i = 2 ; i >= 0 ; i--) {
			sum = 0;
			pos = 1;
			for (int j = 2 ; j >= 0 ; j--) {
				sum += Character.getNumericValue(num1.charAt(j)) * Character.getNumericValue(num2.charAt(i)) * pos;
				pos *= 10;
			}
			System.out.println(sum);
		}
		System.out.println(Integer.parseInt(num1) * Integer.parseInt(num2));
		sc.close();
	}
}

처음에는 배열을 쓰지 않으면서 각 자리를 사용해야 하므로 문자열로 처리하는 게 좋다고 생각했다.

이중 ``for``문에서 한 단계씩 계산하는 과정은 우리가 일반적으로 수학식을 계산하는 과정과 동일하다.

계산과정

숫자 2개를 문자열로 받은 다음 ``charAt``으로 한 자리씩 추출한다.
``getNumericValue()``로 각 위치의 자리를 숫자 변환한 뒤 서로 계산한다.
2의 결과값에 가중치(pos)를 곱해서 더한다.
``pos``는 10진수의 가중치 값을 곱해주는 변수이다(1의 자리, 10의 자리, 100의 자리수이므로)

2. 입력값을 숫자로 처리하는 경우

import java.util.*;

public class Main {
	public static void main(String[] args) {
		int num1, num2, sum;
	
		Scanner sc = new Scanner(System.in);
		
		num1 = sc.nextInt();
		num2 = sc.nextInt();
		
		System.out.println(num1 * (num2 % 10));
		System.out.println(num1 * ((num2 / 10) % 10));
		System.out.println(num1 * (num2 / 100));
		System.out.println(num1 * num2);
		
		sc.close();
	}
}

위의 코드도 문자열로 바꿀 수는 있지만 로직의 차이가 있어서 정리했다.

예를 들어 ``472 * 5``인 경우 1번 코드는 ``((2 * 5) * 1) + ((7 * 5) * 10) + ((4 * 5) * 100) = 2360``이여서 ``for``문에서 3번 연산을 하는 반면에 2번 코드에서는 ``472 * 5 = 2360``으로 연산을 한 번에 끝내기 때문에 훨씬 효율적이다.

[백준][Java, 1000] A + B

Pridiot — Tue, 14 Sep 2021 18:29:06 +0900

1000번: A+B

두 정수 A와 B를 입력받은 다음, A+B를 출력하는 프로그램을 작성하시오.

www.acmicpc.net

문제

두 정수 A와 B를 입력받은 다음, A+B를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 A와 B가 주어진다. (0 < A, B < 10)

출력

첫째 줄에 A+B를 출력한다.

예제 입력

1 2

예제 출력

코드

import java.util.*;

public class Main {
	public static void main(String[] args) {
		int a, b;
		
		Scanner sc = new Scanner(System.in);
		
		a = sc.nextInt();
		b = sc.nextInt();
		
		System.out.printf("%d", a + b);
		sc.close();
	}
}

풀이는 간단하다.

알게 된 점

println

문자열과 숫자를 처리할 경우 문자열이 나온 이후는 전부 문자열 덧셈(덧붙이기) 처리됨
``System.out.println(2 + 1 + "d" + 3 + 4);`` → 3d34
중간에 계산 값을 넣어주려면 괄호로 묶어주면 된다.
``System.out.println("결과는 " + (1 + 2) + "입니다.");`` → 결과는 3입니다.

Scanner

``Scanner``로 입력값을 받는 경우 가변 인자처럼 처리된다.
nextInt()함수만 그런 건지 모르겠는데 입력값이 안 들어오면 프로그램이 안 끝난다(대기함)

// 테스트 코드
// 입력값의 개수에 따라 결과가 어떻게 달라지는지 확인하면 된다.
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		System.out.println("결과는" + (sc.nextInt() + sc.nextInt()) + "입니다");
		sc.nextInt();
		sc.nextInt();
		sc.nextInt();
		sc.nextInt();
		System.out.println("끝");
		sc.nextInt();
		System.out.println("진짜끝");
		sc.close();
	}
}

[자료구조] 그래프(graph)

Pridiot — Sat, 31 Jul 2021 13:58:19 +0900

공부했던 자료 정리하는 용도입니다.

재배포, 수정하지 마세요.

그래프(graph)

객체 사이의 연결 관계를 표현할 수 있는 자료구조
정점(vertex)과 간선(edge)들의 유한 집합

용어 정리

정점 : 여러 가지 특성을 가질 수 있는 객체를 의미
ex) V(G) : 그래프 G의 정점들의 집합
정점의 차수(degree) : 인접 정점의 개수
인접 정점(adjacent vertex) : 간선에 의해 직접 연결된 정점
간선 : 링크(link)라고도 한다. 간선의 종류에 따라 무방향 그래프와 방향 그래프로 구분된다.
ex) E(G) : 그래프 G의 간선들의 집합
- 브리지(bridge) : 제거하면 정점과의 연결이 끊어지는 간선
단순 경로(simple path) : 반복되는 간선이 없는 경로
사이클(cycle) : 시작 정점과 종료 정점이 동일한 단순 경로

그래프의 종류

무방향 그래프(undirected graph) : 간선이 양방향으로 갈 수 있는 그래프
ex) (A, B) : 정점 A와 정점 B를 연결하는 간선.
(A, B) == (B, A)
``무방향 그래프의 모든 정점의 차수합 == 간선 * 2`` (간선이 두 개의 정점에 인접하기 때문)
방향 그래프(directed graph) : 간선에 방향성이 존재하는 그래프. 간선은 한쪽 방향으로만 갈 수 있다.
ex) <A, B> : 정점 A에서 정점 B로만 갈 수 있는 간선
<A, B> != <B, A>
- 진입 차수(in-degree) : 외부에서 오는 간선의 개수
- 진출 차수(out-degree) : 외부로 향하는 간선의 개수
가중치 그래프(weighted graph), 네트워크(network) : 간선에 비용이나 가중치가 할당된 그래프
부분 그래프(subgraph) : 어떤 그래프의 정점의 일부와 간선의 일부로 이뤄진 그래프. V(S)⊆V(G), E(S)⊆E(G)를 만족시키는 그래프이다.
연결 그래프(connected graph) : 모든 정점 쌍에 대하여 항상 경로가 존재하는 무방향 그래프
+ 트리는 사이클을 가지지 않는 연결 그래프이다.
- 비연결 그래프(unconnected graph)
완전 그래프(complete graph) : 그래프에 속해있는 모든 정점이 서로 연결되어있는 그래프
그래프 정점의 수가 n인 경우 하나의 정점은 n - 1개의 다른 정점으로 연결되므로 간선의 수는 $\frac{n * (n - 1)}{2}$이 된다.

그래프의 연산

객체 : 정점의 집합과 간선의 집합
연산 :
    create_graph() ::= 그래프 생성
    init(g) ::= 그래프 g를 초기화
    insert_vertex(g, v) ::= 그래프 g에 정점 v를 삽입
    insert_edge(g, u, v) ::= 그래프 g에 간선 (u, v)를 삽입
    delete_vertex(g, v) ::= 그래프 g의 정점 v를 삭제
    delete_edge(g, u, v) ::= 그래프 g의 간선 (u, v)를 삭제
    is_empty(g) ::= 그래프 g가 공백 상태인지 검사
    adjacent(v) ::= 정점 v에 인접한 정점들의 리스트 반환
    destroy_graph(g) ::= 그래프 g를 제거

그래프 구현 방법

인접 행렬(adjacency matrix) : 2차원 배열을 이용
- 시간 복잡도
* 두 정점의 간선 존재 여부 : $O(1)$
ex) 정점 u와 정점 v를 연결하는 간선 : ``M[u][v]``
* 정점의 차수 : $O(n)$ 인접 행렬의 행이나 열을 보면 됨
* 모든 간선의 수 : $O(n^2)$ 인접 행렬 전체를 봐야 하기 때문
- n개의 정점을 가지는 그래프를 표현하기 위해서는 항상 $n^2$개의 메모리 공간이 필요
- 간선이 많이 존재하는 밀집 그래프(dense graph)를 표현할 때는 적합하나 간선이 적은 희소 그래프(sparse graph)에는 메모리 낭비가 큼
인접 리스트(adjacency list) : 연결 리스트를 이용
- 정점의 개수만큼 포인터 배열이 필요

그래프 탐색

깊이 우선 탐색(DFS : depth first search)
- 구현 방법
1) 순환 호출 이용
2) 명시적인 스택을 사용
- 시간 복잡도 (정점의 수가 n이고 간선의 수가 e인 그래프인 경우)
* 인접 리스트로 표현되어 있는 경우 : $O(n + e)$
* 인접 행렬로 표현되어 있는 경우 : $O(n^2)$
너비 우선 탐색(BFS : breath first search) : 시작 정점으로부터 가까운 정점을 먼저 방문하고 멀리 떨어져 있는 정점을 나중에 방문하는 순회 방법
- 시간 복잡도
* 인접 리스트로 표현되어 있는 경우 : $O(n + e)$
* 인접 행렬로 표현되어 있는 경우 : $O(n^2)$

신장 트리(spanning tree)

그래프 내의 모든 정점을 포함하는 트리(그래프의 최소 연결 부분 그래프이다.)
모든 정점들이 연결되어 있어야 한다.
사이클을 포함해서는 안된다.
정점이 n개일 때 (n - 1)개의 간선으로 연결된다.
최소 비용 신장 트리(MST: minimum spanning tree) : 신장 트리 중에서 사용된 간선들의 가중치 합이 최소인 신장 트리

최소비용 신장 트리를 구하는 알고리즘

결과는 두 방법 모두 동일하다. 희소 그래프를 대상으로 한 경우에는 Kruskal의 알고리즘, 밀집 그래프의 경우에는 Prim의 알고리즘이 더 효율적이다.

Kruskal (간선 기반 알고리즘) : 탐욕적인 방법을 이용
- 탐욕적인 방법(greedy method) : 매 순간 가장 좋다고 생각되는 것을 선택함으로써 최종 답에 도달하는 방식
- 시간 복잡도 : union-find 알고리즘을 쓰면 $|e|log_2|e|$ (간선들을 정렬하는 시간에 좌우되기 때문)
- union-find 알고리즘
  - 간선의 양끝 정점이 같은 집합에 속해있는지 검사하는 알고리즘(같은 집합이면 간선을 추가할 경우 사이클이 형성됨)
  ex) ``union(x, y)`` : 원소 x와 y가 속해있는 집합을 입력으로 받아 2개의 합집합을 만듦
  ``find(x)`` : 원소 x가 속해있는 집합을 반환
Prim (정점 기반 알고리즘) : 시작 정점부터 신장 트리 집합을 단계적으로 확장해나가는 방법. 간선이 n - 1개가 될 때까지 반복하며, 앞 단계에서 만들어진 신장 트리 집합에 인접한 정점들 중에서 최저 간선으로 연결된 정점을 선택하여 트리를 확장한다.
- 시간 복잡도 : $O(n^2)$

최단 경로 알고리즘

최단 경로(shortest path) : 네트워크 안의 특정한 정점 두 개를 연결하는 경로 중에서 간선들의 가중치의 합이 최소가 되는 경로

Dijkstra : 하나의 시작 정점으로부터 다른 모든 정점까지의 최단 경로를 구하는 알고리즘. 최단 경로는 경로의 길이 순으로 구해진다.
- 시간 복잡도 : $O(n^2)$
Floyd : 그래프에 존재하는 모든 정점 사이의 최단 경로를 한 번에 모두 찾아주는 알고리즘
- 시간 복잡도 : $O(n^3)$

위상 정렬

위상 정렬(topological sort) : 방향 그래프에 존재하는 각 정점들의 선행 순서를 위배하지 않으면서 모든 정점을 나열하는 것. 하나의 그래프에는 여러 개의 위상 순서가 존재할 수 있다.
위상 순서(topological order) : 위상 정렬 과정에서 선택되는 정점의 순서

[자료구조] 우선순위 큐(priority queue), 힙(heap)

Pridiot — Sat, 17 Jul 2021 22:54:16 +0900

공부했던 자료 정리하는 용도입니다.

재배포, 수정하지 마세요.

우선순위 큐(priority queue)

큐에 우선순위의 개념을 도입한 자료구조
데이터들은 우선순위를 가지고 있고, 우선순위가 높은 데이터가 먼저 나가게 된다.
우선순위에 따라 스택이나 큐처럼 동작하기도 한다.

우선순위 큐 연산

객체 : n개의 element형의 우선 순위를 가진 요소들의 모임
연산 :
    create() ::= 우선순위 큐 생성
    init(q) ::= 우선순위 큐 q를 초기화
    is_empty(q) ::= 우선순위 큐 q가 비어있는지 검사
    is_full(q) ::= 우선순위 큐 q가 포화상태인지 검사
    insert(q, x) ::= 우선순위 큐 q에 요소 x를 추가
    delete(q) ::= 우선순위 큐로부터 가장 우선순위가 높은 요소를 삭제하고 해당 요소 반환
    find(q) ::= 우선순위가 가장 높은 요소를 반환

우선순위 큐 구현 방법

배열을 이용
- 정렬된 배열을 사용하는 경우
- 정렬되지 X 배열을 사용하는 경우
연결 리스트를 이용
- 정렬된 연결 리스트를 사용하는 경우
- 정렬되지 않은 연결 리스트를 사용하는 경우
힙(heap)을 이용

각 구현 방법에 따른 시간 복잡도

자료 구조	삽입 연산	삭제 연산
정렬된 배열 이용	$O(n)$	$O(1)$
정렬되지 않은 배열 이용	$O(1)$	$O(n)$ 우선순위가 높은 요소를 찾아야하기 때문
정렬된 연결 리스트를 이용	$O(n)$ 우선순위가 높은 요소를 찾아야 하기 때문	$O(1)$
정렬되지 않은 연결리스트 이용	$O(1)$ (처음에 삽입하는 경우)	$O(n)$ 배열과 마찬가지로 우선순위가 높은 요소를 찾아야 하기 때문
힙(heap)을 이용	$O(log_2n)$	$O(log_2n)$

힙(heap)

완전 이진트리의 일종으로 우선순위 큐를 위하여 만들어진 자료구조이다.
이진 탐색 트리와 달리 중복 값을 허용한다.
부모 노드의 키 값이 자식 노드의 키 값보다 항상 큰 이진트리이다.
일종의 느슨한 정렬 상태를 유지한다. (삭제 연산이 수행될 때 최대값(root)만 찾으면 되므로 전체를 정렬하지 않는다.)
최대값이나 최소값을 빠르게 찾을 때 유리하다.

힙의 종류

최대 힙(max heap)
: 부모 노드의 키 값이 자식 노드의 키 값보다 크거나 같은 완전 이진트리
최소 힙(min heap)
: 부모 노드의 키 값이 자식 노드의 키 값보다 작거나 같은 완전 이진트리

힙 구현 방법

배열을 이용한 구현
- 정렬된 배열 이용
- 정렬되지 X 배열 이용
- 구현을 쉽게 하기 위해서 인덱스 0은 사용하지 않는다.
- 연산을 통해 노드의 인덱스를 알 수 있다.
##왼쪽 자식의 인덱스 = (부모의 인덱스) * 2##
##오른쪽 자식의 인덱스 = (부모의 인덱스) * 2 + 1##
##부모의 인덱스 = (자식의 인덱스) / 2##
연결 리스트 이용

힙의 시간 복잡도

삽입 연산 : $O(log_2n)$
삭제 연산 : $O(log_2n)$

힙의 연산

삽입 연산
(1) 요소를 힙의 가장 마지막 노드로 삽입
(2) 부모 노드와 비교하여 부모 노드보다 클 경우 값 교환(부모 노드보다 작을 때까지 반복)
삭제 연산
(1) 루트 노드 삭제
(2) 빈 루트 자리에 힙의 마지막 노드를 가져옴
(3) 양쪽 자식 중 큰 값과 교환이 일어남(자식 노드보다 클 때까지 반복)

힙 정렬(heap sort)

최대 힙을 이용하면 정렬을 할 수 있다. 데이터를 차례대로 최대 힙에 추가하여 힙을 생성한 뒤, 요소를 하나씩 빼서 뒤쪽부터 저장하면 오름차순이 된다. 이렇게 힙을 사용하는 정렬 알고리즘을 힙 정렬(heap sort)이라고 한다. 전체 자료를 정렬하지 않고 큰 값만 필요한 경우에도 유용하게 사용된다.

시간 복잡도 : $O(nlog_2n)$ (전체 높이가 $log_2n$인 완전 이진트리이기 때문)

힙 응용

LPT 알고리즘(longest processing time first) : 가장 긴 작업을 우선적으로 할당하는 것
허프만 코드(Huffman codes)
ex) 영문자 빈도수를 이용한 데이터 압축

[자료구조] 트리, 이진 트리, 이진 탐색 트리

Pridiot — Fri, 18 Jun 2021 18:07:15 +0900

공부했던 자료 정리하는 용도입니다.

재배포, 수정하지 마세요.

트리와 관련된 용어

트리(tree) : 한 개 이상의 노드로 이루어진 유한 집합.
레벨(level) : 트리의 각 층에 번호를 매긴 것. 루트는 1이되고 한 층 내려갈수록 1씩 증가한다.
높이(height) : 트리가 가지고 있는 최대 레벨
forest : 트리들의 집합
노드(node) : 트리의 구성 요소
루트 노드(root node) : 트리에서 가장 높은 곳에 있는 노드
차수(degree)
노드의 차수 : 노드가 가지고 있는 자식 노드의 개수 (단말 노드의 차수는 0)
트리의 차수 : 트리가 가지고 있는 노드의 차수 중에서 가장 큰 값
서브 트리 : 트리의 하위 트리구조
간선(edge) : 노드를 연결하는 선
부모 노드(parent node) : 자식 노드가 속해있는 노드
자식 노드(children node) : 부모 노드에 속한 부속 노드
형제 노드(sibling node) : 같은 부모 노드를 가지는 노드
조상 노드(ancestor node) : 루트 노드에서 임의의 노드까지의 경로를 이루고 있는 노드들을 의미
후손 노드(descendent node)
- 임의의 노드 하위에 연결된 모든 노드들을 의미.
- 어떤 노드의 서브 트리에 속하는 모든 노드들은 후손 노드이다.
단말 노드(terminal node, leaf node) : 자식 노드가 없는 노드
비 단말 노드(nonterminal node) : 단말 노드의 반대
결정 트리(decision tree) : 의사 결정 구조를 표현하는 방법 중 하나

이진트리(binary tree)

루트와 왼쪽 서브 트리, 오른쪽 서브 트리로 구성된 노드들의 유한 집합
이진트리의 서브 트리들은 모두 이진트리여야 한다. (서브 트리는 공집합일 수 있다.)
모든 노드가 2개의 서브 트리를 가지고 있는 트리이다. (서브 트리는 공집합일 수 있다.)
최대 2개까지의 자식 노드가 존재할 수 있다 (== 모든 노드의 차수가 2 이하이다.)
서브 트리 간의 순서가 존재(왼쪽 서브 트리와 오른쪽 서브 트리는 서로 구별된다.)

이진트리의 성질

부모와 자식 간에는 하나의 간선만 존재
노드가 n개인 이진트리의 간선 개수 : $n-1$(부모 노드는 항상 1개이기 때문)
높이가 h인 이진트리의 노드 개수 : 최소 h개 ~ 최대 $2^h - 1$개
레벨 i에서의 노드 최대 개수 : $2^{i - 1}$
노드가 n개인 이진트리의 높이 : 최소 $log_2(n+1)$ ~ 최대 n

이진트리의 종류

포화 이진트리 (full binary tree)
- 트리의 각 레벨에 노드가 꽉 차있는 이진트리 (== 노드의 개수가 항상 $2^k - 1$개)
- 노드에 번호를 부여할 때는 (같은 레벨에서) 왼쪽에서 오른쪽으로 붙인다.
완전 이진트리(complete binary tree)
: 높이가 k일 때, 레벨 1부터 k -1까지는 노드가 모두 채워져 있고 마지막 레벨에서는 왼쪽부터 오른쪽으로 노드가 순서대로 채워져 있는 이진트리(중간에 비어있으면 안 됨)
- 포화 이진트리는 항상 완전 이진트리
- 포화 이진트리와 노드 번호 부여 방식은 같다.
기타 이진트리

이진트리 구현

배열 표현법
: 노드의 최대 개수인 $2^k -1$개의 공간을 할당한 뒤 노드들을 저장
- 기억공간 낭비가 심함

포인터 이용 : 포인터를 이용해서 왼쪽 노드와 오른쪽 노드를 저장한다.

typedef struct TreeNode{
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

이진트리 순회

순회(traversal) : 이진트리에 속한 모든 노드를 한 번씩 방문하는 것

전위 순회(preorder traversal) : 루트 노드를 가장 먼저 방문 (루트 → 왼쪽 서브 트리 → 오른쪽 서브 트리)
중위 순회(inorder traversal) : 루트 노드를 2번째로 방문 (왼쪽 서브 트리 → 루트 → 오른쪽 서브 트리)
후위 순회(postorder traversal) : 루트 노드를 서브 트리 방문 후에 방문 (왼쪽 서브트리 → 오른쪽 서브트리 → 루트)
레벨 순회(level order)
- 각 노드를 레벨 순으로 방문
- 같은 레벨일 경우에는 좌, 우로 방문

트리 응용

디렉터리 용량 계산 : 후위 순회(하위 디렉터리 용량을 알아야 현재 디렉터리 용량을 계산할 수 있음)
수식 트리(expression tree) 처리 : 후위 순회

이진 탐색 트리(binary search tree)

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

이진 탐색 트리의 정의
- 모든 원소의 키는 유일한 키를 가진다.
- 왼쪽 서브 트리 키들은 루트 키보다 작다.
- 오른쪽 서브 트리의 키들은 루트의 키보다 크다.
- 왼쪽과 오른쪽 서브 트리도 이진 탐색 트리이다.
탐색과 관련된 용어
탐색 : 레코드의 집합에서 특정 레코드를 찾아내는 작업
테이블(table) : 레코드들의 집합
레코드(record) : 하나 이상의 필드(field)로 구성
주요 키(primary key) : 레코드를 구별할 수 있는 값 (중복되지 않은 고유한 값)

이진 탐색 트리의 시간 복잡도

탐색, 삽입 삭제 연산의 시간 복잡도 : (트리의 높이가 h일때) $O(h)$
노드가 n개인 이진 탐색 트리 연산
평균적인 경우(좌우 서브 트리가 균형을 이루는 경우) 시간복잡도 : $O(log_2n)$
최악의 경우(한쪽으로 치우치는 경우) : 선형 탐색과 같이 $O(n)$
→ 최악의 경우를 방지하기 위해 트리의 높이를 $log_2n$으로 한정시키는 방식을 사용한다...

[자료구조] 큐(Queue), 덱(Deque)

Pridiot — Tue, 2 Feb 2021 14:15:08 +0900

공부했던 자료 정리하는 용도입니다.

재배포, 수정하지 마세요.

큐(Queue)

선입선출(FIFO: First-In First-Out) 입출력 형태를 갖는다.
삽입과 삭제가 일어나는 위치가 다르다.
= 삽입과 삭제가 큐의 양 끝에서 일어난다.
rear(후단) : 큐에서 삽입이 일어나는 곳
front(선단) : 큐에서 삭제가 일어나는 곳

큐의 연산

객체 : 0개 이상의 요소들로 구성된 선형 리스트
연산 :
    create(max_size) ::= 최대 크기가 max_size인 공백 큐를 생성
    init(q) ::= 큐 초기화
    is_empty(q) ::=
    	if(size == 0) return TRUE;
        else return FALSE:
    is_full(q) ::=
    	if(size == max_size) return TRUE;
        else return FALSE;
    enqueue(q, e) ::=
    	if(is_full(q)) ERROR_QUEUE_FULL;
        else q의 끝에 e를 추가
    dequeue(q) ::=
    	if(is_empty(q)) ERROR_QUEUE_EMPTY;
        else q의 맨 앞에 있는 e를 제거하여 반환
    peek(q) ::=
    	if(is_empty(q)) ERROR_QUEUE_EMPTY;
        else q의 맨 앞에 있는 e를 읽어서 반환

enqueue(Q, x) ::=
    rear<-(rear + 1) % MAX_QUEUE_SIZE;    // 배열 크기를 넘어가지 않게 하기 위해 큐 사이즈로 나눠줌
    Q[rear]<-x;
dequeue(Q) ::=
    front<-(front + 1) % MAX_QUEUE_SIZE;
    return Q[front];

원형 큐일 경우 삽입과 삭제 알고리즘이 달라진다.

enqueue : 삽입 연산. 큐의 맨 뒤에 새로운 요소를 추가
dequeue : 삭제 연산. 큐의 맨 앞에 있는 요소가 삭제되면서 반환
peek : 맨 앞에 있는 요소를 읽어서 반환 (삭제가 일어나지 X)
is_empty : 큐가 공백 상태인지 검사
is_full : 큐가 포화 상태인지 검사
create : 큐 생성
init : 큐 초기화

큐의 종류

선형 큐(linear queue)
- front와 rear이 증가만 하기 때문에 경우에 따라 배열의 앞부분을 사용할 수 없음
- 주기적으로 모든 요소를 앞쪽으로 이동시켜야 하기 때문에 비효율적
원형 큐(circular queue)
선형 큐의 단점을 보완하기 위해 처음과 끝을 연결한 개념.
공백 상태 : ``front == rear``
포화 상태 : front가 rear보다 한 칸 앞에 있는 경우

- 공백상태와 포화상태를 구분하기 위한 방법
1. 항상 큐의 한자리 이상을 비우기
2. 원소의 개수를 저장하는 변수를 지정

큐의 응용

버퍼
인쇄 작업 큐
운영체제의 작업 스케줄링

대기 행렬 이론, 큐잉 이론(queueing theory)

: 대기 행렬을 수학적으로 다루는 이론. 경영관리, 산업공학, 통신 네트워크의 성능 분석 및 설계(패킷 스케줄링 정책, 자원관리)등 여러 분야에서 사용한다.

덱(Deque, double-ended queue)

큐의 전단(front) 후단(rear)에서 모두 삽입과 삭제가 가능한 큐를 의미한다.

덱의 연산

객체 : n개의 element형의 요소들의 순서 있는 모임
연산 :
    create() ::= 덱 생성
    init(dq) ::= 덱 초기화
    is_empty(dq) ::= 덱이 공백상태인지 검사
    is_full(dq) ::= 덱이 포화상태인지 검사
    add_front(dq, e) ::= 덱의 앞에 요소 추가
    add_rear(dq, e) ::= 덱의 뒤에 요소 추가
    delete_front(dq) ::= 덱의 앞에 있는 요소를 반환한 다음 삭제
    delete_rear(dq) ::= 덱의 뒤에 있는 요소를 반환한 다음 삭제
    get_front(dq) ::= 덱의 앞에 있는 요소를 삭제하지 않고 반환
    get_rear(dq) ::= 덱의 뒤에 있는 요소를 삭제하지 않고 반환

add_front : 덱의 앞에 요소를 추가
add_rear : 덱의 뒤에 요소를 추가
delete_front : 덱의 앞에 있는 요소가 삭제되면서 반환
delete_rear : 덱의 뒤에 있는 요소를 삭제되면서 반환
get_front : 덱의 앞에 있는 요소를 반환 (삭제되지 X)
get_rear : 덱의 뒤에 있는 요소를 반환 (삭제되지 X)
is_empty : 덱이 공백 상태인지 검사
is_full : 덱이 포화 상태인지 검사
create : 덱 생성
init : 덱 초기화

덱의 연산 비교

덱은 스택과 큐의 연산들을 모두 가지고 있다.

	스택(stack)	큐(queue)	덱(deque)
앞에서 삽입			add_front
앞에서 삭제		dequeue	delete_front
뒤에서 삽입	push	enqueue	add_rear
뒤에서 삭제	pop		delete_rear

[자료구조] 스택(Stack)

Pridiot — Tue, 26 Jan 2021 13:39:35 +0900

공부했던 자료 정리하는 용도입니다.

재배포, 수정하지 마세요.

스택(stack)

후입 선출(LIFO : Last-In First-Out)의 입출력 형태를 갖는다.
자료의 출력 순서가 입력 순서의 역순이어야 할 때 많이 사용된다.
입출력이 맨 위에서만 일어나고 스택의 중간에서는 데이터 삭제가 불가능하다.

요소(element) : 스택에 저장되는 것

공백 스택(empty stack) : 요소가 하나도 없는 스택

스택의 연산

객체 : 0개 이상의 원소를 가지는 유한 선형 리스트
연산:
    create(size) ::= 최대 크기가 size인 공백 스택을 생성
    is_full(s) ::=
    	if(스택의 원소수 == size) return TRUE;
        else return FALSE;
    is_empty(s) ::=
    	if(스택의 원소수 == 0) return TRUE;
        else return FALSE;
    push(s, item) ::=
    	if(is_full(s)) return ERROR_STACKFULL;
        else 스택의 맨 위에 item을 추가
    pop(s) ::=
    	if(is_empty(s)) return ERROR_STACKEMPTY;
        else 스택의 맨 위에 원소를 제거해서 반환
    peek(s) ::=
    	if(is_empty(s)) return ERROR_STACKEMPTY;
        else 스택의 맨 위의 원소를 제거하지 않고 반환

push : 삽입 연산. 요소가 스택의 가장 위에 쌓인다. (스택이 가득 차면 오류)
pop : 삭제 연산. 가장 위에 쌓여있는 요소가 삭제되면서 반환된다. (스택이 비어있으면 오류)
peek : 가장 위에 있는 요소를 읽어오는 연산 (삭제가 일어나지 X)
is_empty : 스택이 공백 상태인지 검사
is_full : 스택이 포화 상태인지 검사
create : 스택 생성
init : 스택 초기화

스택 구현 방식

	배열 이용	연결 리스트 이용
장점	구현이 간단하고 성능이 우수	배열에 비해 구현이 복잡
단점	스택 크기가 고정됨	스택의 크기를 가변적으로 사용할 수 있음

스택응용

괄호 검사
후위 표기 수식의 계산
미로 찾기

팩토리얼 계산

Pridiot — Mon, 25 Jan 2021 15:06:53 +0900

공부했던 자료 정리하는 용도입니다.

재배포, 수정하지 마세요.

팩토리얼(거듭제곱 값) 계산

반복적인 방법이 순환적인 방법에 비하여 속도가 더 빠르다.

1. 반복문을 사용하는 방법

double power_1(double x, int n)
{
	int i;
	double result = 1.0;
	
	for (i = 0; i < n ; i++)
		result *= x;
	return (result);
}

한 번의 루프마다 한 번의 곱셈이 일어나므로 시간 복잡도는 $O(n)$이 된다.

2. 순환을 사용하는 방법

double power_2(double x, int n)
{
	if (n == 0)
		return 1;
	else if ((n % 2) == 0)	// n이 짝수인 경우
		return power_2((x * x), (n / 2));
	else	// (n % 2) != 0 -> n이 홀수인 경우 
		return x * power_2((x * x), ((n - 1) / 2));
}

$x^n = (x^2)^{\frac{n}{2}}$ 의 공식을 이용하는 방법이다.

n이 짝수인 경우에는 $x^2$을 먼저 계산한 후에 이 값을 $\frac {n}{2}$제곱하고,

n이 홀수인 경우에는 $x^2$을 $\frac{n-1}{2}$제곱한 뒤 $x$를 한번 더 곱해야 한다.

함수를 한번 호출할 때마다 n승, $\frac{n}{2}$, $\frac{n}{4}$승으로 점점 문제의 크기가 약 절반으로 줄어든다.

시간 복잡도

$2^k$ → $2^{k-1}$ → $2^{k-2}$ → ... → $2^1$ → $2^0$

약 k번의 순환 호출이 일어난다. $n = 2^k$이므로 양변에 log를 취하면 $log_2n = k$가 된다.

한 번의 순환 호출이 일어날 때마다 약 1번의 곱셈과 1번의 나눗셈이 일어나므로 전체 연산의 개수는 $k = log_2n$에 비례하게 되어 시간 복잡도는 $O(log_2n)$이 된다.

순환 알고리즘

Pridiot — Mon, 25 Jan 2021 13:17:34 +0900

공부했던 자료 정리하는 용도입니다.

재배포, 수정하지 마세요.

반복과 순환

기본적으로 반복과 순환은 문제 해결 능력이 같으며 대부분의 경우 순환 알고리즘과 반복 알고리즘은 서로 대체될 수 있다. 특히 순환 호출이 끝에서 이뤄지는 것을 꼬리 순환(tail recursion)이라 하는데, 이를 반복 알고리즘으로 쉽게 대체할 수 있다. 대부분의 언어가 순환을 지원하지만 FORTRAN, COBOL과 같은 고전적인 언어에서는 지역변수가 없거나 있더라도 정적으로 할당되므로 순환이 불가능하다. (함수 호출마다 새로운 지역변수를 만들지 못하면 이전 호출과 구분할 수 없어 순환 호출이 불가능하다.)

반복(iteration) : 반복 구조로 되풀이하는 방법
순환(recursion) : 어떤 알고리즘이나 함수가 자기 자신을 호출하여 문제를 해결하는 프로그래밍 기법
- 특정 문제에서 반복에 비해 알고리즘을 훨씬 명확하고 간결하게 나타낼 수 있다.
- 함수호출을 하게 되므로 대부분 반복에 비해 수행 속도가 떨어진다.
- 알고리즘의 정의가 순환적으로 되어있는 경우 유용함
ex) 팩토리얼, 피보나치 수열, 이항 계수 계산, 이진트리 알고리즘, 이진 탐색, 하노이 탑 등

순환의 원리 : 문제의 일부를 해결한 다음 나머지 문제에 대하여 순환 호출을 한다.

분할정복(divide and conquer) : 주어진 문제를 더 작은 동일한 문제들로 분해하여 해결하는 방법

순환의 종류

머리 순환(head recursion) : 순환 호출이 순환 함수 처음에서 이뤄지는 경우
꼬리 순환(tail recursion) : 순환 호출이 순환 함수 맨 끝에서 이뤄지는 경우 → 반복문으로 쉽게 변환 가능
multi recursion : 여러 군데에서 자기 자신을 호출하는 경우

순환 호출 과정

복귀주소가 시스템 스택에 저장되고 호출되는 함수를 위한 매개변수(parameter)와 지역 변수를 스택으로부터 할당받는다.
활성 레코드(activation record) : 함수를 위한 시스템 스택에서의 공간
준비가 끝나면 호출된 함수의 시작 위치로 점프하여 수행 시작
호출된 함수가 끝나면 시스템 스택에서 복귀 주소를 추출하여 호출한 함수로 되돌아감

순환 알고리즘의 구조

[반환형] [함수이름] (매개변수)
{
    if (종료조건)
    {
    	// 순환을 멈추는 부분
    }
    else
    {
    	// 순환호출 하는 부분
    }
}

종료 조건이 없으면 무한히 반복하게 되므로 주의한다.

순환 알고리즘 문제

팩토리얼(거듭제곱) : https://pridiot.tistory.com/260
피보나치
하노이의 탑

알고리즘 성능분석

Pridiot — Fri, 22 Jan 2021 09:48:25 +0900

공부했던 자료 정리하는 용도입니다.

재배포, 수정하지 마세요.

자료구조(data structure) : 자료들을 정리하여 보관하는 여러 가지 구조
알고리즘(algorithm) : 컴퓨터로 문제를 풀기 위한 단계적인 절차, 특정한 일을 수행하는 명령어들의 집합

알고리즘이 되기 위한 조건

입력 : 0개 이상의 입력이 존재해야 함
출력 : 1개 이상의 출력이 존재해야 함
명백성 : 각 명령어의 의미는 모호하지 않고 명확해야 한다.
유한성 : 한정된 수의 단계 후에는 반드시 종료되어야 한다.
유효성 : 각 명령어들은 컴퓨터로 실행 가능한 연산이어야 한다.

알고리즘을 기술하는 방법

자연어
ex) 한글, 영어
흐름도(flowchart)
의사코드(pseudo-code)
대입 연산자를 ←로 사용한다는 점이 다름
프로그래밍 언어

알고리즘의 성능 분석

수행 시간 측정 방법 : ``time.h``헤더의 ``clock( )``함수를 이용해서 호출 프로세스에 의하여 사용된 CPU 시간을 계산
- 알고리즘이 복잡한 경우 테스트하기가 어려움
- 여러 가지 알고리즘을 비교하는 경우 반드시 똑같은 하드웨어를 사용하여 수행 시간을 측정해야 함
- 소프트웨어 환경에 따라 결과가 달라질 수 있음
ex) 일반적으로 컴파일 언어가 인터프리터 언어보다 빠름
- 테스트하지 않은 입력에 대해서는 수행 시간을 보장할 수 없음
알고리즘의 복잡도 분석 방법(complexity analysis)
: 대부분의 경우 알고리즘의 복잡도는 시간 복잡도를 의미한다.
- 시간 복잡도(time complexcity)
  - 알고리즘의 수행 시간 분석.
  - 절대적인 수행 시간이 아닌 알고리즘을 이루고 있는 연산들이 몇 번 수행되는지 숫자로 표시한다.
  - (보통 입력 값에 따라 수행 횟수가 변하게 되므로)연산의 수를 입력의 개수 n의 함수로 나타낸 것을 시간 복잡도 함수라고 하고 $T(n)$이라고 표기한다.
- 공간 복잡도(space complexity) : 알고리즘이 사용하는 기억공간 분석

빅오(big O) 표기법

big o

두 개의 함수 $f(n)$과 $g(n)$이 주어졌을 때 모든 $n > n_0$에 대하여 |f(n)| <= c|g(n)|을 만족하는 2개의 상수 c와 $n_0$가 존재하면 f(n)=O(g(n))이다.

n의 값에 따른 함수의 상한 값을 나타내는 방법이다.
시간 복잡도 함수에서 불필요한 정보(함수의 증가에 별로 기여하지 못하는 항을 생략)를 제거한 것으로, 알고리즘 분석을 쉽게 할 목적으로 사용한다.
다항식으로 표현되었을 경우 다항식의 최고 차항만을 남기고 다른 항들과 상수항을 버리는 방법으로 간단하게 구할 수 있다. (logn은 생략하면 X)
최소 차수 함수로 표기되었을 경우만 의미가 있다.
상한을 표기한 것이므로 상한이 여러 개가 존재하는 경우에 문제

빅 오메가(big omega) 표기법

big omega

두 개의 함수 $f(n)$과 $g(n)$이 주어졌을 때 모든 $n > n_0$에 대하여 |f(n)| >= c|g(n)| 을 만족하는 2개의 상수 c와 $n_0$가 존재하면 f(n)=Ω(g(n))이다.

n의 값에 따른 함수의 하한 값을 나타내는 방법이다.

빅 세타(big theta) 표기법

big theta

두 개의 함수 $f(n)$과 $g(n)$이 주어졌을 때 모든 $n > n_0$에 대하여 c1|g(n)| <= |f(n)| <= c2|g(n)|을 만족하는 3개의 상수 c1, c2와 $n_0$가 존재하면 f(n)=Θ(g(n))이다.

동일한 함수로 상한과 하한을 만들 수 있는 경우에 사용할 수 있는 방법이다.
3가지 표기법 중 가장 정밀하다.

시간 복잡도 함수의 수행 시간(빅오 표기법)

수행시간
$O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(2^n) < O(n!)$

$O(1)$ : 상수형
$O(log n)$ : 로그형
$O(n)$ : 선형
$O(nlogn)$ : 선형 로그형
$O(n^2)$ : 2차형
$O(n^3)$ : 3차형
$O(2^n)$ : 지수형
$O(n!)$ : 팩토리얼형

최선, 평균, 최악의 경우

똑같은 알고리즘도 주어지는 입력에 따라 수행시간이수행 시간이 달라질 수 있다. 평균적인 경우는 산출하기 어렵기 때문에 대부분 최악의 경우의 수행 시간이 알고리즘의 시간 복잡도 척도로 많이 사용된다.

최선의 경우(best case) : 수행시간이 가장 적은 경우
평균적인 경우(average case) : 알고리즘의 모든 입력과 각 입력이 발생하는 확률을 고려한 평균적인 수행시간
최악의 경우(worst case) : 자료 집합 중에서 알고리즘의 수행 시간이 가장 오래 걸리는 경우

추상화(abstraction)

어떤 시스템의 간략화된 기술, 또는 명세로서 시스템의 핵심적인 구조나 동작에만 집중하는 것.
좋은 추상화는 사용자에게 중요한 정보는 강조되고 중요하지 않은 구현 세부 사항은 제거되는 것이다. 이를 위하여 정보 은닉 기법(information hiding)이 개발되었고 추상 자료형의 개념으로 발전되었다.

추상 자료형(ADT : abstract data type)

자료형을 추상적으로 정의한 것
데이터나 연산이 무엇인지는 정의되지만 어떻게 컴퓨터 상에서 구현할 것인지는 정의되지 않는다.
- ADT안에는 객체(objects)와 함수(functions)들이 정의된다.
- 함수에는 매개변수, 반환형, 함수가 수행하는 기능의 기술 등이 포함된다.
- ``::=``는 "~으로 정의된다"는 의미이다.
정보은닉의 한 방법으로도 사용된다.
: ADT가 구현될 때 보통 구현 세부사항은 외부에 알리지 않고 외부와의 인터페이스만을 공개하게 된다. ADT의 사용자는 구현 세부사항이 아닌 인터페이스만 사용하기 때문에 추상 자료형의 구현 방법은 언제든지 안전하게 변경될 수 있다. 또한 인터페이스만 정확하게 지켜진다면 ADT가 여러 가지 방법으로 구현될 수 있다.
객체 지향 언어에서는 클래스 개념을 사용하여 ADT를 구현한다.
- ADT의 객체는 클래스의 속성, 연산은 클래스의 멤버 함수로 구현된다.
- private나 protected 키워드를 이용하여 내부 자료의 접근을 제한할 수 있다.
- 클래스는 계층구조(상속 개념 사용)로 구성될 수 있다.

기본 자료형

기초 자료형 : char, int, float, double ...
파생 자료형 : 배열, 포인터
사용자 정의 자료형 : 구조체, 공용체, 열거형