빅 O,당신은 어떻게 계산/대략적인 그것은?

https://stackoverflow.com/questions/3255

08-06-2019
|

문제

대부분의 사람들과에서 학위 CS 은 확실히 알 O 미.하는 데 도움이 측정 방법(in)의 효율적인 알고리즘 정말 알고 있는 경우 어떤 종류의 문제를 해결하기 위해 노력하고 있는 알아낼 수 있는 경우 그것은 여전히 가능하 짜내는 성능이다.¹

하지만 내가 궁금해서,어떻게 당신 계산 또는 대략의 복잡도 알고리즘?

¹ _{하지만 그들이 말하는 무리하지 않고, 조 최적화는 모든 악의 뿌리, 고 최적화없이 정당화 원인을 받아야 한다는 이름니다.}

해결책

내가하기 위해 최선을 다하겠 설명 그것은 여기에 간단한 약관,하지만 경고하는 이 항목은 학생들의 몇 개월 마지막으로 파악한다.자세한 정보를 찾을 수 있습니다에서 2 장 데이터 구조와 알고리즘에서 Java 책입니다.

이 없 기계적 절차 하는 데 사용할 수 있는 얻을 BigOh.

으로"책",을 얻 BigOh 조각에서의 코드 첫 번째는 것을 깨달을 필요가 있을 만들 수학 수식 계산하는 방법에는 많은 단계의 계산이 실행되어 입력의 일부 크기입니다.

목적 간단하다:을 비교하는 알고리즘에서는 이론적인 관점,할 필요없이 실행하는 코드입니다.낮은 수의 단계,빠른 알고리즘이 있습니다.

예를 들어,당신이 조각의 코드:

int sum(int* data, int N) {
    int result = 0;               // 1

    for (int i = 0; i < N; i++) { // 2
        result += data[i];        // 3
    }

    return result;                // 4
}

이 기능은 반의 합의 모든 요소를 배열을,우리를 만들려는 수식 계산 계산적 복잡성 의 것 기능:

Number_Of_Steps = f(N)

그래서 우리는 f(N), 기능의 수를 계산 전산 단계가 있습니다.입력의 기능 구조체의 크기를 과정입니다.그것이 의미하는 이 함수를 호출과 같은:

Number_Of_Steps = f(data.length)

매개변수 N 걸리 data.length 값이 있습니다.지금 우리가 필요한 실제적인 함수 정의 f().에서 수행한 소스 코드에서는 각각의 흥미로운 라인에는 1 번부터 4.

많은 방법이 있을 계산하 BigOh.이 시점에서 앞으로 우리가 가는 모든 문장에 의존하지 않는 크기의 입력 데이터는 일정한 C 번호 전산 단계가 있습니다.

우리는 가 추가 개인번호의 단계 기능,그리고 어느 지역 변수 선언으며 return 문의 크기에 따라 달라집합 data 배열입니다.

는 것을 의미하는 라인 1 4C 량의 단계 각각의 기능은 다소 다음과 같다:

f(N) = C + ??? + C

다음 부분은 정의의 값 for 문입니다.기억 우리가 세 번호 전산모사의 단계는 것을 의미합체의 for 문 얻 실행 N 다.그의 동일한으로 추가 C, N 시간:

f(N) = C + (C + C + ... + C) + C = C + N * C + C

가 없는 기계적인 규칙을 얼마나 많은 시간의 몸 for 실,당신은 그것을 계산에 의해 무엇을 찾고 있는 코드는 않습니다.계산을 단순화하는,우리는 무시한 변수 초기화 상태로 증가 및 부속의 for 문입니다.

을 얻을 실제 BigOh 리 Asymptotic analysis 의 기능입니다.이것은 대략은 다음과 같이 수행:

하는 서비스를 받는 회원 및 비회원을 상수 C.
서 f() 을 얻 polynomium 그 standard form.
분할의 조건 polynomium 및 정렬이 그들에 의해 평가의 성장입니다.
계속 한 성장하는 더 큰 경우 N 접근법 infinity.

리 f() 는 두 개의 조건:

f(N) = 2 * C * N ^ 0 + 1 * C * N ^ 1

리 모든 C 상수하고 중복되는 부품:

f(N) = 1 + N ^ 1

이후 기간은 중 하나 성장하는 더 큰 경우 f() 가(생각에 제한)이 BigOh 인수,그리고 sum() 기능 BigOh 의:

O(N)

거기에 몇 가지 기술 일부를 해결하기 위해 까다로운 것들:사 합계 문제를 해결할 수 있습니다.

예를 들어,이 코드는 쉽게 해결할 수있를 사용하여 합계:

for (i = 0; i < 2*n; i += 2) {  // 1
    for (j=n; j > i; j--) {     // 2
        foo();                  // 3
    }
}

첫 번째 것은 당신이하는 데 필요한 요청이의 실행 순서 foo().는 동안 일반적인 이야 O(1),에게 필요한 교수들에 대한니다. O(1) 단(거의 대부분)일정한 C, 독립적인 크기 N.

