시간 복잡도 예제 | [알고리즘] 3. 시간복잡도(Bigo) 기초 - 센치한개발자 2526 좋은 평가 이 답변

당신은 주제를 찾고 있습니까 “시간 복잡도 예제 – [알고리즘] 3. 시간복잡도(BigO) 기초 – 센치한개발자“? 다음 카테고리의 웹사이트 https://kk.taphoamini.com 에서 귀하의 모든 질문에 답변해 드립니다: https://kk.taphoamini.com/wiki/. 바로 아래에서 답을 찾을 수 있습니다. 작성자 센치한개발자 이(가) 작성한 기사에는 조회수 5,586회 및 좋아요 98개 개의 좋아요가 있습니다.

Table of Contents

시간 복잡도 예제 주제에 대한 동영상 보기

여기에서 이 주제에 대한 비디오를 시청하십시오. 주의 깊게 살펴보고 읽고 있는 내용에 대한 피드백을 제공하세요!

아래 동영상 보기

d여기에서 [알고리즘] 3. 시간복잡도(BigO) 기초 – 센치한개발자 – 시간 복잡도 예제 주제에 대한 세부정보를 참조하세요

#센치한개발자 #알고리즘 #코딩테스트
▶︎ 센치한개발자 강의 구독하기 : https://goo.gl/wPYaXG
*. 이번시간은 간단한 예시로 익혀보는 시간복잡도 기초 방송입니다.

시간 복잡도 예제 주제에 대한 자세한 내용은 여기를 참조하세요.

[알고리즘] 시간복잡도 예제 15종 | 블로그 – 딩그르르

사실, 예제 찾기가 쉽지가 않아요. 그리고, 시간복잡도를 구하는 문제가 면접에서 면접에서 나온다면, 잘 기억하세요. ‘정말 집중하셔야 해요’. 내가 만든 …

+ 여기를 클릭

Source: dingrr.com

Date Published: 6/12/2022

[Algorithm] 빅오 표기법과 시간 복잡도의 개념 및 예제

시간 복잡도 : 알고리즘이 얼마나 빠르게 결과를 출력하는지 측정, 입력 크기 n에 대한 시간 함수 T(n)으로 표현. – 공간 복잡도 : 원하는 결과를 …

+ 여기에 더 보기

Source: codesyun.tistory.com

Date Published: 1/12/2021

[자료구조] 시간복잡도 Big-O 표기법 예제(c)

이번 시간에는 시간복잡도 big-o 예제에 대해서 알아보겠다. 시간 복잡도에 대한 개념 및 설명은 생략하겠다. #1 O(n) 복잡도. vo Func1(int n) for(int i = 0; …

+ 여기에 보기

Source: intrepidgeeks.com

Date Published: 8/23/2021

[Javascript] 시간 복잡도 정리 및 예제 – 코딩병원

[Javascript] 시간 복잡도 정리 및 예제. 코딩병원 2022. 4. 27. 22:08. 빅오 표기법은 알고리즘의 최악의 경우 복잡도를 측정합니다. 빅오 표기법에서 n은 입력의 …

+ 자세한 내용은 여기를 클릭하십시오

Source: itprogramming119.tistory.com

Date Published: 10/22/2022

시간 복잡도란? – 오늘의 코드 – 티스토리

1. 시간 복잡도 1-1. 시간 복잡도란? 1-2. Big-O 표기법 2. 예제 2-1. O(1) 2-2. O(n) 2-3. O(n²) 2-4. O(n³) 2-5. O(nm) 2-6. O(2ⁿ) 2-7. O(logn) 3.

+ 여기에 자세히 보기

Source: todaycode.tistory.com

Date Published: 10/13/2022

알고리즘 시간 복잡도(Complexity) 쉽게 이해하기 – Developercc

19. [탐색 알고리즘 DFS 깊이 우선 탐색] 예제 자바 코드 (코딩 테스트, 코딩 면접 준비) 탐색 알고리즘 …

+ 여기를 클릭

Source: developercc.tistory.com

Date Published: 4/23/2021

실전 대비 C 알고리즘 인터뷰: 1.3 시간 복잡도 예제

