시간 복잡도 / 공간 복잡도

상황에 맞는 좋은 알고리즘을 선택하기 위해서는 알고리즘의 효율성을 확인해야 한다.

이 때 효율성 측정에는 시간 복잡도(time complexity)와 공간 복잡도(space complexity)라는 두 부분이 있다.

시간 복잡도는 문제를 해결하는데 걸리는 시간과 입력의 함수 관계

공간 복잡도는 문제를 해결하는데 필요로 하는 자원 공간의 양

Big-O 표기법 (Big-O Notation)

시간 복잡도의 표기법은

최선 경우 분석(Best Case Analysis) => Big-Ω(빅-오메가) / 하한 점근

-> 알고리즘 최상의 실행 시간을 표기한다.

최악 경우 분석(Worst Case Analysis) => Big-O(빅-오) / 상한 점근

-> 알고리즘 최악의 실행 시간을 표기한다.

평균 경우 분석(Average Case Analysis) => Big-θ(빅-세타) / 그 둘의 평균

-> 알고리즘 평균 실행 시간을 표기한다.

일반적으로 위의 3가지 경우로 분류한다.

그중에서 Big-O 표기법은 최소한 보장되는 성능을 표기하기 때문에 가장 많이 사용하는 표기법이다.

(불확실성을 제거하기 위해 최악의 경우를 사용)

O(1) < O(logN) < O(N) < O(N logN) < O(N²) < O(2ᴺ) < O(N!)

O(1) – 상수 시간 (Constant Time)

입력한 데이터의 크기에 상관없이 언제나 일정한 시간이 걸리는 알고리즘

O(1) 알고리즘은 데이터(data)가 증가해도, 처리속도(time)에는 변함이 없는 알고리즘이다.

#include <iostream>

using namespace std;

int main()
{
	cout << "Do Something!!";

	return 0;
}

#include <iostream>

using namespace std;

int main()
{
	cout << "Do Something!!";
	cout << "Do Something!!";

	return 0;
}

두번 출력을 하는 코드는 O(2)가 아닌 O(1)이다.

왜냐하면 Big O는 함수의 디테일에는 관심이 없기 때문이다.

그저 input 사이즈에 따라서 달라진다.

O(N) – 선형 시간 (Linear Time)

O(N)는 완벽한 대각선

최악의 경우에 n번의 연산을 수행해야 하는 알고리즘으로 데이터가 추가될 때마다 알고리즘이 한 단계 더 진행된다.

이것이 선형 시간이라고 하는 이유

ex) 1중 for문

#include <iostream>

using namespace std;

int main()
{
	int N = 0;
	cin >> N;
	for (int i = 0; i < N; i++) {
		cout << "Do Something!!" << "\n";
	}

	return 0;
}

* 참고 * O(1) / O(N)

O(1)과 O(N)의 알고리즘으로 같은 문제를 50까지 수행한다면

→ 입력 배열의 요소가 50개 미만일 때 O(N)가 더 효율적

→ 정확히 50개의 요소에서 두 알고리즘은 동일한 단계 수를 사용

→ 데이터가 증가할수록 O(N)더 많은 단계가 필요

Big-O 표기법은 데이터가 무한대로 커짐에 따라 알고리즘이 어떻게 수행되는지 살펴보기 때문에

O(N)가 보다 덜 효율적인 것으로 간주되는 이유다.

O(N²) – 2차 시간 (Quadratic Time)

성능이 입력 요소 크기의 제곱에 비례하는 알고리즘의 복잡성을 나타낸다. 일반적으로 매우 느리다.

주로 중첩 반복이 있을 때 발생하게 된다.

루프안에서 루프가 실행된다면, 20개의 데이터는 400개의 스텝이 된다. O(n^2)

ex) 2중 for문, 삽입(Insertion)/거품(Bubble)/선택(Selection) 정렬 등…

#include <iostream>

using namespace std;

int main()
{
	int N = 0;
	cin >> N;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N; j++) {
			cout << "Do Something!!" << "\n";
		}
	}

	return 0;
}

O(logN) – 로그 시간 (Logarithmic Time)

연산이 한 번 실행될 때 마다 데이터의 크기가 절반 감소하는 알고리즘 (log의 지수는 항상 2)

데이터의 관점으로 말하면 O(logN)은 데이터가 두 배가 될 때마다 작업 수가 하나씩 증가한다.

ex) binary search 알고리즘, tree 형태 자료구조 탐색

// 이진 탐색

int BinarySearch(int arr[], int size, int target)
{
	
	int low = 0;
	int high = size - 1;
	int mid = 0;

	while (low <= high)
	{
		mid = (low + high) / 2;

		if (target < arr[mid])
			high = mid - 1;
		else if (target > arr[mid])
			low = mid + 1;
		else
			return mid;  // 반환 값은 인덱스
	}

	return -1;
}