이 for 문에 문장이 수은 까다 롭습니다.는 인덱스에서 끝나 2 * N, 증가에 의해 수행되는 두.는 것을 의미는 첫 번째 for 져만 실행 N 단계,그리고 우리는 나누어야 하는 수입니다.

f(N) = Summation(i from 1 to 2 * N / 2)( ... ) = 
     = Summation(i from 1 to N)( ... )

문장 번호 두 개의 도 난이도에 따라 이후의 가치 i.을 보라:수는 값:0, 2, 4, 6, 8, ..., 2 * N 고,두 번째 for 을 얻을 수행:N 번째 중 하나,N-2 두 번째,N-4 세 번째...최 N/2 단계에서 두 번째 for 지 않이 실행됩니다.

에 수식,그 의미합니다:

f(N) = Summation(i from 1 to N)( Summation(j = ???)(  ) )

다시는 우리가 계산 단계의 수.그리고,모든 요약해야 항상 중 한 곳에서 시작 및 끝 번호에서 더 큰 또는 동등한 보다 하나입니다.

f(N) = Summation(i from 1 to N)( Summation(j = 1 to (N - (i - 1) * 2)( C ) )

(우리는 가정 foo() 가 O(1) 고 C 단계가 있습니다.)

우리는 여기서 문제가:면 i 은 값 N / 2 + 1 위쪽으로 내면의 합계로 끝나는 부정적인 수!는 불가능하고 잘못입니다.우리가 분할해야 합산에서 두 개의되고,중요한 포인트는 순간 i 립 N / 2 + 1.

f(N) = Summation(i from 1 to N / 2)( Summation(j = 1 to (N - (i - 1) * 2)) * ( C ) ) + Summation(i from 1 to N / 2) * ( C )

때문에 중요한 순간 i > N / 2, 내부 for 지 않을 것을 얻을 실행,그리고 우리는 가정하면 일정한 C 실행 복잡성에 몸입니다.

지금 합계 간소화할 수 있습니다 일부를 사용하여 신원칙:

합계(w 에서 1N)(C)=N*C
합계(w 에서 1N)(A(+/-)B)=합계(w 에서 1N)(A)(+/-)합계(w 에서 1N)(B)
합계(w 에서 1N)(w*C)=C*합계(w 에서 1N)(w)(C 은 일정의 독립적 w)
합계(w 에서 1N)(w)=(N*(N+1))/2

일부를 적용하여 대수:

f(N) = Summation(i from 1 to N / 2)( (N - (i - 1) * 2) * ( C ) ) + (N / 2)( C )

f(N) = C * Summation(i from 1 to N / 2)( (N - (i - 1) * 2)) + (N / 2)( C )

f(N) = C * (Summation(i from 1 to N / 2)( N ) - Summation(i from 1 to N / 2)( (i - 1) * 2)) + (N / 2)( C )

f(N) = C * (( N ^ 2 / 2 ) - 2 * Summation(i from 1 to N / 2)( i - 1 )) + (N / 2)( C )

=> Summation(i from 1 to N / 2)( i - 1 ) = Summation(i from 1 to N / 2 - 1)( i )

f(N) = C * (( N ^ 2 / 2 ) - 2 * Summation(i from 1 to N / 2 - 1)( i )) + (N / 2)( C )

f(N) = C * (( N ^ 2 / 2 ) - 2 * ( (N / 2 - 1) * (N / 2 - 1 + 1) / 2) ) + (N / 2)( C )

=> (N / 2 - 1) * (N / 2 - 1 + 1) / 2 = 

   (N / 2 - 1) * (N / 2) / 2 = 

   ((N ^ 2 / 4) - (N / 2)) / 2 = 

   (N ^ 2 / 8) - (N / 4)

f(N) = C * (( N ^ 2 / 2 ) - 2 * ( (N ^ 2 / 8) - (N / 4) )) + (N / 2)( C )

f(N) = C * (( N ^ 2 / 2 ) - ( (N ^ 2 / 4) - (N / 2) )) + (N / 2)( C )

f(N) = C * (( N ^ 2 / 2 ) - (N ^ 2 / 4) + (N / 2)) + (N / 2)( C )

f(N) = C * ( N ^ 2 / 4 ) + C * (N / 2) + C * (N / 2)

f(N) = C * ( N ^ 2 / 4 ) + 2 * C * (N / 2)

f(N) = C * ( N ^ 2 / 4 ) + C * N

f(N) = C * 1/4 * N ^ 2 + C * N

과 BigOh 입니다:

O(N²)

다른 팁

O 은 상한 시간 복잡도 알고리즘.그것은 일반적으로 사용되는과 함께 데이터 처리 설정(목록)하지만 사용될 수 있습니다.

의 몇 가지 예는 어떻게 그것의 사용에서는 C 코드입니다.

우리가 배열의 요소 n

int array[n];

하려는 경우스의 첫 번째 요소는 배열을 이 O(1)지 않기 때문에 얼마나 큰 배열을,그것은 항상 같은 일정한 시간을 얻을 먼저 항목입니다.

x = array[0];

만약 우리가 원하는 번호를 찾을 수 있에서 목록:

for(int i = 0; i < n; i++){
    if(array[i] == numToFind){ return i; }
}

이 O(n)기 때문에 가장 우리가 보고를 통해 전체 목록을 찾을 수 있 우리의 숫자입니다.Big-O 은 여전히 O(n)더라도 우리는 우리의 번호를 찾을 수 있습니다 첫 번째 시도하고 실행을 통해 반복하기 때문에 한 번 Big-O 에 대해 설명합 상한 알고리즘(가 낮은 바타는 단단한 바인딩).

우리가 중첩된 소프트웨어

for(int i = 0; i < n; i++){
    for(int j = i; j < n; j++){
        array[j] += 2;
    }
}

이 O(n^2)이후는 각 전달의 외부 루프(O(n))우리가 전체 목록을 다시 그렇게 n 의 곱으로 우리를 떠나 n 제곱.

이것은 거의 표면을 긁는 하지만 때를 얻을 분석하는 더 복잡한 알고리즘의 복잡한 수학에 관련된 증거를 제공합니다.희망이 끊이지 당신은 기초에서 적어도 하지만입니다.

알고있는 동안 어떻게 그 큰 O 시간에 대한 특정 문제입니다 유용한 알고,몇몇 일반적인 경우 먼 길을 갈 수 있습에서 당신이 결정을 내릴 수 있도록에 당신의 알고리즘이 있습니다.

여기에 몇 가지의 가장 일반적인 경우,해제에서 http://en.wikipedia.org/wiki/Big_O_notation#Orders_of_common_functions:

O(1)-를 결정하는 경우 수정할 수 있도록 또는 odd;를 사용하여 일정한 크기의 테이블 조회 또는 해쉬테이블

O(logn)-을 찾는 항목에서 정 배열 검색

O(n)-을 찾는 항목에서 정렬되지 않은 목록;추가 두 n-자리 숫자

O(n²)-두 개의 곱 n-자리 숫자에 의해 간단한 알고리즘;추가 두 n×n 매트릭스;거품을 정렬하거나 삽입 정렬

O(n³)-두 개의 곱 n×n 매트릭스에 의해 간단한 알고리즘

O(cⁿ)-을 찾는 것(정확한)솔루션을 외판원 문제를 사용하여 동적 프로그래밍;을 결정하는 경우 논리적 문은 동등한 무력을 사용하는

O(n!) 이 외판원 문제를 통해 무차별 검색

O(nⁿ)-자주 사용하는 대신 O(n!) 파생 간단한 수식에 대한 근사 복잡성

작 알림:이 big O 표기법은 사용을 나타내 asymptotic 복잡성(즉,문제의 크기 성장을 무한), 고 그것은 숨을 일정하게 유지되었습니다.

이것이 의미하는 사이에 알고리즘 O(n)및에서 하나 O(n²다),가장 빠른 항상 첫번째 중 하나(그러나 거기에 항상 존재하는 n 값의 그러한 문제의 크기>n,처음 알고리즘 가장 빠르게).

참고 숨겨진 일정한 매우 많은 구현에 따라 달라집!

또한,어떠한 경우에는,런타임이 없는 결정적인 기능의 크기 n 의 입력이 있습니다.을 정렬이 사용하여 빠른 종류를 위한 예제:시간하는 데 필요한 종류의 배열 요소 n 이 일정하지 않지만에 따라 달라집을 시작 구성의 배열입니다.

다른 시간 복잡:

최악의 경우(일반적으로 가장 간단한 그 밖으로 항상 그렇지는 않지만,매우 의미심장)
평균 케이스(일반적으로 많은 열심히 그림 밖으로...)
...

좋은 소개 한 소개입을 분석하는 알고리즘의 R.Sedgewick 및 P.Flajolet.

당신 말대로, premature optimisation is the root of all evil, 고(가능하면) 프로파일링 정말 항상 사용할 때 최적화 코드입니다.할 수 있도를 결정하는 데 도움이의 복잡도 알고리즘이 있습니다.

답변을 보는 여기에서 내가 생각하는 결론을 내릴 수 있는 대부분의 우리가 실제로 대략적인 순서 알고리즘에 의해 보 에 그것을 사용하여 일반적인 감각을 대신 계산하는것으로,예를 들어, 마스터 방법 우리가 생각에서 대학교도 있습니다.그 말과 함께 추가해야 한다 심지어는 교수는 격려 우리에(이후에)제 생각 에 대한 계산습니다.

또한 추가하고 싶다는 방법에 대해 수행 재귀적 기능:

가정 우리는 같은 기능(표 코드):

(define (fac n)
    (if (= n 0)
        1
            (* n (fac (- n 1)))))

는 재귀적으로의 계승을 계산합됩니다.

첫 번째 단계는 시도하고 결정하는 성능 특성에 대한 몸의 기능만 이 경우에는,아무것도 특별한 한 몸에 곱하기(또는 반환 값 1)입니다.

그래서 성능한 신체:O(1) (일정).

다음을 시도하고 이를 확인에 대한 의 번호를 재귀적화.이 경우에 우리는 n-1recursive 호출합니다.

그래서 성능한 재귀 전화:O(n-1) (주 n,우리가 던져 사소한 부분).

다음을 넣어 두 가지를 함께 당신이 다음 성능이 전체에 대한 재귀적 기능:

1*(n-1)=O(n)

피, 답변, 당신의 제 문제점; 방법은 여기서 설명하는 실제로 처리이다.하지만 이것은 아직도 근사 지 전체를 수학적으로 올바른 대답이다.방법은 여기서 설명하는 또 하나의 방법을 우리가 배운 대학에서,그리고 내가 기억하는 올바르게 사용되었다 훨씬 더 많은 고급 알고리즘보다는 요인에서 내가 사용하는 이 예입니다.
물론 그것은 모든 방법에 따라 잘 수 있습니다 추정하는 실행 시간의 신체 기능의 수 및 재귀적인 통화,그러나 그 사실을 위한 다른 방법이 있습니다.

는 경우의 비용은 다항식,그냥 계속 가장 높은 순서 장기하지 않고,그것의 승수입니다.E.g.:

O((n/2+1)*(n/2))=O(n²/4+n/2)=O(n²/4)=O(n²)

이 작동하지 않는 무한 시리즈,당신을 마음.이 없다 하나의 레시피에 대한 일반적인 경우,하지만 몇 가지 일반적인 경우,다음과 같은 불평등이 적용됩니다:

O(로그인 N) < O(N) < O(N 로그인 N) < O(N²) < O(N^k) < O(eⁿ) < O(n!)

난 그것에 대해 측면에서의 정보입니다.어떤 문제로 구성되어 있는 학습의 특정 숫자의 비트입니다.

귀하의 기본적인 도구의 개념이 결정 포인트 및 그들의 엔트로피했습니다.의 엔트로피를 결정을 내 지점은 평균 정보 그것은 당신에게 줄 것이다.예를 들면,프로그램을 포함한 결정을 지점에 두 개의 지점,그것은 엔트로피의 합의 확률은 각 지점 번의 로그인₂ 의 역할 확률는 지점에 있습니다.는 얼마나 많이 배우고 실행하여 그 결정이다.

예를 들어, if 문를 갖는 두 가지를 모두 동일하게 할 가능성이있는 엔트로피의 1/2*로그(2/1)+1/2*로그인(2/1) = 1/2 * 1 + 1/2 * 1 = 1.그래서 그것의 엔트로피는 1 비트입니다.

당신이 검색 표 N 항목처럼,N=1024.는 10 비트 문제 때문에 로그(1024)=10 비트입니다.그래서 만약 당신이 검색 할 수 있습니다 그것과 함께 경우는 문이 동등하게 높은 결과,10 을 결정합니다.

는 당신이 무엇을 얻을 바이너리로 검색합니다.

당신이 당신을하고 선형 검색합니다.당신이 볼 첫 번째 요소와 요청하는 경우 그것이 당신이 원하는 것 있습니다.확률은 1/1024 는 그것은,그리고 1023/1024 는 그것은 아닙니다.의 엔트로피는 결정은 1/1024*로그(1024/1)+1023/1024*로그인(1024/1023) = 1/1024 * 10 + 1023/1024 * 0 내====.01 비트입니다.당신이 배웠어요 아주 작은!두 번째 결정을 훨씬 더 나은 되지 않습니다.그 이유는 선형 검색을 수도 있습니다.사실 그것은 기하급수적 비트의 수신을 배울 필요가 있다.

당신이 당신을 인덱싱.가정하자면 테이블이 미리 정의 많은으로,쓰레기통을 사용해 일부 의 모든 비트에서 핵심 인덱스 테이블에 직접 항목입니다.이 있는 경우 1024 쓰레기통,엔트로피는 1/1024*로그(1024)+1/1024*로그(1024)+...에 대한 모든 1024 가능한 결과입니다.이 1/1024*10 시간 1024 결과,또는 10 비트 엔트로피는 인덱싱 동작이다.그 이유는 인덱싱 검색이 빠릅니다.

지금 생각에 대한 정렬됩니다.당신 N 항목 및 수 있습니다.에 대한 각각의 항목이 있을 검색하는 항목에 목록을 추가한다.그래서 정렬는 약 N 번수 단계의 근본적인 검색합니다.

그래서 종류에 따라 이진 결정하는 데 대략 동등하게 높은 결과 모든 약 O(N 로그 N)단계가 있습니다.O(N)정렬 알고리즘은 가능한 경우에 따라 인덱싱을 검색합니다.

내가 찾는 거의 모든 알고리즘 성능 문제를 조회 할 수 있습니다 이런 방식입니다.

시작할 수 있습니다.

먼저,원칙을 적는 특정 간단한 데이터에 대한 작업 수행 O(1) 시간에서,즉,시간의 독립적인 크기의 입력이 있습니다.이러한 기본 작업으로 구성 C

연산(예:+나%).
논리 연산(예를 들어,&&).
비교 연산(예를 들어, <=).
구조물에 액세스하는 작업(예:배열 색인처럼[i]또는 포인터 fol- lowing 과->operator).
간단한 과제로 복사하는 것과 같이 값을 변수입니다.
전화 라이브러리 함수(예를 들어,scanf,printf).

의 정당성에 대한 이 원리를 필요로 상세한 공부의 기계 지침(기본 단계)전형적인 컴퓨터입니다.의 각각 설명하는 작업을 수행할 수 있습니다 몇 가지 작은 수를 기계 지침자주 하나 또는 두 개의 지침이 필요합니다.결과적으로,여러 가지 종류의 문 C 에 실행할 수 있습니다 O(1) 시간에서,즉,일부 일정한 양의 시간의 독립적인 입력이 있습니다.이러한 간단한 포함

할당 문을 포함하지 않는 함수 호출에 그들의 표현입니다.
읽기 문이 있습니다.
쓰 문을 필요로하지 않는 함수 호출을 평가하는 인수입니다.
점프 문의 휴식,계속,고토,그리고 반환되는 표현을,어디서 식 포함되지 않은 함수 호출합니다.

C 많은 위한 루프가 형성된 초기화하여 인덱스를 가변하는 어떤 가치와 증가하는 변수에 의해 각각 1 시간 루프 주위에.이에 대한 반복을 끝나는 경우 인덱스에 도달한 제한.예를 들어,위해 루프

for (i = 0; i < n-1; i++) 
{
    small = i;
    for (j = i+1; j < n; j++)
        if (A[j] < A[small])
            small = j;
    temp = A[small];
    A[small] = A[i];
    A[i] = temp;
}

사용하는 지수의 변수 i.그것이 증가하여 각 1 시간 루프 주위에,그리고 반복 멈출 때에 도달 n−1.

그러나는 순간에 초점을 단순한 형태의를 위해 루프가 차이는 최종 및 초기 값을 나누어,양에 의하여하여 인덱스의 변수가 증가하는 방법을 우리에게 알려줍니다 많은 시간을 우리는 돌아 루프.는 횟수가 정확하지 않는 한 방법이 있을 종료한 루프를 통해 뛰어 문장;그것은 상에서 반복 횟수 어떤 경우에도 빠지지 않았습니다.

예를 들어,위해 루프 반복 ((n − 1) − 0)/1 = n − 1 times, 부터 0 초기 값 i,n−1 가장 높은 값에 의해 도달 i(즉,때 나 에 도달 n−1,지고 없이 반복 발생 i=n−1),1 는 추가 i 에서의 각 반복합니다.

가장 간단한 경우,어디에 소요되는 시간을 반복 몸이 각각 동일 반복 우리는 곱할 수있는 큰 오 상 몸의 수에 의하여 시간 루프 주위에.엄격히 말하자면,우리는 그런 다음 add O(1)초기화 시간 루프 인덱스와 O(1)의 시각을 위한 첫 번째 비교 루프의 인덱스 제한, 기 때문에,우리는 테스트 중 하나는보다 더 많은 시간이 우리 주위에 이동합니다.그러나지 않는 한, 그것은 실행이 가능 루프로 시간,시간을 초기화 루프 및 테스트 한번은 저해될 수 있는 기간에 의해 삭제 합계 규칙이 있습니다.

이제 다음 예제를 살펴보십시오:

(1) for (j = 0; j < n; j++)
(2)   A[i][j] = 0;

우리가 알고 있는 라인(1) 립 O(1) 시간입니다.분명히,우리 주위에 이동 반복 n 배로 우리는 확인할 수 있습을 빼서 하한 상한가에서 발견에선 (1)다음에 추가 1.이후,바디 라인(2),소 O(1)시간,우리가 할 수 있습을 게을리 시간을 증가 j 시간과 비교 j n,모두의는 또한 O(1).따라서,실행 시간의(1)및(2) 제품의 n O(1), 는 O(n).

마찬가지로,우리는 할 수 바인딩된 실행 시간의 외부 루프로 구성된 라인 (2)(4),가

(2) for (i = 0; i < n; i++)
(3)     for (j = 0; j < n; j++)
(4)         A[i][j] = 0;

우리는 이미 설정된 루프 라인의(3)및(4)소 O(n)시간입니다.따라서,우리는 무시할 수 있 O(1)는 시간을 증가 나는지 여부를 테스트하는 내가 < n 각 반복,그 결론 각 반복의 외부 루프는 O(n)시간입니다.

초기화 i=0 의 외부 루프(n+1)세인트의 시험 조건 나 < n 마찬가지로 취 O(1)간 및 수 있는 무시할 수 있습니다.마지막으로,우리는 우리가 우리가 가서 이것을 관찰 외부 루프 n 시간 복용,O(n)시간에 대한 각 반복을주는,총 O(n^2) 실행하는 시간입니다.

더 실용적인 예이다.

enter image description here

하려는 경우 추정하기 위해 코드의 경험적으로 보다는 오히려 분석을 통해 코드에,당신은 스틱 시리즈의 증가하는 값의 n 및 시간 당신의 코드입니다.줄거리 당신의 타이밍을 로그에는 규모입니다.만약 코드 O(x^n)의 값을 가을해야의 라인에 슬로프 n.

이는 여러 가지 이점을 통해 공부합니다.한지 여부를 확인할 수 있습니다 당신은 범위에서 실행 시간에 접근 순서입니다.또한,당신은 당신을 찾을 수 있는 코드를 가지고 생각했기 위해 O(x)은 정말 순 O(x^2),예를 들어,기 때문에 소요되는 시간 라이브러리에서 호출합니다.

기본적으로 일하는 농작물의 90%는 시간이를 분석하는 루프가 있습니다.당신은 단일,이중,삼중 중첩된 루프?에 있 O(n),O(n^2),O(n^3)실행하는 시간입니다.

아주 드물게(지 않는 한 당신이 쓰는 플랫폼을 광범위한 기반 라이브러리(예를 들어,니다.NET BCL,또는 C++'s STL)발생할 것이라는 것보다 더 어려운 단지에서 찾고 루프(에 대한 문의는 동안,고토,등등...)

분 알고리즘은 조각으로 알고 있 O 표기 위해,그리고 결합을 통해 큰 오산자입니다.는 유일한 방법으로 나가 알고 있습니다.

자세한 정보는 확인 Wikipedia 페이지 게 확인할 수 있게 되었습니다.

O 표기용하기 때문에 그것의 쉬운 작동하고 숨겨 불필요한 합병증과 세부정보(일부의 정의 불필요).중 하나는 좋은 방법은 작업의 복잡성의 분할 및 정 알고리즘은 나무는 방법입니다.당신 버전의 퀵 중간 절차,그래서 당신은 배열을 분할에 완벽하게 균형 잡힌 subarrays 니다.

라 나무에 해당하는 모든 배열니다.루트에서 당신이 원래의 배열을,루트에는 두 개의 어린이는 subarrays.이것을 반복할 때까지 하나의 배열 요소 아래에 있습니다.

때문에 우리가 찾을 수 있습니다 중간에 O(n)시간과 배열을 분할에서 두 개의 부품에 O(n)시간에서 수행 된 작업이 각 노드를 O(k)는 k 가 배열의 크기.각 레벨의 나무 들어가 있습니다(대부분)에서 전체 배열 그래서 작업 레벨 당 O(n)(크기의 subarrays 추가 할 n,그리고 그 이후 우리는 O(k)당 수준을 추가할 수 있습니다 이).만 있 로그(n)수준에서 트리 이후 매번 우리가 절반으로 줄이 입력한다.

따라서 우리는 상한 금액의 작동에 의해 O(n*로그(n)).

그러나,O 숨기 일부 정보는 우리는 때때로 무시할 수 없는.고려한 컴퓨팅 피보나치

a=0;
b=1;
for (i = 0; i <n; i++) {
    tmp = b;
    b = a + b;
    a = tmp;
}

고 있다는 가정은 a 와 b BigIntegers 에 자바나 뭔가를 처리할 수 있는 임의의 큰 숫자입니다.대부분의 사람들은 말을 이 O(n)알고리즘은 아무 문제없이.추론하는 n 반복에 대한 루프 O(1)작업에서 측합니다.

그러나 피보나치 숫자는 큰,n 피보나치 수가 기하급수적입 n 그래서 그것을 저장하는 것을 주문 n 바이트입니다.을 수행한 큰 것입니다 정수 시장(n)양의 작동합니다.그래서의 총량에서 수행 된 작업이 절차

1 + 2 + 3 + ...+n=n(n-1)/2=O(n^2)

그래서 이 알고리즘에서 실행됩 quadradic 시간!

에 익숙한 알고리즘/데이터 구조에 사용 및/또는 빠른 눈을 분석의 반복이 중첩이 있습니다.어려움을 호출할 때에는 라이브러리 함수,아마도 여러 번-당신은 종종 수지의 여부는 함수를 호출에 불필요하게 번이나 무엇을 구현서 사용할 수 있는 지를 확인합니다.어쩌면 라이브러리 함수해야한 복잡성/효율성을 측정 할 수 있는지 여부,O 또는 다른 메트릭에서 사용할 수 있는 문서 또는 IntelliSense.

적용하는 일반적으로,생각,그러나 완전성을 위해기도 빅 오메가 Ω, 을 정의하는 낮은 바인딩에는 알고리즘의 복잡성과 큰타 Θ, 는,정의를 모두 살니다.

로"당신은 어떻게 계산"O,이것은 부분의 계산 복잡도 이론.일(많은)특별한 경우를 수 있습을 함께 몇 가지 간단한 추론(같은 곱하여 루프 수에 대한 중첩된 루프),esp.을 때 당신이 원하는 모든 어떤 상의 추정,그리고 당신이 쓰지 않는 경우가 너무 비관적-는 것은 아마도 당신의 질문에 대해서입니다.

만약 당신이 정말로 원하는 귀하의 질문에 대답한 알고리즘 당신이 할 수 있는 최고의를 적용하는 이론입니다.외의 단순한"최악의 경우에"내가 찾 분석 청산 분석 연습에 매우 유용합니다.

1 경우,내부 반복 실행 n-i 간에,그래서 총 수의 실행 합계 i 서 0 하기 n-1 (기 때문에 보다 낮보다 낮은,또는 동등한 것)의 n-i.당신이 얻을 마지막으로 n*(n + 1) / 2, 래 O(n²/2) = O(n²).

2 루프 i 사 0 고 n 포함한 외부 루프내부 루프가 실행될 때 j 은 엄격하게 더 큰 것보다 n, 는 불가능합니다.

또한 사용을 마스터 방법(중 하나 또는 해당 전문 분야),테스트 알고리즘을 실험적으로.이 수 없 증명 는 어떤 특정의 복잡성 등이 달성,하지만 그것은 확신을 제공할 수 있습는 수학적 분석은 적절하다.하는 데 도움이 안심,내가 사용하는 코드 검사 도구와 함께 내는 실험을 보장하기 위해,나는 운동하는 모든 경우.

으로 아주 간단한 예제는 너를 말하고 싶어 정신을 확인에 속도니다.NET 프레임워크의 목록을 정렬합니다.를 작성할 수 있습 다음과 같이,다음 분석 결과 엑셀에서 확인하는 그들이 초과 하지 않았 n*로그(n)곡선입니다.

이 예에서 나는 측정의 번호 비교를 하지만 그것은 또한 신중한 검사를 실제 시간을 각각에 필요한 샘플 크기입니다.그러나 당신은 더욱 신중해야 하는 당신은 단지 측정 알고리즘을 포함하지 않는 유물 테스트에서 infrastructure.

int nCmp = 0;
System.Random rnd = new System.Random();

// measure the time required to sort a list of n integers
void DoTest(int n)
{
   List<int> lst = new List<int>(n);
   for( int i=0; i<n; i++ )
      lst[i] = rnd.Next(0,1000);

   // as we sort, keep track of the number of comparisons performed!
   nCmp = 0;
   lst.Sort( delegate( int a, int b ) { nCmp++; return (a<b)?-1:((a>b)?1:0)); }

   System.Console.Writeline( "{0},{1}", n, nCmp );
}


// Perform measurement for a variety of sample sizes.
// It would be prudent to check multiple random samples of each size, but this is OK for a quick sanity check
for( int n = 0; n<1000; n++ )
   DoTest(n);

하는 것도 잊지도록 허용한 공간 복잡는 원인이 될 수도 있습에 대한 우려가 있는 경우 메모리가 제한된 리소스입니다.그래서 예를 들을 수 있습니다 누군가가 원하는 일정한 공간 알고리즘은 기본적으로 말하는 방법이 차지하는 공간으로는 알고리즘에 의존하지 않는 어떤 요인이 내부에 코드입니다.

때로는 복잡성에서 올 수 있는 얼마나 많은 시간이라는 것이,얼마나 자주 반복 실행 방법을 자주 할당되는 메모리,그리고은 다른 부분이 질문에 대답합니다.

마지막으로,O 위해 사용될 수 있는 최악의 경우,최고의 경우,그리고 상각는 경우가 일반적으로 그것이 최악의 경우에 사용하는 방법을 설명하는 나쁜 알고리즘이 될 수 있습니다.

어떤 종종 간과 예상 의 동작을 알고리즘이 있습니다. 변경되지 않 Big-O 의 알고리즘, 지만,그것은 관련 문의"조 최적화입니다...."

예상 문제의 알고리즘은 매우를 풀고 아래--어떻게 빠른 기대할 수 있습니다 당신의 알고리즘을 작품에서 데이터는 당신이 대부분을 참조하십시오.

예를 들어,당신은 값에 대한 검색 목록에서,그것은 오(n)지만,당신이 알고 있는 경우는 대부분의 목록은 당신이 볼 수있는 당신의 값 앞에,일반적인 문제의 알고리즘이 더 빠릅니다.

정말 그래야 합 설명할 수 있는 확률분포의"공간을 입력"(필요할 경우 목록을 정렬,얼마나 자주 하는 목록을 정렬할 것인가?얼마나 자주 그것은 완전히 반대?얼마나 자주 그것은 주로 정렬?) 그것은 항상 가능하다는 것을 알고 있지만,때때로 당신은 않습니다.

좋은 질문입니다!

면책 조항:이 대답을 들 허위진술이 보입니다.

당신이 사용하는 경우 O,당신은 당신에 대해 이야기 나쁜 경우(에 더 무엇을 의미하는 이상).또한,자본 세타에 대한 일반적인 경우와 큰 오메가에 대한 최고의 경우입니다.

이 사이트를 확인에 대한 사랑스러운 공식적인 정의 큰 O: https://xlinux.nist.gov/dads/HTML/bigOnotation.html

f(n)=O(g(n))있는 것을 의미한 긍정적인 상수 c k 는 0≤f(n)≤cg(n)에 대한 모든 n≥k.의 값 c k 에 고정되어야에 대해 기능을 f 야에 의존하지 않 n.

그래,그래서 지금 우리가 무엇을 의미하는"최고의 경우"및"최악의 경우에는"복잡?

이것은 아마도 가장 명확하게 표현을 통해 예입니다.예를 들어 우리가 사용하여 선형 검색 번호를 찾을 수 있에 정렬된 배열음 최악의 경우 은 우리가 결정하는 검색에 대한 마지막 요소 의 배열이 많은 단계가 있는 항목에서 배열입니다.이 최고의 케이스 것을 때 우리는 검색 첫째 요소 때문에 우리는 우리 것이라 후에 행해지 먼저 확인합니다.

모든 지점이 형용사-케이스의 복잡성은 우리가 찾고있는 방법으로 그래프로 표시하는 시간을 가상 프로그램을 실행하여 완성의 관점에서의 크기는 특정한 변수입니다.그러나 많은 알고리즘을 수 있다는 주장이 없는 하나의 시간에 대한 특정 크기의 입력이 있습니다.이 모순이와 함께 기본적인 요구 사항의 기능에 모든 입력이 있어야 더 이상 하나의 출력이 있습니다.그래서 우리는 우리와 함께 올 러 기능 설명하는 알고리즘의 복잡성이 있습니다.지금도 검색하는 배열의 크기 n 걸릴 수 있습니다 다양한 양의 시간에 따라 무엇을 찾고 있는 배열에 따라 비례 n,우리가 만들 수 있는 유익한 정보에 대한 설명 알고리즘을 사용하여 제일-케이스,평균 경우,그리고 최악의 경우 클래스입니다.

죄송이 너무 가난하게 작성 및 결 기술 정보를 얻을 수 있습니다.하지만 잘하면 시간을 만드는 복잡성을 클래스는 생각보다 훨씬 더 어렵습니다.당신은 편안한 이러가 간단한 문제의 분석을 통해 귀하의 프로그램을 찾고 같은 것들을 위해 루프에 의존하는 배열의 크기와 추론을 기반으로 데이터 구조에 어떤 종류의 입력에 발생할 것 사소한 경우와 어떤 입력하면 결과는 최악의 경우입니다.

지하는 방법을 알고 프로그래밍 방식으로 이 문제를 해결,하지만 먼저 사람들은 우리는 샘플링 알고리즘에 대한 특정 패턴 작업의 수행,말 4n^2+2n+1 우리가 2 규칙:

만약 우리가 합의 조건에,기간으로 가장 큰 증가율이 유지되고,다른 측면은 생략한다.
면 우리는 제품이 여러 가지 요인의 일정한 요인은 생략한다.

만약 우리를 단순화하 f(x),f(x)에 대한 수식의 숫자 작업을 수행,(4n^2+2n+1 위에서 설명),우리가 얻 big-O 값이[O(n^2)이 경우에].그러나 이것은 계정 Lagrange 보간법,프로그램에는 어려울 수 있을 구현할 수 있습니다.그리고 어떤 경우에는 실제 big-O 값 O(2^n)및 수 있습니다 우리는 뭔가가 다음과 같 O(x^n)그래서 이 알고리즘은 아마 없을 프로그래밍할 수 있습니다.그러나 만약 어떤 사람이 증명 나에게 잘못이 나에게 코드입니다....

코드는,외부 루프를 실행을 위해 n+1 번,'1'시간을 의미하는 프로세스를 검사할지 여부가 여전히 요구에 응합니다.및 내부 반복 실행 n 시간 n-2 에게 자비를 보여 주셨습니다.따라서,0+2+..+(n-2)+n= (0+n)(n+1)/2= O(n²).

코드 B 지만,내부 루프지 않을 것 단계에서 실행 foo(),내부 반복 실행됩니다 위한 시간에 따라 외부 반복 실행 시간은 오(n)

요 Big-O 에서 조금 다른 측면이다.

Big-O 은 비교하의 복잡성 프로그램을 의미하는 방법을 빠르고 있는 그들은 성장을 경우 입력이 증가지 정확한 시간을 보낼 수행합니다.

이럴 big-O 공식 당신은 더 나은 사용하지 않는 더 복잡한 방정식(할 수 있지만 그들은 다음 그래프.) 그러나 당신은 여전히 사용할 수 있는 다른 정확한 수식(3^n,n^3,...)하지만 그것보다 더 될 수 있는 때때로 오해의 소지가!그래서 더 나은 그것을 유지하는 가능한 한 간단합니다.

제가 강조하고 싶어 다시 한 번 여기에는 우리가 원하지 않을 얻을 정확한 수식의 알고리즘이 있습니다.우리는 단지 보여주고 싶은 어떻게 성장하면 입력은 성장 비교와 다른 알고리즘에서는 감각입니다.그렇지 않으면 당신은 더 나은 다른 방법을 사용하는 다음과 같 벤치 표시입니다.

라이센스 : CC-BY-SA ~와 함께 속성

제휴하지 않습니다 StackOverflow