이 절에서는 코드만 보고 함수의 시간 복잡도를 빅오로 표현할 수 있는 예제를 살펴봅니다. 예제 1-1. int fun1(int n) { int m = 0; for (int i = 0; i < n; ...

+ 여기에 더 보기

Source: thebook.io

Date Published: 3/7/2022

주요 시간 복잡도 정리 – velog

알고리즘 시간 복잡도의 순위는 다음과 같다. … O(1)은 인풋의 크기가 소요 시간에 영향이 없으며 반복문이 없으면 대체로 … O(1) 함수 예제:

+ 여기에 표시

Source: velog.io

Date Published: 3/23/2021

알고리즘_시간복잡도 예제 – Tigercow.Door – 티스토리

이번에는 실제로 특정 코드나 알고리즘을 대상으로 그 시간복잡도를 분석해보는 실습을 진행해보도록 하겠습니다. 아래에서 다루게 될 예제들은 …

+ 더 읽기

Source: doorbw.tistory.com

Date Published: 2/28/2022

알고리즘 복잡도 분석

III-II. 시간 복잡도의 종류 · IV. 알고리즘의 함수 실행 시간 도출 · V. 시간 복잡도 예제.

+ 여기에 표시

Source: hy6219.github.io

Date Published: 11/13/2021

주제와 관련된 이미지 시간 복잡도 예제

주제와 관련된 더 많은 사진을 참조하십시오 [알고리즘] 3. 시간복잡도(BigO) 기초 – 센치한개발자. 댓글에서 더 많은 관련 이미지를 보거나 필요한 경우 더 많은 관련 기사를 볼 수 있습니다.

주제에 대한 기사 평가 시간 복잡도 예제

Author: 센치한개발자
Views: 조회수 5,586회
Likes: 좋아요 98개
Date Published: 2020. 9. 15.
Video Url link: https://www.youtube.com/watch?v=dxStJ6lCqPQ

[알고리즘] 시간복잡도 예제 15종

시간 복잡도에 대해서 들어보셨지요?

시간 복잡도를 처음 공부하시면, 예제와 함께 하는 것이 정말 많은 도움이 됩니다. 저도 역시 그랬고요.. 사실, 예제 찾기가 쉽지가 않아요. 그리고, 시간복잡도를 구하는 문제가 면접에서 면접에서 나온다면, 잘 기억하세요.

‘정말 집중하셔야 해요’

내가 만든 코드가 아닌데 거기서 시간 복잡도를 구하려면 먼저 자세히 살펴봐야 합니다. 코드리뷰를 먼저 하셔야 하죠. 무턱대고 구하시면 틀릴 가능성이 커요. 왜냐하면, 함정을 숨겨 놓을 것이라서요. 분명!

시간 복잡도 때문에 집중하지 못해서 면접에서 떨어졌다면? 걱정마세요.. 그렇다고 당신이 실력이 없는 것이 아닙니다. 이 시간복잡도는 중요하지만, 아주 아주 작은 빙산의 일각일 뿐이에요. 내가 작성한 코드의 시간복잡도만 정확히 구하실 줄 알면 됩니다. 장기적으로 그런 의미에서 이 예제들이 많이 도움이 되었으면 좋겠습니다.

아직 시간복잡도가 무엇인지 모르신다면, 다른 포스트 글을 참고해 주세요.

그리고 시간 복잡도는 C나 Java로 많이 출제 됩니다. 그래서 파이썬 코드보다 아래 코드로 보시면 더욱 문제 풀이에 수월하실 거에요.

>>딩그르르의 시간복잡도에 관한 포스트 읽기

문제 #1.

int a = 0 , b = 0 ;

for (i = 1 ; i < N; i++) { a = a + rand(); } for (j = 2 ; j < M; j++) { b = b + rand(); } 정답보기 문제 #2. a = 0 , b = 0 ; for (i = 0 ; i < N; i++) { for (j = 0 ; j < N; j++) { a = a + j; } } for (k = 0 ; k < N; k++) { b = b + k; } 정답보기 문제 #3. int a = 0 ; for (i = 0 ; i < N; i++) { for (j = N; j > i; j–) {

a = a + i + j;

}

}

정답보기

문제 #4. 우리는 두가지 알고리즘을 가지고 있습니다, ‘Algo A’와 ‘Algo B’ 이지요. 여기서, ‘Algo A’가 ‘Algo B’ 보다 점근적으로 더 효과적이라는 말은 무슨 뜻인지 아래 선택 답지에서 골라보세요.