O(N logN) – 로그 선형 시간 (Log-linear Time)

O(N)의 알고리즘과 O(log N)의 알고리즘이 중첩된 형태

log(N)작업 N시간을 수행

ex) 퀵(Quick) / 병합(Merge) / 힙(Heap) 정렬, 분할 정복 알고리즘

O(2ᴺ) – 지수 시간 (Exponential Time)

매우 느린 시간 복잡도로 주로 재귀적으로 수행하는 알고리즘이 이에 해당

ex) fibonacci 수열

// 피보나치 수열 
int Fibonaci(int n){
    if (n == 1) return 0;
    else if (n == 2) return 1;
    else return Fibo(n - 1) + Fibo(n - 2);
}

O(N!) – 계승 시간(Factorial Time)

 입력 크기의 계승에 비례하는 실행 시간

가장 느린 알고리즘으로 입력 값이 조금만 커져도 계산이 어렵다. (답없다.)

빅오 표기법(big-O notation) 규칙

계수 법칙: 상수를 제거하라

계수 법칙은 단순히 입력 크기와 연관되지 않은 상수를 전부 무시하는 것이다

빅오에서 입력 크기가 클 때 계수를 무시할 수 있다

상수 k > 0 인 경우 f(n)이 O(g(n))이면,
kf(n)은 O(g(n)이다.
이 말은 즉, 5f(n)과 f(n)이 모두 동일한 O(f(n))이라는 빅오 표기법을 지님을 의미한다

합의 법칙: 빅오를 더하라

합의 법칙은 시간 복잡도를 더할 수 있다는 것을 의미한다

f(n)이 O(h(n))이고 g(n)이 O(p(n))이라면
f(n)+g(n)은 O(h(n))+O(p(n))이다
이 때 주의해야할 점은 합의 법칙을 적용한 다음 계수 법칙을 적용해야한다는 점이다

곱의 법칙: 빅오를 곱하라

곱의 법칙은 빅오가 어떤 식으로 곱해지는지에 관한 것이다

f(n)이 O(h(n))이고 g(n)이 O(p(n))이면
f(n)g(n)은 O(h(n)p(n))이다

다항 법칙: 빅오의 k승

다항 법칙은 다항 시간 복잡도가 동일한 다항 차수를 지닌 빅오 표기법을 지님을 의미한다

f(n)이 k차 다항식이면 f(n)은 O(nᵏ)이다

쉽게 말해, 빅오 표기법은 제일 영향력 있는 것만 신경쓰겠다는 의미

(최고 차항을 남기고, 상수는 버린다)

O(30n³+20n²+500n+3000)로 표시된 값이 있을 때, 빅오 표기법은 제일 영향력 있는 것만 남겨 O(n³)으로만 표기한다

참고 사이트

https://velog.io/@2seunghye/%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EB%B9%85%EC%98%A4%ED%91%9C%EA%B8%B0%EB%B2%95Big-O-notation

https://towardsdatascience.com/introduction-to-big-o-notation-820d2e25d3fd

https://wing-beat.tistory.com/17

https://towardsdatascience.com/the-big-o-notation-d35d52f38134

https://noahlogs.tistory.com/27

https://velog.io/@nana-moon/%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EB%B9%85%EC%98%A4-%ED%91%9C%EA%B8%B0%EB%B2%95big-O-notation%EC%9D%B4%EB%9E%80

The post 알고리즘 – 빅오 표기법(Big-O Notation) 정리 appeared first on 어제와 내일의 나 그 사이의 이야기.

알고리즘을 분석하는 이유

정확성 확인(무결성 확인)

모든 유효한 입력에 대해서 유한 시간 내에 올바른 해를 찾아내는가를 판단하기 위함

효율성 확인

한정된 자원(기억 장소 사용량, 수행 시간)에서 효율적으로 작동하는지 확인하기 위함

궁극적으로 알고리즘을 분석하여 얻는 이점

문제를 해결하기 위해 중요한 것과 중요하지 않은 것을 판단할 수 있다.

문제를 단순화하여 생각할 수 있다.

다른 사람의 아이디어에 대한 효율성을 판단할 수 있다.

같은 문제를 해결하는 알고리즘은 여러 가지가 존재한다.

최상의 알고리즘은 존재하지 않으며 항상 주어진 상황을 객관적으로 분석하여 알고리즘을 선택해야 한다.

또한 기존의 알고리즘을 개선하기 위해서 적용 가능한 여러 알고리즘을 객관적으로 비교 분석을 할 줄 알아야 한다.

알고리즘을 분석하는 방법

일반적으로 알고리즘의 수행 시간에 따른 시간복잡도(Time Complexity)와

작성한 프로그램이 얼마나 많은 공간(메모리)을 차지하느냐를 분석하는 방법인 공간복잡도(Space Complexity)로 분석한다.

시간복잡도의 경우 알고리즘을 잘못 구성하였을 경우 결과값이 나오지 않거나 현저하게 느린속도가 나오기에

공간복잡도보다는 시간복잡도를 우선시하여 프로그램을 분석한다. (기술의 발달로 인한 메모리 증가도 큰 영향)

알고리즘의 수행 시간

알고리즘의 효율성을 분석하는 방법은 다양하지만, 많은 경우에 알고리즘의 수행 시간을 이용하여 효율성을 분석

시간복잡도 (Time Complexity) : 얼마나 빠른가?

입력 크기에 비례하여 작업시간이 어떠한 비율로 증가하는지 확인한다.

시간복잡도를 사용하는 이유

실측으로 시간을 측정하는 경우 프로그래밍 언어, 컴퓨터의 성능, 프로그래머의 실력 등의 다양한 변수에 따라 달라질 수 있다.

(분석에 객관적인 기준이 필요)

수행 시간 분석 방법

최선 경우 분석(Best Case Analysis) => Big-Ω(빅-오메가) / 하한 점근

최선의 경우는 프로그램 실행 시간의 하한을 계산한다.

선형 탐색의 경우 베스트 케이스는 찾으려는 x가 제일 처음에 위치하는 경우이다.

최상의 경우 실행되는 연산의 수는 상수이며 입력 크기 n에 영향을 받지 않는다.

따라서 최상의 경우 시간 복잡도는 θ(1)이다.

최악 경우 분석(Worst Case Analysis) => Big-O(빅-오) / 상한 점근

최악의 경우는 알고리즘이 실행되는 시간의 상한을 결정한다.

프로그램을 실행 할 때 연산이 수행되는 횟수가 최대가 되는 경우이다.

선형 탐색의 경우 찾으려는 원소가 배열에 존재하지 않거나 배열의 끝에 존재하는 경우이다.

배열에 찾으려는 원소가 존재하지 않으면 배열의 전체 원소와 모두 비교를 한다.

이 때 최악이라는 것은 단위 연산이 수행되는 횟수가 최대라는 것이다.

입력 크기와 입력 값(내용) 모두에 종속된다.

선형 탐색의 최악의 경우 시간 복잡도는 θ(n)이다.​

평균 경우 분석(Average Case Analysis) => Big-θ(빅-세타) / 그 둘의 평균

평균적인 경우를 계산하는 방법은 다음과 같다.

가능한 모든 입력에 대해 실행 시간을 계산한다.

그리고 이 시간을 모두 더하고, 더한 결과를 입력의 수로 나눈다.

선형 탐색을 계산하는 방법은 다음과 같다.

선형 탐색인 경우 모든 경우들이 균등하게 분포한다고 가정하자.

크기 n의 배열에서 원소 x를 찾으려고 할 때, x의 위치는 1 또는 2, 3, … , n이 될 수 있다.

배열을 따라 각 원소를 x와 비교한다.

만약 배열의 k번째 원소에 도달 했으면 이미 k번 비교를 한 것이다.

x가 인덱스 1의 위치에 있다면 1번 비교한다.

x가 인덱스 2의 위치에 있다면 2번 비교한다.

…

x가 인덱스 n의 위치에 있다면 n번 비교한다.

평균을 구하기 위해 비교한 수들을 합하면 1+ 2 + 3 + … + n = (n+1)n / 2

이를 배열의 크기인 n으로 나누면 (n+1) / 2 이다.

따라서 선형 탐색의 평균 시간 복잡도는 θ(n) 이다.

가장 자주 사용되는 분석

최악 경우 분석(Worst Case Analysis) => Big-O(빅-오) / 상한 점근

시간 복잡도에는 여러 개념이 있지만 그중에서

‘아무리 많이 걸려도 이 시간 안에는 끝날 것‘의 개념이 제일 중요하다. 

예를 들어 동전을 튕겨서 뒷면이 나올 확률을 이야기해본다면 운이 좋으면 한 번에 뒷면이 나올 수도 있고

운이 좋지 않으면 3번 4번만에 뒷면이 나올수도 있다.

운이 나쁜 경우 n번만큼 동전을 튕겨야 하는 최악의 경우가 발생하는데

이 최악의 경우를 계산하는 방식을 빅-오(Big-O) 표기법이라고 부르며 이 방식을 가장 많이 사용한다.

The post 알고리즘 – 알고리즘 분석에 대한 정리 appeared first on 어제와 내일의 나 그 사이의 이야기.