Algo A가 어떤 크기의 입력이 들어와도 항상 빠르다. Algo A가 입력 크기가 클 경우 빠르다. Algo A가 입력 크기가 작을 경우 빠르다. Algo B가 항상 더 빠르다. Algo A가 입력 크기에 따라 메모리 관리능력이 효과적이다.

정답보기

문제 #5.

int a = 0 , i = N;

while (i > 0 ) {

a += i;

i /= 2 ;

}

정답보기

문제 #6.

int count = 0 ;

for ( int i = N; i > 0 ; i /= 2 ) {

for ( int j = 0 ; j < i; j++) { count += 1 ; } } O(N * N) O(N * log N) O(N * log(log(N))) O(N) O(N * Sqrt(N)) 정답보기 문제 #7. int i, j, k = 0 ; for (i = n/ 2 ; i <= n; i++) { for (j = 2 ; j <= n; j = j * 2 ) { k = k + n/ 2 ; } } Θ(n) Θ(nLogn) Θ(n^2) Θ(n^2 / Logn) Θ(n^2Logn) ** Big-Θ 문제는 잘 안나옵니다. 만약 어떤 알고리즘의 시간복잡도가 Big-O로 표기했을 때 O(n) 이고 Big- Ω로 표기해도 O(n) 이라고 가정해 봅시다. 이런 경우에 이 알고리즘은 Θ(n)이 될 수 있습니다. 만약 Big-O로 표기했을 때 O(n) 인데 Big- Ω로는 다른 값이 나온다면, 이 알고리즘은 Θ값으로 표기할 수 없습니다. 그래서 Big-Θ 문제를 푸시려면, 시간 복잡도를 표기하는 Big-O, Big- Ω, Big-Θ 를 모두 알아야 하기 때문에 아주 가아아아끔 가뭄에 콩 나듯 출제됩니다. 그래서 정답 옵션 중, '빅-세타로 표현할 수 없음.' 이 있으면 골치 아픕니다. 근데... 면접관님들도 잘 모르실듯...;;; 한 느낌적인 느낌? Big-O 시간복잡도를 제외한, Big-O 공간복잡도, Big- Ω, Big-Θ 는 평소에 잘 쓰이지 않습니다. 우리는 모두 인간이라 잘 안쓰면.. 까먹.. ㅜㅜ 정답보기 문제 #8. int gcd( int n, int m) { if (n%m == 0 ) return m; if (n < m) swap(n, m); while (m > 0 ) {

n = n%m;

swap(n, m);

}

return n;

} # 조건 : n 은 m 보다 항상 큽니다.

정답보기

문제 #9. 다음 보기중 O(n^2)가 아닌 것은 무엇인가요?

(15^10) * n + 12099 n^1.98 n^3 / (sqrt(n)) (2^20) * n

정답보기

문제 #10. 아래 보기 중 가장 빠른 반복문을 고르세요.(n은 양의 정수)

for(i = 0; i < n; i++) for(i = 0; i < n; i += 2) for(i = 1; i < n; i *= 2) for(i = n; i > -1; i /= 2)

정답보기

문제 #11. 가장 빠른 순서대로 나열하세요.

f1(n) = 2^n

f2(n) = n^(3/2)

f3(n) = n Log n

f4(n) = n^(Log n) f5(n) = n!

f3(), f2(), f4(), f1(), f5() f3(), f2(), f1(), f4(), f5() f2(), f3(), f1(), f4(), f5() f2(), f3(), f4(), f1(), f5()

정답보기

문제 #12.

/*

* V 는 이미 정렬되어 있습니다 .

* V.size() = N

* searchNumOccurrence(V, k, 0, N-1) 가 호출되었습니다 .

*/

int myFunction(vector< int > &V, int k, int start, int end) {

if (start > end) return 0 ;

int mid = (start + end) / 2 ;

if (V[mid] < k) return myFunction(V, k, mid + 1 , end); if (V[mid] > k) return myFunction(V, k, start, mid – 1 );

return myFunction(V, k, start, mid – 1 ) + 1 + myFunction(V, k, mid + 1 , end);

}

O(sqrt N) O(log N) O(log^2 N ) O(N) O(N * log N) O(N * sqrt N)

정답보기

문제 #13.

int memo[ 101 ][ 101 ];

int findMinPath(vector >& V, int r, int c) {

int R = V.size();

int C = V[ 0 ].size();

if (r >= R || c >= C) return 100000000 ; // Infinity

if (r == R – 1 && c == C – 1 ) return 0 ;

if (memo[r][c] != – 1 ) return memo[r][c];

memo[r][c] = V[r][c] + min(findMinPath(V, r + 1 , c), findMinPath(V, r, c + 1 ));

return memo[r][c];

}

O(R*C*log(R*C))

O(2^(R + C)) O(R*C) O(R + C) O(R*R + C*C)

정답보기

문제 #14.

int j = 0 ;

for ( int i = 0 ; i < n; ++i) { while (j < n && arr[i] < arr[j]) { j++; } } O(n) O(n^2) O(nlogn) O(n(logn)^2) 정답보기 문제 #15. 이론적으로 QuickSort의 최악의 시간 복잡도는 어떻게 됩니까? O(n) O(log n) O(n^2) O(n log n) O(n(log n)^2) 정답보기

[Algorithm] 빅오 표기법과 시간 복잡도의 개념 및 예제

728×90

알고리즘에서 중요한 속성

1. 정확성 : 주어진 입력을 모두 처리하며 올바르게 출력해야 한다.

2. 효율성 : 문제를 효율적으로 해결해야 한다. 두 가지 변수로 측정

– 시간 복잡도 : 알고리즘이 얼마나 빠르게 결과를 출력하는지 측정, 입력 크기 n에 대한 시간 함수 T(n)으로 표현

– 공간 복잡도 : 원하는 결과를 얻기 위해 알고리즘이 얼마나 메모리를 사용하는지 측정, 입력 크기 n에 대한 메모리 사용 함수 S(n)으로 표현

빅오 표기법 (big-O)

– 점근적 분석의 한 방법

– 수학적 정의

– cg(n)은 모든 n >= n0에 대해 f(n)의 상한이다.

– 최고차항의 차수로 표현하고 계수와 낮은 차수의 항은 무시한다.

(예시) n^2 + n = O(n^2)

시간 복잡도

알고리즘에 주로 나오는 시간 복잡도.

시간이 커지는 순서로 나열했습니다 🙂

1. 상수 시간 O(1)

입력 크기와 상관없이 고정된 시간으로 계산한다면 알고리즘이 상수 시간(constant time)에 실행된다고 한다.

– 배열의 n번째 원소에 접근

– 스택에 push/pop

– 큐에 삽입/삭제

– 해시 테이블의 원소에 접근

2. 선형 시간 O(n)

알고리즘의 실행 시간이 입력 크기에 정비례

– 배열에서 검색, 최솟/최댓값 찾기 등 연산

– 연결 리스트에서 순회, 최솟/최댓값 찾기 등 연산

3. 로그 시간 O(logn)

알고리즘의 실행 시간이 입력 크기의 로그에 비례.

알고리즘의 각 단계에서 입력의 상당 부분(절반)을 방문하지 않고 지나간다.

– 이진 탐색(binary search) 알고리즘

4. N 로그 N 시간 O(nlogn)

알고리즘의 실행 시간이 입력 크기와 입력크기의 로그 곱에 비례.

이런 알고리즘은 입력의 절반(또는 일부)으로 나눌 때마다 각 부분을 독립적으로 처리

– 병합 정렬(merge sort)

– 퀵 정렬(quick sort) – 평균적인 성능, 최악의 시간 복잡도는 O(n^2)

– 힙 정렬(heap sort)

5. 이차 시간 O(n^2)

알고리즘의 실행 시간이 입력 크기의 제곱에 비례

이런 알고리즘은 각 원소를 다른 모든 원소와비교

– 버블 정렬(bubble sort)

– 선택 정렬(selectrion sort)

– 삽입 정렬(insertion sort)

6. 지수 시간 O(2^n)

입력 데이터들의 원소들로 만들 수 있는 모든 부분 집합을 생성

7. 계승 시간 O(n!)

입력 데이터의 원소들로 만들 수 있는 모든 순열을 생성

알고리즘 속 함수 실행 시간 도출

– 반복문 : 반복문 내 수문의 실행 시간과 반복 횟수의 곱. 시간 복잡도는 O(n)

– 중첩 반복문 : 모든 반복문 크기의 곱과 반복문 내 구문의 실행 시간을 곱한 것. 반복문 수를 c라고 할 때 시간 복잡도는 O(n^c)

– 연속 구문 : 연속된 구문의 실행 시간을 모두 더한다.

– if-else 구문 : if나 else 중 실행 시간이 더 많이 걸리는 블록을 선택, 나머지는 무시.

– 로그 구문 : 각 반복마다 입력 크기가 일정하게 감소. 시간 복잡도는 O(logn)

시간 복잡도 예제

int f(int n){ int m = 0; for (int i = 0; i < n; i++) { for(int j = 0; j < n; j++){ m += 1; } } return m; } > 시간 복잡도 : O(n^2)

int f(int n) { int i, j, m = 0; for (i = 0; i < n; i++) { for (j = 0; j < i; j++) { m += 1; } } return m; } > 시간 복잡도 : O(n + (n-1) + (n-2) + … + 1) == O(n(n+1)/2) == O(n^2)

int f(int n) { int i, m = 0; i = 1; while (i < n) { m += 1; i = i * 2; } return m; } > 시간 복잡도 : O(logn)

> 문제 공간을 매번 절반으로 나눔

int f(int n) { int i, j, k, m = 0; for (int i = 0; i < n; i++) { for (j = 0; j < n; j++) { m += 1; } } for (i = 0; i < n; i++) { for (k = 0; k < n; k++) { m += 1; } } return m; } > 시간 복잡도 : O(n^2) + O(n^2) = O(n^2)

> 두 반복문은 연속적이므로 두 그룹의 복잡도를 더한다.

int f(int n) { int i, j, m = 0; for (i = 0; i < n; i++) { for (j = 0; j < sqrt(n); j++) { m += 1; } } return m; } > 시간 복잡도 : O(n*√n) = O(n^(3/2))

int f(int n) { int i, j, m = 0; for (i = n; i > 0; i /= 2) { for (j = 0; j < i; j++) { m += 1; } } return m; } > 시간 복잡도 : O(n + n/2 + n/4 + n/8 + n/16 + …) == O(n)

> 중첩 반복문에서는 내부 반복문에서 시간 복잡도를 계산

728×90

반응형

[자료구조] 시간복잡도 Big-O 표기법 예제(c)

Author And Source

이 문제에 관하여([자료구조] 시간복잡도 Big-O 표기법 예제(c)), 우리는 이곳에서 더 많은 자료를 발견하고 링크를 클릭하여 보았다 https://velog.io/@qlwb7187/자료구조-시간복잡도-Big-O-표기법-예제c

저자 귀속: 원작자 정보가 원작자 URL에 포함되어 있으며 저작권은 원작자 소유입니다.

[Javascript] 시간 복잡도 정리 및 예제

빅오 표기법은 알고리즘의 최악의 경우 복잡도를 측정합니다. 빅오 표기법에서 n은 입력의 개수를 나타냅니다. 알고리즘을 구현할 때 빅오 표기법이 해당 알고리즘이 얼마나 효율적인지 나타내기 때문에 빅오 표기법은 중요합니다. 빅오와 관련된 질문으로 “n이 무한으로 접근할 때 무슨 일이 일어날까?”가 있을 수 있습니다.

일반적인 빅오 복잡도
[시간복잡도의 예]
1. O(1) – Constant Time

O(1)은 입력 공간에 대해 변하지 않습니다. 따라서 O(1)을 상수 시간이라고 부릅니다. n의 값이 얼마나 크든 상관이 없습니다. O(1) 알고리즘의 예로 배열에 있는 항목을 인덱스를 사용해 접근하는 경우가 있습니다.

function exampleConstant(arr) { console.log(arr[0]); }

2. O(n) – Linear Time

O(n)은 선형 시간이고 최악의 경우에 n번의 연산을 수행해야 하는 알고리즘에 적용됩니다. O(n)의 예로 0부터 n-1까지의 숫자를 출력하는 경우가 있습니다.

function exampleLinear(n) { for (let i = 0; i < n; i++) { console.log(i); } } 3. O( n²) - Quadratic Time O(n)과 마찬가지로 O(n²)은 2차 시간입니다. O(n^3)은 3차 시간이겠죠? 2차 시간과 3차 시간 복잡도의 예는 다음과 같습니다. function exampleQuadratic(n) { for (let i = 0; i < n; i++) { console.log(i); for (let j = i; j < n; j++) { console.log(j); } } } function exampleCubic(n) { for (let i = 0; i < n; i++) { console.log(i); for (let j = i; j < n; j++) { console.log(j); for (let k = j; k < n; k++) { console.log(k); } } } } 4. O(log n) - Log 로그 시간 복잡도를 지닌 알고리즘의 예는 2의 2승부터 n승까지의 항목들을 출력하는 경우가 있습니다. 예를 들어 exampleLogarithmic(10)은 다음 결과를 출력합니다. 2,4,8,16,32,64 로그 시간 복잡도의 효율은 백만 개의 항목과 같이 큰 입력이 있는 경우에 분명합니다. n이 100만이라고 하더라도 exampleLog는 log2(1,000,000)= 19.931.. 이기 때문에 단지 19개의 항목만을 출력합니다. 로그 시간 복잡도를 구현한 코드는 아래와 같습니다. function exampleLogarithmic(n) { for (let i = 2; i <= n; i*2) { console.log(i); } } * 혹시라도 log를 너무 오랜만에 접해 저처럼 까먹으신 분들을 위해 기억 하는데 도움이 되고자 적습니다. [시간 복잡도 비교] O(1) < O(log n) < O(n) < O(N log n) < O(n²) < O(2^n) n의 값이 커지면 커질수록, 시간복잡도가 복잡한 알고리즘은 수행 시간이 급격하게 길어지게 됩니다. References https://mathbang.net/595 https://joshuajangblog.files.wordpress.com/2016/09/1.jpg?w=638 자바스크립트로 하는 자료구조와 알고리즘(배세민)

시간 복잡도란?

1. 시간 복잡도

1-1. 시간 복잡도란?

1-2. Big-O 표기법

2. 예제

2-1. O(1)

2-2. O(n)

2-3. O(n²)

2-4. O(n³)

2-5. O(nm)

2-6. O(2ⁿ)

2-7. O(logn)

3. 그 외

3-1. 상수항 무시

3-2. 영향력이 낮은 항 무시

3-3. 대략적인 소요시간 추측하기

1. 시간 복잡도

1-1. 시간 복잡도란?

우리가 작성한 코드는 실행시간이 얼마나 걸릴까?

실행해보기 전에 정확한 시간을 추측하는 것은 힘들겠지만

반복문을 몇 번 사용했는지, 입력값은 어떻게 되는지 등을 통해 대략적으로 이 정도 되겠구나.. 를 추측할 수 있다.

즉, 우리는 입력값과 연산 수행 시간의 상관관계를 나타내는 척도를 시간 복잡도라고 한다.

1-2. Big-O 표기법

같은 알고리즘을 가지고 테스트를 하더라도 입력 값이 달라짐에 따라 수행 시간은 매우 짧아질 수도, 매우 길어질 수도 있다.

2

1 3 4 5 6 7 8 9 10

예를 들어 10개의 배열에 위처럼 숫자가 들어가 있다고 치자.

이 숫자를 오름차순으로 정렬하려면 ‘2’와 ‘1’만 바꿔주면 된다. 수행 시간이 아주 짧을 것이다.

10

9 8 7 6 5 4 3 2 1

하지만 만약 숫자가 처음부터 이렇게 들어가 있었다면…?

분명 수행 시간이 더 오래 걸릴 것이다. 오름차순 정렬하기에는 가장 최악의 상황인 것이다.

시간 복잡도는 보통 이런 최악의 상황일 때 걸리는 시간을 이용해 나타낸다.

그리고 이걸 Big-O 표기법이라고 한다.

그 외 다른 표기법은 여기에서 확인할 수 있다.

하지만 거의 대부분 Big-O 표기법을 이용해 시간 복잡도를 나타낸다.

1-3. 자료의 수에 따른 실행시간 변화

for(int i=0; i

알고리즘 시간 복잡도(Complexity) 쉽게 이해하기

반응형

복잡도란?

알고리즘의 성능을 나타내는 척도입니다.

복잡도는 시간 복잡도(Time Complexity)와 공간 복잡도(Space Complexity)로 나눌 수 있습니다.

시간 복잡도

알고리즘 문제를 해결할 때 단순히 ‘복잡도’라고 하면 보통 시간 복잡도를 의미합니다.

시간 복잡도는 특정한 크기의 입력에 대하여 알고리즘이 얼마나 오래 걸리는지를 의미하며, 알고리즘을 위해 필요한 연산의 횟수 또한 의미합니다.

시간 복잡도를 표현할 떄는 빅오(Big-O) 표기법을 사용합니다. 간단히 정의하자면 가장 빠르게 증가하는 항만을 고려하는 표기법입니다.

다음 아래 빅오 표기법 표는 위쪽에 있을수록 더 빠릅니다.

빅오 표기법 명칭 설명 O(1) 상수 시간(Constant time) 문제를 해결하는데 오직 한 단계 처리 O(logN) 로그 시간(Log time) 문제를 해결하는데 필요한 단계들이 연산마다 특정 요인에 의해 줄어듬 O(N) 선형 시간 문제를 해결하기 위한 입력 N 만큼 단계가 필요 O(NlogN) 로그 선형 시간 문제를 해결하기 위한 단계의 수가 N번에 그 하나의 N번당 단계들이 연산마다 특정 요인에 의해 줄어듬 O(N^2) 이차 시간 문제를 해결하기 위한 단계의 수는 입력값 N의 제곱 O(2^N) 지수 시간 문제를 해결하기 위한 단계의 수는 주어진 상수값 2의 N제곱

1. O(1)

int a = 4; int b = 8; System.out.println(a + b);

위 소스코드의 연산 횟수는 1입니다. 단순히 더하기 연산 한 번이 수행되기 때문에 이는 상수 연산이므로 시간 복잡도는 O(1)로 표현할 수 있습니다.

2. O(logN)

이진 탐색을 예로 들 수 있습니다. 이진 탐색은 탐색 범위를 절반씩 좁혀가며 데이터를 탐색하기 때문에 확인하는 데이터 개수가 절반씩 줄어든다는 점에서 O(logN)로 표현할 수 있습니다.

3. O(N)

int[] array = {3, 5, 2, 1, 4}; int sum = 0; for(int i = 0; i < array.length; i++) { sum += array[i]; } System.out.println(sum); 위 소스코드와 같이 array가 커짐에 따라 비례하여 연산을 수행하는 루프문 부분이므로 시간 복잡도는 O(N)으로 표현할 수 있습니다. 4. O(NlogN) 합병 정렬, 퀵 정렬을 예로 들 수 있습니다. 합병정렬의 분할 단계에서 분할되는 깊이가 logN에 비례합니다. 각 깊이별로 분할이 수행되어 합병해야 되는 배열의 수는 많아지지만, 총 원소의 수는 똑같습니다. (N개) 따라서, 각 깊이별로 수행되는 merge의 시간복잡도는 O(N)이 되며, 이것을 모든 깊이에 대하(logN개만큼) 수행하기 때문에 시간 복잡도는 O(NlogN)으로 표현할 수 있습니다. 5. O(N^2) int[] array = {3, 5, 2, 1, 4}; for(int i = 0; i < array.length; i++) { for(int j = 0; j < array.length; j++) { System.out.println(a+b); } } 위 소스코드와 같이 array 크기만큼 중첩루프를 사용하여 연산 수행하므로 시간 복잡도는 O(N^2)으로 표현할 수 있습니다. 6. O(2^N) 대표적으로 피보나치 수열을 예로 들 수 있습니다. 재귀가 역기능을 할 경우 해당 대며, 데이터량이 많아질수록 처리시간이 기하급수적으로 증가합니다. References 「이것이 코딩테스트다」 - 한빛미디어 (나동빈 저) 반응형

실전 대비 C 알고리즘 인터뷰: 1.3 시간 복잡도 예제

1 .3 시간 복잡도 예제

이 절에서는 코드만 보고 함수의 시간 복잡도를 빅오로 표현할 수 있는 예제를 살펴봅니다.

예제 1-1

int fun1 (int n) { int m = 0; for (int i = 0; i < n; i++) { m += 1; } return m; } 분석 시간 복잡도는 O(n)입니다. 예제 1-2 int fun2 (int n) { int i, j, m = 0; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { m += 1; } } return m; } 분석 시간 복잡도는 O(n2)입니다.

주요 시간 복잡도 정리

알고리즘 시간 복잡도의 순위는 다음과 같다.

O(1) < O( log n ) < O(n) < O(n log n) < O(n^2) < O(n^3) O(1)은 인풋의 크기가 소요 시간에 영향이 없으며 반복문이 없으면 대체로 O(1)이다. O(1) 함수 예제: def print_first ( my_list ) : print ( my_list [ 0 ] ) print_first ( [ 2 , 3 ] ) print_first ( [ 2 , 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 , 29 , 31 , 37 , 41 , 43 , 47 , 53 ] ) 반복문이 있고, 반복되는 횟수가 인풋의 크기와 비례하면 일반적으로 O(n)이다. O(n) 함수 예제: def print_each ( my_list ) : for i in range ( len ( my_list ) ) : print ( my_list [ i ] ) ) n번 반복하는 것이 아닌, n/2번 반복할 경우 O(n/2) 내 1/2도 버려서 결국엔 시간 복잡도는 여전히 O(n)이다. O(n) 함수 변형 예제 (n/2): def print_half ( my_list ) : for i in range ( len ( my_list ) // 2 ) : print ( my_list [ i ] ) 마찬가지로 O(3n)도 결국에는 3을 버려서 O(n)이라고 표현할 수 있다. O(n) 함수 변형 예제 (3n): def print_three_times ( my_list ) : for i in range ( len ( my_list ) ) : print ( my_list [ i ] ) for i in range ( len ( my_list ) ) : print ( my_list [ i ] ) for i in range ( len ( my_list ) ) : print ( my_list [ i ] ) 반복문 내 반복문이 연속해서 나오는 경우, 인풋의 크기가 반복문에 비례하여 나올 시, for문의 n개수만큼 곱한다. O(n^2) 함수 예제: def print_pairs ( my_list ) : for i in range ( len ( my_list ) ) : for j in range ( len ( my_list ) ) : print ( my_list [ i ] , my_list [ j ] ) 동일한 원리로, 인픗의 크기에 비례하는 반복문이 세 번 중첩되면 O(n^3)이다. O(n^3) 함수 예제: def print_triplets ( my_list ) : for i in range ( len ( my_list ) ) : for j in range ( len ( my_list ) ) : for k in range ( len ( my_list ) ) : print ( my_list [ i ] , my_list [ j ] , my_list [ k ] ) 이번에는 O(log n)이 되는 경우를 알아보자. 인풋이 리스트가 아닌 정수를 출력할 때, 정수의 값이 2배로 커지는 경우의 반복문은 O(log n)이 된다. 인풋 n이 128일 경우, i가 1일 때부터 2,4,8,16,32,64까지 총 7번 실행한다. log 128 = 7인 값을 낼 수 있다. O(log n) 함수 예제: def print_powers_of_two ( n ) : i = 1 while i < n : print ( i ) i = i * 2 곱하기가 아닌 나눗셈으로 n부터 시작해서 반 씩 나눌 경우도 마찬가지로 O(log n)의 값을 낸다. O(log n) 함수 예제: def print_powers_of_two ( n ) : i = n while i > 1 : print ( i ) i = i / 2

반복문이 두 개 있는데 한 개는 인풋에 비례하고, 다른 하나는 정수에 비례할 경우 O(log n)의 시간 복잡도를 표현할 수 있다.

O (n log n) 함수 예제:

def print_powers_of_two_repeated ( y ) : for i in range ( n ) : j = 1 while j < n : print ( i , j ) j = j * 2 위 코드의 경우 for문의 반복횟수는 n에 비례하는 반면, while문의 반복횟수는 log n에 비례한다. 따라서, 시간 복잡도는 O(n log n)이다. for문이 while에 중첩되느냐, while문이 for문 내에 중첩되느냐에 상관없이 반복횟수는 각각의 반복문의 곱셈의 값이다. O (n log n) 함수 변형 예제: def print_powers_of_two_repeated ( n ) : i = 1 while i < n : for j in range ( n ) : print ( i , j ) i = i * 2 기본 O(n log n) 함수 예제에서 중첩의 경우를 바꾼 것이지만 마찬가지로 시간 복잡도는 O(n log n)이다.