무슨 일반 영어 설명의"O"표?

Question

내가 선호하는 것으로 작은 공식적인 정의 가능한 한 간단한 수학했다.

Answer 1

빠르고,이것은 거의 확실히 혼란 O 표기 (이 상)을타 표기"Θ"(는 두 개의 측에 바인딩).내 경험에 의하면,이것은 실제로의 전형적인 토론에서는 비 학술 설정합니다.숙박 시설에는 흡연 구역이 지정되어 혼란이 발생합니다.

---

O 복잡한 시각화 할 수 있습니다 이 그래프

가장 간단한 정의를 내가 줄 수 있는 대 Big-O 표기 this:

Big-O 표기법은 상대적 표현의 복잡도는 알고리즘이 있습니다.

거기에 몇 가지 중요하고 의도적으로 선택된 단어는 문장

• 상대: 만 비교할 수 있습니다비교할 수 없는 알고리즘을 곱셈 연산하는 알고리즘 종류의 목록을 정수입니다.하지만 비교하는 두 개의 알고리즘 연산을 수행하는 작업(하나의 곱셈이나 외에)당신에게 말할 것이 뭔가 의미심장;
• 표현: Big-O(에서는 가장 간단한 형태)감소 사이의 비교하는 알고리즘을 하나의 변수입니다.는 변수에 따라 선택 또는 관측 모델 예측제어 등을 다룬다.예를 들어,정렬 알고리즘은 일반적으로 비교 기반으로 비교 연산(비교하는 두 개의 노드를 결정하는 그들의 상대적인 순).이는 비교가 비싸다.하지만 어떤 경우에 비해 저렴하지만 교환하는 것은 비싸요?그것을 변경하는 비교;고
• 복잡: 는 경우 그것은 나에게 한 두 번째로 정렬하 10,000 요소를 얼마나 오래 걸릴 것입니 나를 정렬하는 하나의 만?복잡성이 인스턴스에서는 상대 측정하는 다른 뭔가가 있습니다.

다시 돌아와 다시 읽는 위 때 읽었습니다.

의 가장 좋은 예 Big-O 나의 생각할 수 있을 참조하시기 바랍니다.두 번호(123456 및 789012).기본적인 연산 우리는 학교에서 배운다:

• 외;
• 뺄셈;
• 곱하기고
• division.

이러한 각각의 작업 또는 문제입니다.의 방법 이라고 알고리즘.

또한 간단합니다.당신은 라인의 숫자는(오른쪽)및 추가 자리에서 열 글의 마지막 번호는 것 외에 결과입니다.는'수천만'부분의 숫자가 수행하는 다음의 열입니다.

가정하자는 이러한 숫자가 가장 비용이 많이 드는 작업에 이 알고리즘이 있습니다.그 이유는 추가 이러한 두 번호 함께 우리는 함께 추가 6 자리(및 수행 7).만약 우리가 두 개 추가 100 자리 숫자로 함께 우리가 해야 할 100 추가 사항입니다.면 우리는 추가 두 개의 10,000 자리의 숫자는 우리가 해야 할 10,000 추가 사항입니다.

패턴을 참조하십시오?이 복잡성 (되는 작업의 수)에 직접 비례하의 숫자의 번호 n 에서 더 큰 숫자입니다.우리는 이것을 O(n) 나 선형 복잡성.

빼기와 비슷(제외하고 필요할 수 있습을 빌려신의 캐).

곱셈은 다릅니다.당신은 라인의 숫자까지,첫번째 자리에서 바닥 수와 곱에서 그것을 차례에 대한 각각 자리에서 최고 번호를 통해 각각의 자리입니다.그래서를 곱 우리의 두 6 자리의 숫자는 우리가 해야 하는 36 곱셈.우리는 작업을 수행해야 할 수 있습으로 많은 10 11 열 추가 최종 결과를 얻기 위하여 너무입니다.

만약 우리가 두 100 자리 숫자 우리가 할 필요가 있는 10,000 개의 곱셈과 200 개 추가합니다.두 가지 중 하나 만 자리 숫자는 우리가 해야 할 일조(10¹²)곱지만은 추가한다.

으로 알고리즘이 n제곱, 이 O(n²) 나 이차 복잡성.이것은 좋은 시간을 소개하는 또 다른 중요한 개념:

우리는 케어에 대해 가장 중요한 부분은 복잡한 작업이 필요 없습니다.

켜줄 수 있습을 실현할 수 있는 익스프레스의 숫자 작업:n² +2n.하지만 본서의 예를 두 개의 숫자와 백만의 숫자가 각각 두 번째 학기(2n)가 미미(에 대한 회계 0.0002%의 총을 운영하여는 단계).

한한다는 것을 알 수 있습라고 생각했는 최악의 경우 시나리오를 여기에.는 곱하여 6 자리의 숫자는 경우 그들 중 하나는 4 자리 숫자와 다른 하나는 6 자리한 다음,우리는 24 곱셈.아직도 우리가 계산이 최악의 시나리오에 대한'n'i.e 때 모두 6 자리의 숫자입니다.따라서 Big-O 표기에 대한 최악의 시나리오 알고리즘의

전화 예약

다음에 생각할 수 있는 가장 좋은 예의는 전화로 예약,일반적으로 불리는 흰색 페이지 또는 이와 유사한 그러나 그것은 국가에 따라 달라질.그러나 나는 이야기에 대해 하나 나열하는 사람들에 의해 성과한 다음의 이니셜이나 이름,가능한 주소한 다음 전화 번호.

지금 당신이 지시하는 컴퓨터를 찾 전화 번호"에 대한 존 스미스에서"전화로 예약이 포함된 1,000,000 이름,당신은 무엇을 할 것인가?사실은 무시할 수 있는 방법을 생각까지 들의 시작(가정하자할 수 없습니다),당신은 무엇을 할 것인가?

일반적인 구현될 수 있을 열을 중간을 500,000^th 와 비교해"Smith".면 그것은"Smith,John",우리는 그냥 있어 실제 운이 좋다.훨씬 더 가능성이 높은"존 스미스는"것입하기 전에 또는 그 후에 이름입니다.는 경우 그 후에 우리는 다음을 나눈 후반의 전화 예약에서 반고 반복합니다.면 그것은 그 전에 우리는 나누 전반의 전화 예약에서 반고 반복합니다.그래서.

이 검색 사용되는 모든 일에서 프로그래밍 너는 그것을 실현하지 않습니다.

그래서 만약 당신을 찾으려면에 이름을 전화 번의 이름을 찾을 수 있습니다 실제로 모든 이름으로 이 일에 가장 20 시간.교에서 검색 알고리즘 우리가 결정하는 것이 비교가 우리의'n'.

• 전화 예약의 3 이름을 걸리는 2 비교(대부분에서).
• 7 이 걸리는 대부분 3.
• 15 걸 4.
• …
• 에 대한 1,000,000 20.

는 것은 믿기 어려울 정도 좋지 않나요?

Big-O 이 O(로그 n) 나 로그 복잡성.이제 로그에 문제를 해결할 수 있습 ln(base e),로그인₁₀, 로그인₂ 또는 다른 기초입니다.그것이 문제가되지 않 그것은 여전히 O(로그 n)처럼 O(2n²)and O(100n² 용)여전히 모두 O(n²).

그것은 가치 있는 이 시점에서 설명하는 빅 오를 결정하는 데 사용할 수 있습니다 세 가지 경우 알고리즘을 사용:

• 최고의 경우: 전화 예약 검색,최고의 경우는 우리가 이름을 발견 중 하나에서 비교입니다.이 O(1) 나 일정한 복잡성;
• 예상되는 경우: 위에서 설명한 대로 이 O(로그 n);고
• 최악의 경우: 이것은 또한 O(로그 n).

일반적으로 우리에 대해 걱정하지 않고 최고의 경우입니다.우리에 관심이 예상과는 최악의 경우입니다.때로는 하나 이상의 다른 것이 더 중요합니다.

다시 되었습니다.

는 무엇이 있는 경우는 전화번호와를 찾고 싶어 이름이 무엇입니까?경찰 역방향 전화 번지만 이러한 모습이 거부된 일반에게 공개되어 있습니다.또는 그들은?기술적으로 되돌릴 수 있습을 찾아에서 번호를 일반 전화 번호.방법?

당신은에서 시작 첫 번째 이름과 비교할 수 있습니다.는 경우 그것은 일치하지 않으면 좋은 당신이 다음에 이동.당신이해야 할 그것을 이렇기 때문에 전화 번호 정렬 (전화 번호로 어쨌든).

그래서를 찾는 주어진 이름 전화번호(역 lookup):

• 최고의 경우: O(1);
• 예상되는 경우: O(n)(500,000);고
• 최악의 경우: O(n)(에 대한 1,000,000).

여행는 세일즈맨

이것은 매우 유명한 문제에 컴퓨터 공학과 언급 가치가있.에서 이 문제가 있 N 습니다.각 사람들의 마을을 연결하는 1 또는 그 이상의 다른 도시에 의해 도로의 특정 거리입니다.여행 외판원 문제를 찾는 것이 가장 짧은 관광 방문하는 모든 도시입니다.

간단한 소리?다시 생각합니다.

이 있는 경우 3 도시 A,B 및 C 와 도로 사이의 모든 쌍 갈 수 있:

• A→B→C
• A→C→B
• B→C→
• B→→C
• C→→B
• C→B→

물론 실제로 거기보다는 것 때문에 이들 중 일부는 해당하는(A→B→C C→B→은 해당하는,예를 들어,사용하기 때문에 같은 도로,다만 역에서).

실제로 3 가능성이 있습니다.

• 이 4 개의 도시와 있(iirc)12 가능성이 있다.
• 5 그것은 60.
• 6 된 360.

이 기능의 수학 작동 불 factorial.기본적으로:

• 5! = 5 × 4 × 3 × 2 × 1 = 120
• 6! = 6 × 5 × 4 × 3 × 2 × 1 = 720
• 7! = 7 × 6 × 5 × 4 × 3 × 2 × 1 = 5040
• …
• 25! = 25 × 24 × … × 2 × 1 = 15,511,210,043,330,985,984,000,000
• …
• 50! = 50 × 49 × … × 2 × 1 = 3.04140932 × 10⁶⁴

그래서 Big-O 의 여행하는 외판원 문제입 O(n!) 나 계승 또는 복잡성을 조합.

을 얻을 시간을 200 도시가 없는 충분한 시간이 좌 우주에서 문제를 해결하기 위해 전통적인 컴퓨터입니다.

무언가를 생각합니다.

다항식 시간

또 다른 점 만들고 싶었 빠른 언급하는 알고리즘의 복잡성 O(n^a) 가 다항식 복잡성 나는 해결할 수 있에 다항식 시간.

O(n),O(n² 등)은 다항식 시간입니다.어떤 문제를 해결할 수 없을 다항식 시간입니다.특정 상황이 전 세계에서 사용하는 이 때문에. 공개키 암호화 은 예입니다.는 것은 계산 찾기 어려운 두 개의 주요 요인의 매우 큰 숫자가 있습니다.지 않은 경우,우리는 수 없 공개 키를 사용하여 시스템에 우리가 사용합니다.

어쨌든 그에 대한 내(희망 보통 영어)설명의 큰 O(개정).

Answer 2

알고리즘이 어떻게 스케일링되는지 보여줍니다.

에²): 로 알려진 2 차 복잡성

• 1 항목 : 1 초
• 10 개 항목 : 100 초
• 100 개 항목 : 10000 초

항목 수는 10 배 증가하지만 시간은 10 배 증가합니다.². 기본적으로 n = 10 및 o (n²) 우리에게 스케일링 계수 n을 제공합니다² 10입니다².

에): 로 알려진 선형 복잡성

• 1 항목 : 1 초
• 10 개 항목 : 10 초
• 100 항목 : 100 초

이번에는 항목 수가 10 배 증가하며 시간도 증가합니다. n = 10 및 so (n)의 스케일링 계수는 10입니다.

o (1): 로 알려진 일정한 복잡성

• 1 항목 : 1 초
• 10 개 항목 : 1 초
• 100 항목 : 1 초

항목의 수는 여전히 10 배 증가하지만 O (1)의 스케일링 계수는 항상 1입니다.

O (로그 N): 로 알려진 로그 복잡성

• 1 항목 : 1 초
• 10 개 항목 : 2 초
• 100 항목 : 3 초
• 1000 개 항목 : 4 초
• 100000 항목 : 5 초

계산 수는 입력 값의 로그에 의해서만 증가합니다. 따라서이 경우 각 계산이 1 초가 걸리면 입력 로그 n 따라서 필요한 시간입니다 log n.

그것은 그것의 요점입니다. 그들은 수학을 줄이고 정확히 n이 아닐 수도 있습니다.² 또는 그들이 말하는 것이 무엇이든, 그러나 그것은 스케일링의 지배적 인 요소가 될 것입니다.

Answer 3

Big-O 표기(또한"이라는 점근 성장은"표기)가 어떤 기능을"보면"당신이 무시한 일정한 요인 및 물건 근처 원산지.우리가 사용하는 그것에 대해 이야기하기 는 방법은 것은 규모.

---

기초

에 대한"충분히"큰 입력...

• f(x) ∈ O(upperbound) 수단 f "더 빠르다" upperbound
• f(x) ∈ Ɵ(justlikethis) 말 f "성장 정확하게 좋아요" justlikethis
• f(x) ∈ Ω(lowerbound) 수단 f "성장보다 느린" lowerbound

big-O 표기에 대한 관심하지 않는 일정한 요소:기능 9x² 이 말하는"성장 정확하게 좋아요" 10x².어느 쪽도 아니 big-O asymptotic 표기 관리 non-asymptotic 재료("콘텐츠 근처 원본"또는"무엇을 때 일어나는 문제 크기가 작은"):기능 10x² 이 말하는"성장 정확하게 좋아요" 10x² - x + 2.

왜 당신은 무시하고 싶은 더 작은 부분 방정식의?가 되기 때문에 완전히 작게 큰 부분 방정식으로 고려할 큰 비늘그들의 기여가 작게와 관련이 있습니다.(예를 참조하십시오 섹션입니다.)

다른 방법을 넣어,그것은 모든 비 으로 이동합니다. 를 분할하는 경우는 실제 데 걸리는 시간에 의해 O(...), 을 얻을 것이 일정한 요소에서 제한의 큰 입력이 있습니다. 직관적으로 이 의미가 있습니다:기능"scale"같은 다른 하나는 경우 를 곱할 수 있습니다 하나를 얻을 수니다.즉,우리가 말할 때...

actualAlgorithmTime(N) ∈ O(bound(N))
                                       e.g. "time to mergesort N elements 
                                             is O(N log(N))"

...즉 에 대한"큰"충분히 문제 크기 N (있다면 우리는 무시한 물건 근처 원산지),이 존재 일부는 일정(예:2.5,완전히 만)등는:

actualAlgorithmTime(N)                 e.g. "mergesort_duration(N)       "
────────────────────── < constant            ───────────────────── < 2.5 
       bound(N)                                    N log(N)         

많은 선택의 일;종종"최고의"선택으로 알려져 있는"일정 비율의"알고리즘...그러나 우리는 종종 무시하는것처럼 우리는 무시 비 최대의 조건(보는 일정한 요소에 대한 섹션이 왜 그들은하지 않는 일반적으로 물질).당신은 또한 생각할 수 있는 위의 방정식으로 바 말하고,"에서 최악의 시나리오는데 걸리는 시간은 결코 것보다 더 될 거 N*log(N), 내 2.5factor(일정한 요소에 우리는지)".

일반적으로, O(...) 가장 유용하기 때문에 우리는 종종 대한 최악의 경우에는 동작입니다.는 경우 f(x) 무언가를 나타내는"나쁜"같이 프로세서 메모리 사용량이 다음"f(x) ∈ O(upperbound)"의미"upperbound 는 최악의 시나리오 프로세서 메모리 사용량".

---

응용 프로그램

으로 순수한 수학적 구조,big-O 표기에 제한되지 않는 이야기에 대한 처리 시간과 메모리입니다.당신은 그것을 사용할 수 있습을 논의하 asymptotics 의 아무것도 스케일링이 의미와 같은:

• 수도 악수 중 N 사람들은 파티에서(Ɵ(N²), 특히, N(N-1)/2, 지만,중요한 것은 그것을"비늘 같은" N²)
• 확률론적 예상 수를 본 사람들의 몇 가지 바이러스 마케팅의 기능으로 시간
• 얼마나 웹사이트에 대기 시간에 맞 번호의 처리 장치에서는 CPU 또는 GPU 또는 컴퓨터 클러스터
• 어떻게 열 출력에서 확 CPU 사망의 기능으로 트랜지스터의 개수,전압,etc.
• 시간이 얼마나 알고리즘 실행 하는 데 필요한 기능으로의 입력 크기
• 공간이 얼마나 알고리즘 실행 하는 데 필요한 기능으로의 입력 크기

---

예

핸드셰이크를 들어,위의 방에있는 모든 사람을 흔들 모두가 다른 사람의 손입니다.에서 그 예를 들어, #handshakes ∈ Ɵ(N²).왜?

다시 조금:수 악수는 정확하게 n-을 선택-2 N*(N-1)/2 (각 N 는 사람들을 흔들의 손 N-1 다른 사람들이지만,이 두 번수 악수도 나눈 2):

그러나 매우 큰 숫자의 사람들,선형 단기 N 은 작게하고 효과적으로 기여하 0 를 비율(에서 차트:분수의자를 대각선을 통해 총 상자를 가져오는 작은 수로의 참가자들이 큰).따라서 행동은 스케일링 order N², 또는 수의 악수"처럼 성장 N2".

#handshakes(N)
────────────── ≈ 1/2
     N²

바로 그것은 빈 상가에서의 대각선 chart(N*(N-1)/2 체크)도 되지 않은 거기(N² 체크 점근).

(임시 여담에서"보통 영어":)는 경우 이를 증명하기 위해,자신에게 수행할 수 있습니다 몇 가지 간단한 대수학에 비율로 분할 여러 용어(lim 뜻은"간주에서의 제한을"그냥 무시하는 경우에 당신은 그것을 보지 않고,그것의 표기에 대한"N 정말 정말 큰"):

    N²/2 - N/2         (N²)/2   N/2         1/2
lim ────────── = lim ( ────── - ─── ) = lim ─── = 1/2
N→∞     N²       N→∞     N²     N²      N→∞  1
                               ┕━━━┙
             this is 0 in the limit of N→∞:
             graph it, or plug in a really large number for N

tl;박사:수 악수'처럼 보이는'x2 훨씬 큰 값에 대한 것,있다면 우리는 아래로 쓰 비율#악수/x2,는 사실 우리는 할 필요가 없 정확히 x2 악수도에서 소수 임의 큰니다.

예:x=1million,비#악수/x2:0.499999...

---

건물은 직관

이렇게 우리들에게 다음과 같은 문장...

"에 대한 충분히 큰 inputsize=N,상관없이 일정한 요소는 경우, 더블 입력 크기...

• ...나는 두번 O(N)("선형 시간")알고리즘을 걸립니다."

  N →(2N)=2(N)

• ...난중-squared(quadruple)시간 O(N2)("quadratic 간")알고리즘을 걸립니다." (예:문제 100x 로 큰 소 1002=10000x 로 긴...가능한 지속 가능)

  N2 →(2N)2=4(N2)

• ...나는 두 번 cubed(와 큰)시간 O(N3)("입방 시간")알고리즘을 걸립니다." (예:문제 100x 로 큰 소 1003=1000000x 로 긴...매우 지속 가능)

  cN3 →c(2N)3=8(cN3)

• ...추가 고정된 금액을 O(로그(N))("로그 시간")알고리즘을 걸립니다." (cheap!)

  c 로그(N) →로그 c(2N)=(c log(2))+(c 로그(N))=(수정액)+(c 로그(N))

• ...지 시간을 변경 O(1)("시간")알고리즘을 걸립니다." (가장 저렴한!)

  c*1 → c*1

• ...나"(기본적으로)두 시간"O(N 로그(N))알고리즘을 걸립니다." (공통)

  그것보다는 더 적은 O(N^1.000001는)할 수 있을 호출하는 기본적으로 선형

• ...나는 엄청나게 시간을 증가시킬 O(2^N)("지수는 시간")알고리즘을 걸립니다." (당신이블(또는 트리플,etc.) 시간 증가하여 문제가에 의해 하나의 단위)

  2^N → 2^2N = (4^N)............다른 방법을 넣어...... 2^N → 2^N+1 = 2^N2¹ = 2 2^N

[에 대한 수학적으로 경사할 수 있습 마우스 스포일러한 사소한 sidenotes]

(과 신용카 https://stackoverflow.com/a/487292/711085 )

(기술적으로 지속적인 요소는 수면 중에서 좀 더 많은 비전 예지만,나는 말로 표현되는 것을 이상(예를들면로그(N))등의하지 않는 것)

이들은 빵의 순서 성장하는 프로그래머와 적용되는 컴퓨터 과학자들이 사용하는 기준점으로.그들은 이러한 모든 시간입니다.(하는 동안 그래서 당신은 수 있는 기술적으로 생각하"두 배로 입력 O(√N)알고리즘 1.414 시간 느리게,"그것은 더 나은로 생각하는 것"이것은 더 이상 로그하지만 더 이상 선형".)

---

일정한 요인

일반적으로리 걱정하지 않는 어떤 특정한 일정한 요인이기 때문에,그들은 영향을 미치지 않는 방법 기능을 성장한다.예를 들어,두 개의 수 있습니다 알고리즘을 모두 취할 O(N) 시간을 완료,하지만 하나될 수 있 두 번 느린다.우리는 일반적으로 걱정하지 않는 너무 많이하지 않는 한 요인은 매우 큰,때문에 최적화하는 것은 까다로운 비즈니스( 때 최적화 조? );또한 단순한 행동을 선택하는 알고리즘으로 더 나은 big-O 성능을 향상시킬 orders of magnitude.

어떤 점근한 알고리즘(예:비교 O(N log(log(N))) sort)할 수 있습이 그렇게 큰 일정 비율(예: 100000*N log(log(N))),이나 오버헤드는 상대적으로 큰아 O(N log(log(N))) 숨겨진 + 100*N, 그들은 거의 가치를 사용하여도"big data".

---

왜 O(N)은 때때로 당신이 할 수 있는 최고 즉우리가 왜 필요한 데이터 구조체

O(N) 알고리즘은 어떤 의미에서"최고의"알고리즘이 필요하신 경우에는 읽기 당신의 모든 데이터입니다.이 매우 행동을 읽 의 무리는 데이터입니다 O(N) 작업입니다.로드 메모리로 일반적으로 O(N) (또는 더 빠른 경우 하드웨어를 지원하거나,모든 시간에 당신 이미 데이터를 읽).그러나를 터치하면도 보 에 모든 데이터의 조각(또는 모든 데이터의 다른 부분),알고리즘 취할 것입 O(N) 이것을 실행하는 시간을 찾고 있습니다.Nomatter 얼마나 실제의 알고리즘은,그것은 적어도 될 것입니다 O(N) 기 때문에 그것이 그 시간 동안 모든 데이터입니다.

같은 말을 할 수 있는 대 매우 글을 쓰는 행위.모두 알고리즘을 인쇄하는 것을 걸릴 것입니다 N 기 때문에,시간을 출력은 적어도는 긴(예:인쇄의 모든 순열(는 방법을 다시 정렬)세트의 N 재생의 카드는 요인: O(N!)).

이 동기를 부여하의 사용 데이터 구조:데이터 구조에 필요한 데이터를 읽는 한 번만(일반적으로 O(N) 시간),플러스 일부를 임의의 양 전처리(예: O(N) 나 O(N log(N)) 나 O(N²) 도)우리는 우리를 유지하려고 작습니다.그 이후,수정하는 데이터 구조(삽입/삭제/etc.) 고 만들기에 대한 쿼리 데이터를 매우 작은 시간,같은 O(1) 나 O(log(N)).당신이 다 만들의 큰 숫자를 쿼리!에서 일반적으로 더 많은 일을 할 기꺼이 하는 시간의 더 적은 작업해야 할 수도 있습니다.

예를 들어,당신이 말했 위도 경도 좌표의 수백만의 도로 세그먼트,그리고 발견하고 싶었 모든 스트리트입니다.

• 순진한 방법:만약 당신의 좌표를 교차로,그리고 원을 검토 근처의 거리,당신이 가야 할 것입을 통해 수백만 개의 세그먼트의 각 시간을 확인하며,각각에 대한 인접.
• 만약 당신이 작업을 수행하는 데 필요한 한 번,그것은 것이 문제가 되지 않을 할 순진한 방법 O(N) 일만 일단,하지만 당신이 원하는 경우 그것은 많은 시간이다(이 경우, N 시간에 대해 한 번의 각 세그먼트),우리가 해야 할지 O(N²) 작업,또는 10000002=1000000000000 작업입니다.좋지 않은(현대 컴퓨터를 수행할 수 있습에 대한 억 operations per second).
• 우리가 사용하는 경우 간단한 구조물이라고 해시 테이블(인스턴트속 조회 테이블도 알려져 있으로 hashmap 또는 사전에),우리는 작은 비용으로 사전 처리의 모든 것 O(N) 시간입니다.그 후,그것은 단지 일정 시간에서 평균을 통해 그것의 키(이 경우,우리의 핵심은 위도 경도 좌표 올림으로 격자;우리는 검색에 인접한 gridspaces 있는 9 는 일정).
• 우리의 작업은 가능 O(N²) 면 관리 O(N), 며,모두 우리가 했던 지불하는 작은 비용을 해쉬테이블에 추가한다.
• 비유:비유에서 이 특정한 경우 퍼즐:우리가 만든 데이터의 구조는 업적 일부 시설의 데이터입니다.만일 우리도 세그먼트는 다음과 같 퍼즐 조각,우리는 그룹들과 일치하여 컬러와 패턴이다.우리는 다음을 악용을 방지하고 추가 작업이상(비교하는 퍼즐 조각의 색상과 같은 각각 기타,하지 않는 모든 다른 하나의 퍼즐 조각).

똥 묻은 개가 겨 묻은 개를 이야기:데이터 구조할 수 있습속 작업입니다.더 많은 고급 데이터 구조를 할 수 있게,지연,또는 무시 작업에서 매우 영리한 방법이다.다른 문제는 다른 비유,하지만 그들은 모든 포함한을 구성하는 방법으로 데이터를 이용하는 일부 구조를 우리는 케어에 대해,또는 우리는 인위적으로에서 부과를 위한 회계.우리가 하는 일은 시간 앞서(기본적으로 계획 및 조직),그리고 지금 반복되는 작업을 훨씬 더 쉽습니다!

---

실제 예를 들어:시각화의 순서 성장하는 동안 코딩

Asymptotic 표기는,그 중심에,매우 별도의 프로그래밍입니다.Asymptotic 표기법의 수학적 위한 프레임워크에 대해 생각하고 어떻게 확장할 수 있습에서 사용되는 많은 다른 필드가 있습니다.는 말했다...이것은 어떻게 당신 적용 asymptotic 표기하여 코딩이다.

기본 사항:때마다 우리는 상호 작용으로 컬렉션에 있는 모든 요소의 크기는(이러한 배열로,설정,모든 키의 지도,etc.), 또는 반복의 반복,그 multiplcative 요소의 크기를 A.왜 말하는"배수 요소는"?--기 때문에 루프 및 기능(에 의해 거의 정의)가 승법영 시간:의 반복 횟수,시대에 일 루프(또는 위한 기능:는 횟수는 함수를 호출,배에서 수행 된 작업의 기능).(이 경우 우리는 아무 것도 하지 않는 멋진,같은 건너뛰기 루프나 루프가 종료 초,또는 변경 흐름 제어 기능에 따라 인수에 매우 일반적이다.) 여기에 몇 가지 예를 시각화의 기술과 함께 첨부된 의사 코드.

(여기서, xs 을 나타내는 일정한 시간 단위의 작품,프로세서를 지침,통역사 컴파일러,어떤)

for(i=0; i<A; i++)        // A * ...
    some O(1) operation     // 1

--> A*1 --> O(A) time

visualization:

|<------ A ------->|
1 2 3 4 5 x x ... x

other languages, multiplying orders of growth:
  javascript, O(A) time and space
    someListOfSizeA.map((x,i) => [x,i])               
  python, O(rows*cols) time and space
    [[r*c for c in range(cols)] for r in range(rows)]

예제 2:

for every x in listOfSizeA:   // A * (...
    some O(1) operation         // 1
    some O(B) operation         // B
    for every y in listOfSizeC: // C * (...
        some O(1) operation       // 1))

--> O(A*(1 + B + C))
    O(A*(B+C))        (1 is dwarfed)

visualization:

|<------ A ------->|
1 x x x x x x ... x

2 x x x x x x ... x ^
3 x x x x x x ... x |
4 x x x x x x ... x |
5 x x x x x x ... x B  <-- A*B
x x x x x x x ... x |
................... |
x x x x x x x ... x v

x x x x x x x ... x ^
x x x x x x x ... x |
x x x x x x x ... x |
x x x x x x x ... x C  <-- A*C
x x x x x x x ... x |
................... |
x x x x x x x ... x v

예 3:

function nSquaredFunction(n) {
    total = 0
    for i in 1..n:        // N *
        for j in 1..n:      // N *
            total += i*k      // 1
    return total
}
// O(n^2)

function nCubedFunction(a) {
    for i in 1..n:                // A *
        print(nSquaredFunction(a))  // A^2
}
// O(a^3)

만일 우리가 우리가 뭔가를 약간 복잡할 수 있습할 수 있는 상상을 시각적으로 무슨 일인:

for x in range(A):
    for y in range(1..x):
        simpleOperation(x*y)

x x x x x x x x x x |
x x x x x x x x x   |
x x x x x x x x     |
x x x x x x x       |
x x x x x x         |
x x x x x           |
x x x x             |
x x x               |
x x                 |
x___________________|

여기에,최소 인식할 수 있는 윤곽을 그릴 수 있습니다 중요한 것입;삼각형의 두 차원 형태(0.5^2)처럼,사각형의 두 차원 형태(^2);일정 요소의 두 여기에 남아 있 asymptotic 비율 사이에 두는,그러나 우리는 그것을 무시 모두 같은 요인...(거기에 어떤 불행한 뉘앙스를 이 기술은 내가 가지 않으로 여기;그것은 오해를 불러올 수 있습니다.)

물론 이것은 의미하지 않는 루프와 기능에 나쁜;반대로,그들은 이 빌딩 블록의 현대적 프로그래밍 언어,그리고 우리는 그들을 사랑합니다.그러나 우리가 볼 수 있는 방법으로 우리는 직조 루프 기능과 조건문에 우리가 함께 데이터(제어 흐름,etc.) 모방 시간과 공간 사용량의 우리의 프로그램!면 시간과 공간 사용이 문제가 되는 때 우리는 영리함을 찾는 것을 쉽게 알고리즘이나 데이터 구조는 우리가 생각하지 않을 줄이기 위해,순의 성장은 어떻게 든.그럼에도 불구하고,이 시각화 기법(지만 그들은 작동하지 않을 수)을 줄 수 있는 순서 추측하고 최악의 경우 실행 시간입니다.

여기에 다른 것은 우리를 인식할 수 있는 시각적으로:

<----------------------------- N ----------------------------->
x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
x x x x x x x x x x x x x x x x
x x x x x x x x
x x x x
x x
x

우리는 다시 정렬이 그것을 참조하십시오 O(N):

<----------------------------- N ----------------------------->
x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
x x x x x x x x x x x x x x x x|x x x x x x x x|x x x x|x x|x

또 어쩌면 당신은 로그(N)전달의 데이터에 대한 O(N*로그(N))총 시간:

   <----------------------------- N ----------------------------->
 ^  x x x x x x x x x x x x x x x x|x x x x x x x x x x x x x x x x
 |  x x x x x x x x|x x x x x x x x|x x x x x x x x|x x x x x x x x
lgN x x x x|x x x x|x x x x|x x x x|x x x x|x x x x|x x x x|x x x x
 |  x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x
 v  x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x

Unrelatedly 그러나 언급 할 가치가 또 다시:를 수행하는 경우 우리는 해시(예를들면사전/hashtable 조회),그의 요인 O(1).는 매우 빠르다.

[myDictionary.has(x) for x in listOfSizeA]
 \----- O(1) ------/    

--> A*1 --> O(A)

만일 우리가 우리가 뭔가 매우 복잡한 등과 재귀적 기능 또는 divide-and-conquer,알고리즘 사용할 수 있습니다 마스터 정리 (일반적으로 작동),또는에서 말도 안되는 경우 Akra-Bazzi 정리(거의 항상 일) 당신은 실행 시간의 당신의 알고리즘에 Wikipedia.

하지만,프로그래머가 생각하지 않는 다음과 같이기 때문에 결국,알고리즘을 직감이 자연스러워졌습니다.당신이 시작하는 코드가 뭔가 비효율적이,즉 생각에"나는 뭔가 남아서 비효율?".으면 대답은"예"그리고 당신은 그것을 예견 실제로 중요 xx 웅요,그 다음 당신이 취할 수 있는 단계 백 및 생각한 다양한 트릭의 것을 빠르게 실행(대답은 거의 항상"사용 hashtable"거의"사용"나무,그리고 아주 드물게 무언가를 조금 더 복잡합니다).

---

상각하고 평균 경우 복잡성

또한"의 개념으로 상각"및/또는"평균 경우에는"(주는 이들은 다릅니다).

평균 경우:이것은 더 이상 사용하여 big-O 표기 위해 예상되는 가치의 기능보다는 기능이다.일반적인 경우에 고려 모든 입력을 동등하게 할 가능성이 평균 경우에는 평균의 시간입니다.예를 들어 퀵도 최악의 경우 O(N^2) 에 대한 몇 가지 정말 나쁜 입력,평균 경우는 평소 O(N log(N)) (정말 나쁜 입력에서 아주 작은수,그래서 몇 가지 우리는 알 수 없는 그들의 평균 경우).

상각하고 최악의 경우:일부 데이터 구조할 수 있는 최악의 경우 복잡성은 크지만,는 것을 보장 할 경우 많은 이러한 작업의 평균 양 당신이 하는 일보다 더 좋을 것입니다 최악의 경우입니다.예를 들어 있을 수 있는 데이터 구조상적인 일정 O(1) 시간입니다.그러나 때때로 그것이'히컵'고 O(N) 시간 중 하나에 대한 임의의 작업하기 때문에 어쩌면 그것을 할 필요가 일부 부기 또는 가비지 컬렉션이나 뭔가를...그러나 그 약속을 하는 경우에는,고지 않을 것 히컵에 대해 다시 N 더 작업입니다.최악의 경우는 비용은 여전히 O(N) 당 작업,그러나 상각 비용 을 통해 많은 실행 가 O(N)/N = O(1) 당 작업입니다.기 때문에 큰 작업은 충분히 드문에,대량의 임시 작업으로 간주 될 수 있에 혼합하는의 나머지 부분과 작업으로 일정한 요소입니다.우리가 말하는 작업입니다"상각하고"충분히 큰 숫자를 호출하는 사라지 점근.

비유에 대한 청산한 분석:

당신은 자동차 드라이브.때때로,당신이 지출해야하는 10 분 거 주유소한 다음을 보내고 1 분을 보충 탱크가스입니다.았다면 이 모든 시간을 당신은 어디 갔다 자동차와(지출 10 분 운전하여 주유소,몇 초 동안 작성 의 일부분 갤런),그것은 매우 비효율적이다.하지만 경우에 당신을 채우기 탱크마다 몇 일,11 리 운전 주유소가"상각하고"충분히 큰 수정, 는 그것을 무시할 수 있습 척의 모든 당신의 여행이었다면 5%이상합니다.

사이 비교 평균트-케이스 및 상각하고 최악의 경우:

• 평균 경우:우리가 만드는 일부에 대해 가정을 우리의 입력즉는 경우 우리의 입력은 서로 다른 확률,그리고 우리의 출력/런타임이 있는 다른 확률(는 우리가 평균).일반적으로 우리는 우리의 입력은 모두 동일하게(유니폼 확률)지만,경우에는 실제 입력에 맞지 않으면 우리 가정의"평균 입력",평균 출력/런타임을 계산할 수 있습이 될 의미가 없습니다.할 것으로 예상되는 경우 임의의 균일하게 입력하지만,이에 대해 생각하는 것!
• 상각하고 최악의 경우:당신이 사용하여 상각하고 최악의 경우에 데이터 구조,성능을 보장합니다 내에서 상각하고 최악의 경우...결국(는 경우에도 입력을 선택해 악마의 모든 것을 알고있는 고려고 나사를 통해).일반적으로 우리는 이를 사용하여 분석하는 알고리즘이 될 수 있는 아주'고르'에서는 성능으로 예상치 못한 큰 딸꾹질지만,시간이 흐를 수행할 뿐만 아니라 다른 알고리즘이 있습니다.(그러나지 않는 한 당신의 데이터 구조에 대한 상한선을 훨씬 뛰어난 작품은 기꺼이에 지연,사악한 공격자는 아마도 당신에 잡아라의 최대 금액을 지연할 모든 작업하게 됩니다.

하지만,당신 합리적으로 걱정 에 대해 공격자는,다른 많은 알고리즘 공격에 대해 걱정할 외에 상각하고 평균 경우입니다.)

모두균-케이스 및 상각은 매우 유용한 도구에 대해 생각하고 설계와 스케일링에서 마음입니다.

(참조하십시오 차이 평균 케이스 및 상각 분석 에 관심이 있으면 이 하위.)

---

다차원 big-O

대부분의 사람들을 깨닫지 않는 하나 이상의 변수에서 작동합니다.예를 들어,문자열 검색 알고리즘,알고리즘의 시간이 걸릴 수 있습니다 O([length of text] + [length of query]), 즉그것은 선형에서 두 개의 변수 O(N+M).다른 많은 순진한 알고리즘의 수 O([length of text]*[length of query]) 나 O(N*M).을 무시하고 여러 변수 중 하나의 가장 일반적인 감독에는 알고리즘 분석 및 수 있는 핸디캡을 디자인할 때는 알고리즘이 있습니다.

---

전체 이야기

유지 하는 마음에 big-O 지 않습니다.할 수 있습 크게도 일부를 알고리즘을 사용하여 캐싱을 만들고,그들을 캐시 모른다는 피하고,병목 현상과 협력하여 RAM 대의 디스크를 사용하여 병렬화,또는 일 앞서간 이 기술은 종종 독 의 순서의 성장"big-O"표기법,하지만 당신은 자주 나오는 코어의 수를 big-O 표기의 병렬 알고리즘이 있습니다.

또한 염두에 두는 것 때문에 숨겨진의 제약을 당신의 프로그램,되지 않을 수도 있습은 정말 대 asymptotic behavior.작업할 수 있습니다 제한된 수의 값이,예를 들어:

• 만약 당신이 정렬 같은 것 5 소,당신은 당신을 사용하고 싶지 않은 빠른 O(N log(N)) 퀵;당신이 사용하려면 삽입 정렬하는 일을 잘 수행하기 위해 작은 입력이 있습니다.이러한 상황에 종종에서 오는 divide-and-conquer 알고리즘,어디로 분할하는 문제로 작아지고 서브 문제들,재귀 같은 정렬,fast Fourier 변환,행렬의 곱셈.
• 은 값이 있는 경우 효과적으로 묶여 일부로 인해 숨겨진 사실(예:인간의 평균 이름은 부드럽게 경계에서 아마 40 문자,그리고 인간의 나이는 부드럽게 경계에서 150).수도 있습을 부과하 범위에서 입력을 효과적으로 만들어 일정하다.

에서 연습,중에서도 알고리즘을 가지고있는 동일하거나 유사한 점근 성능,자신의 상대적 장점이 있습니다 실제로 구동할 수 있는 다른 것들,그러한다:다른 성능 요소(퀵 및 모두 mergesort O(N log(N)), 지만,퀵 활용 CPU 캐시);non-성과 고려 사항,같은 편의 구현;지 라이브러리를 사용할 수 있고,어떻게 믿을만하고 유지하고 라이브러리입니다.

프로그램을 실행됩니다 느린에 500MHz 컴퓨터 대 2GHz 컴퓨터입니다.우리가 정말 하지 않으로 이것을 고려 일부 자원의 경계하기 때문에,우리는 생각의 확장의 관점에서 기계 자원(예:클럭 주기당),하지 않는 진짜 두 번째입니다.그러나 비슷한 일들 수 있는'비밀'성능에 영향을 미치는지 여부와 같은에서 실행 에뮬레이션,또는지 여부를 컴파일러 최적화된 코드나지 않습니다.이러한 만들 수도 있습니다 몇 가지 기본적인 작업을 더 이상(도 상대적으로),또는 나의 일부 작업은 점근(도 상대적으로).효과될 수 있 작거나 큰 사이에 다른 구현 및/또는 환경입니다.당신은 언어를 전환하거나 기계를 견디는 작은 추가 작동하는가?에 따라 달라지는 백 다른 이유가(필요성,기술,동료,프로그래머의 생산성,금전적 가치의 당신의 시간,친숙,해결 방법,이유하지 어셈블리 또는 GPU,etc...),할 수 있는 것보다 더 중요 성능이다.

위의 문제는 다음과 같 프로그래밍 언어,은 거의 없으로 간주되는 부분의 지속적인 요인(도 그들은 한다);아직 하나 알고 있어야 하기 때문에,그들 때때로 (그래도 거의)그들은 영향을 미칠 수 있습 것들입니다.예를 들어에 cpython,기본 우선순위 큐 구현은 점근 비 최선(O(log(N)) 보 O(1) 당신의 선택에 대 한 삽입 또는 찾아 분);당신이 사용하는 다른 구현?아마 때문에,C 구현은 아마도 더 빨리,그리고 아마 다른 유사한 문제는 다른 곳에서.거기 장단점;때로는 그들은 중요하고 때때로 그들은하지 않습니다.

---

(편집:"일반"영어로 설명을 여기서 끝납니다.)

수학 부 칙

에 대한 완전성,정확한 정 big-O 표기법은 다음과 같습니다: f(x) ∈ O(g(x)) 는 것을 의미"f 은 점근 상단에 묶여 const*g":을 무시하고 모두 아래의 몇 가지 유한 x 의 값이 일정하는 |f(x)| ≤ const * |g(x)|.(다른 상징은 다음과 같습니다:처럼 O 수단≤, Ω 수단≥.이 있는 소문자로 변: o 수단 <고 ω 수단>.) f(x) ∈ Ɵ(g(x)) 모두 의미 f(x) ∈ O(g(x)) 고 f(x) ∈ Ω(g(x)) (상단과 하단에 의해 제한 g):가 존재하는 몇몇 상수 등의는 항상 거짓말에서"밴드"사 const1*g(x) 고 const2*g(x).그것은 가장 강한 점근 문을 만들 수 있고 거의 비슷하다 ==.(미안 해요,선출되는 지연의 언급이 절대값 상징은 지금까지에 명의 술;특히 때문에 나는 본 적이 없는 부정적인 값을 가지고 올에 컴퓨터 과학 context.)

사람들은 자주 사용 = O(...), 아마도 더 정확한 샘플-공상 과'표기와 완전히 합법적인 사용;"f=O(...)"는"읽 f 위해.../f xxx-에 묶여..."및으로 생각한다"f 은 어떤 식 그 asymptotics 은...".배웠을 사용하여 더 엄격한 ∈ O(...). ∈ "를 의미의 요소이다"(계속으로 읽기 전에). O(N²) 실제로 동 클래스, 즉,그것은 세트의 일을 우리가 고려하는 것이 동일합니다.이 특정한 경우, O(N²) 담 요소는 다음과 같{2 N², 3 N², 1/2 N², 2 N² + log(N), - N² + N^1.9,...}고 무한하게 크지만,그것은 여전히 설정합니다.이 = 표기법이 될 수 있는 더 일반적인 한도에서 사용되는 논문에 의해 세계적으로 유명한 컴퓨터 과학자.또한,그것은 종종 경우는 캐주얼에서 설정,사람들은 이렇게 말할 것입니다 O(...) 때 그들은 의미 Ɵ(...);이것은 기술적으로 진정한 이후 설정의 것 Ɵ(exactlyThis) 하위 집합의 O(noGreaterThanThis)...와의 유형입니다.;-)

Answer 4

편집 : 빠른 참고, 이것은 거의 확실하게 혼란 스럽습니다. 큰 o 표기법 (상한) Theta 표기법 (상부 및 하한)을 가진 (상한). 내 경험상 이것은 실제로 비 학술 환경에서 토론의 전형적인 것입니다. 혼란에 대한 사과.

한 문장으로 : 직업의 크기가 올라 가면서 완료하는 데 얼마나 오래 걸립니까?

분명히 그것은 "크기"를 입력과 "시간"으로 사용하는 것만으로 출력으로 사용됩니다. 메모리 사용법에 대해 이야기하려면 동일한 아이디어가 적용됩니다.

다음은 우리가 말리고 싶은 N 티셔츠가있는 예입니다. 잘 추정하다 건조 위치에 빠지는 것은 엄청나게 빠릅니다 (즉, 인간의 상호 작용은 무시할 수 있습니다). 물론 실생활에서는 그렇지 않습니다 ...

• 외부 세척 라인 사용 : 무한한 뒷마당이 있다고 가정하면, 세척은 O (1) 시간에 건조됩니다. 그러나 당신이 가지고 있으면, 그것은 같은 태양과 신선한 공기를 얻을 수 있으므로 크기가 건조 시간에 영향을 미치지 않습니다.

• 회전식 건조기 사용 : 각 하중에 10 개의 셔츠를 넣은 다음 한 시간 후에 완료됩니다. (여기서 실제 숫자를 무시하십시오 - 무의미합니다.) 그래서 50 개의 셔츠를 건조시킵니다. ~에 대한 10 셔츠 건조의 5 배.

• 방송 찬장에 모든 것을 넣으십시오 : 우리가 모든 것을 하나의 큰 더미에 넣고 일반적인 따뜻함을하도록한다면, 중간 셔츠가 마르려면 오랜 시간이 걸립니다. 나는 세부 사항을 추측하고 싶지 않지만, 이것이 적어도 O (n^2)라고 생각합니다. 세척 하중을 증가시킬 때 건조 시간이 더 빨리 증가합니다.

"Big O"표기법의 중요한 측면 중 하나는 그렇지 않습니다 주어진 크기에 대해 어떤 알고리즘이 더 빠를 지 말하십시오. 해시 가능 (문자열 키, 정수 값) 대 쌍의 배열 (문자열, 정수)을 가져갑니다. 문자열을 기반으로 해시 가능 또는 배열의 요소에서 키를 찾는 것이 더 빠릅니까? (즉, 배열의 경우, "문자열 파트가 주어진 키와 일치하는 첫 번째 요소를 찾습니다.") 해시 블라블은 일반적으로 상각되어 있습니다 (~ = "평균") O (1) - 일단 설정 한 후에는 사용해야합니다. 동시에 1,000,000 입학 테이블에서와 같이 100 입력 테이블에서 항목을 찾을 수 있습니다. 배열에서 요소를 찾는 것은 (색인이 아닌 콘텐츠를 기준으로) 선형입니다. 즉, O (n) - 평균적으로 항목의 절반을 살펴 봐야합니다.

이로 인해 조회 용 배열보다 해시 가능이 더 빨라 집니까? 반드시 그런 것은 아닙니다. 매우 작은 항목 모음이있는 경우 배열이 더 빠를 수 있습니다.보고있는 해시 코드를 계산하는 데 걸리는 시간 내에 모든 문자열을 확인할 수 있습니다. 그러나 데이터 세트가 커짐에 따라 해시 가능은 결국 배열을 이길 것입니다.

Answer 5

Big O는 입력이 커질 때 기능의 성장 동작, 예를 들어 프로그램의 런타임에 대한 상한을 설명합니다.

예 :

• O (n) : 입력 크기를 두 배로 늘리면 런타임이 두 배로

• 에²) : 입력 크기가 런타임으로 두 배가되는 경우

• O (로그 N) : 입력 크기가 두 배가되는 경우 런타임이 하나 증가합니다.

• o (2^N) : 입력 크기가 하나 증가하면 런타임이 두 배로

입력 크기는 일반적으로 입력을 나타내는 데 필요한 비트의 공간입니다.

Answer 6

Big O 표기법은 프로그래머가 입력 세트의 크기의 함수로 표현하기 위해 계산 (알고리즘)이 얼마나 오래 걸리는지에 대한 대략적인 측정 값으로 가장 일반적으로 사용됩니다.

Big O는 입력 수가 증가함에 따라 두 개의 알고리즘이 얼마나 잘 확대 될지 비교하는 데 유용합니다.

더 정확하게 큰 o 표기법 함수의 점근 적 거동을 표현하는 데 사용됩니다. 즉, 함수가 무한대에 접근함에 따라 작동 방식을 의미합니다.

많은 경우 알고리즘의 "O"는 다음 중 하나에 속합니다.

• o (1) - 완료 시간은 입력 세트의 크기에 관계없이 동일합니다. 예는 색인 별 배열 요소에 액세스하는 것입니다.
• O (로그 N) - 완료 시간은 Log2 (n)에 대략적으로 증가합니다. 예를 들어 Log2 (1024) = 10 및 log2 (32) = 5이므로 1024 항목은 32 개 항목의 대략 두 배가 걸립니다. 예제는 A에서 항목을 찾는 것입니다. 이진 검색 트리 (BST).
• 켜짐) - 완료 시간은 입력 세트의 크기로 선형으로 스케일링됩니다. 다시 말해 입력 세트의 항목 수를 두 배로 늘리면 알고리즘의 대략 두 배가 걸립니다. 예는 링크 된 목록의 항목 수를 계산하는 것입니다.
• o (n log n) - 완료 시간은 Log2 (n)의 결과의 횟수만큼 증가합니다. 이것의 예는입니다 힙 정렬 그리고 빠른 정렬.
• o (n^2) - 완료 시간은 항목 수의 제곱과 거의 같습니다. 이것의 예는입니다 버블 정렬.
• 켜짐!) - 완료 시간은 입력 세트의 계승입니다. 이것의 예는 여행 판매원 문제 Brute-Force 솔루션.

Big O는 입력 크기가 무한대로 증가함에 따라 함수의 성장 곡선에 의미있는 방식으로 기여하지 않는 요소를 무시합니다. 이는 함수에 추가되거나 곱하는 상수가 단순히 무시된다는 것을 의미합니다.

Answer 7

Big O는 내 코드를 실행하는 데 얼마나 많은 시간 / 공간이 필요한가? "라는 공통의 방식으로 자신을"표현 "하는 방법 일뿐입니다.

당신은 종종 o (n)을 볼 수 있습니다, o (n²), o (nlogn) 등,이 모든 것은 단지 보여주는 방법 일뿐입니다. 알고리즘은 어떻게 변경됩니까?

o (n)은 큰 O가 N이라는 것을 의미하며 이제 "N!"라고 생각할 수 있습니다. 글쎄 "n"은 요소의 양입니다. 배열에서 항목을 검색하려는 이미징. 각 요소를보고 "당신은 올바른 요소/항목입니까?" 최악의 경우, 항목은 마지막 색인에 있습니다. 즉, 목록에 항목이있는 것만 큼 많은 시간이 걸렸으므로 일반적인 것은 "오, 이봐, n은 공정한 가치가 주어진 가치가 있습니다!"라고 말합니다. .

그러면 당신은 "n²"그러나 더 구체적이지만, 당신은 단순하고, 분류 알고리즘의 단순하고, 가장 간단한 생각을 가지고 놀아주십시오. Bubblesort.이 알고리즘은 각 항목에 대해 전체 목록을 살펴 봐야합니다.

나의 목록

1. 1
2. 6
3. 3

여기의 흐름은 다음과 같습니다.

• 가장 큰 1과 6을 비교하십시오. OK 6은 올바른 위치에 있으며 앞으로 나아갑니다!
• 6과 3을 비교하십시오. 오, 3은 적습니다! 옮기자, 목록이 바뀌 었습니다. 우리는 지금 시작부터 시작해야합니다!

이것은 o n입니다² 목록의 모든 항목을 살펴 봐야하므로 "N"항목이 있습니다. 각 항목에 대해 모든 항목을 한 번 더 보면 비교하기 위해 "N"이기도하므로 모든 항목에 대해 "N"시간을 의미합니다. N*N = N을 의미합니다.²

나는 이것이 당신이 원하는만큼 단순하기를 바랍니다.

그러나 Big O는 시간과 공간의 방식으로 자신을 지출하는 방법 일뿐입니다.

Answer 8

Big O는 알고리즘의 기본 스케일링 특성을 설명합니다.

Big O가 주어진 알고리즘에 대해 말하지 않는 많은 정보가 있습니다. 그것은 뼈를 자르고 알고리즘의 스케일링 특성, 특히 "입력 크기"에 대한 응답으로 알고리즘의 리소스 사용 (생각 시간 또는 메모리)에 대한 정보 만 제공합니다.

증기 엔진과 로켓의 차이점을 고려하십시오. 그것들은 단지 같은 품종의 다른 종류 (예를 들어 프리우스 엔진 대 람보르기니 엔진) 일뿐 만 아니라 코어에서 극적으로 다른 종류의 추진 시스템입니다. 증기 엔진은 장난감 로켓보다 빠를 수 있지만 증기 피스톤 엔진은 궤도 발사 차량의 속도를 달성 할 수 없습니다. 이는 이러한 시스템이 주어진 속도 ( "입력 크기")에 도달하기 위해 필요한 연료의 관계 ( "자원 사용")와 관련하여 스케일링 특성이 다릅니다.

이것이 왜 그렇게 중요한가요? 소프트웨어는 최대 1 조의 요인별로 크기가 다를 수있는 문제를 다루기 때문입니다. 잠시 생각해보십시오. 달로 이동하는 데 필요한 속도와 인간 보행 속도 사이의 비율은 10,000 : 1 미만이며, 이는 입력 크기 소프트웨어의 범위에 비해 절대적으로 작습니다. 소프트웨어는 입력 크기의 천문 범위에 직면 할 수 있기 때문에 알고리즘의 복잡성이 큰 가능성이 있기 때문에 기본적인 스케일링 특성이며 구현 세부 사항을 능가하는 것이 기본적입니다.

표준 분류 예를 고려하십시오. 버블-소트는 O (n²) merge-sort는 O (n log n)입니다. 병합-소트를 사용하는 버블-스트와 애플리케이션 B를 사용하는 두 가지 정렬 응용 프로그램이 있다고 가정 해 봅시다. 약 30 개의 요소의 입력 크기에 대해서는 정렬시 응용 프로그램 B보다 1,000 배 빠른다 고 가정 해 봅시다. 30 개 이상의 요소를 정렬 할 필요가 없다면 이러한 입력 크기에서 훨씬 빠르기 때문에 응용 프로그램 A를 선호해야합니다. 그러나 천만 항목을 정렬해야한다는 것을 알게되면 응용 프로그램 B가 실제로 각 알고리즘이 스케일링하는 방식으로 인해이 경우 응용 프로그램 A보다 실제로 수천 배 더 빠릅니다.

Answer 9

다음은 Big-O의 일반적인 품종을 설명 할 때 사용하는 경향이 있습니다.

모든 경우에, 목록에서 더 높은 알고리즘을 목록에서 낮게 선호합니다. 그러나 더 비싼 복잡성 클래스로 이동하는 비용은 크게 다릅니다.

o (1) :

성장이 없습니다. 문제가 얼마나 큰지에 관계없이 같은 시간에 문제를 해결할 수 있습니다. 이것은 방송 범위 내에있는 사람들의 수에 관계없이 주어진 거리에서 방송하는 데 동일한 양의 에너지가 필요한 방송과 다소 유사합니다.

O (로그 N):

이 복잡성은 동일합니다 o (1) 조금 더 나쁘다는 점을 제외하고. 모든 실제 목적을 위해 이것을 매우 큰 일정한 스케일링으로 간주 할 수 있습니다. 1 천과 10 억 항목을 처리하는 작업의 차이는 6 계절 일뿐입니다.

영형(N):

문제 해결 비용은 문제의 크기에 비례합니다. 문제의 크기가 두 배가되면 솔루션 비용이 두 배가됩니다. 데이터 입력, 디스크 읽기 또는 네트워크 트래픽과 같이 대부분의 문제는 컴퓨터에 스캔해야하므로 일반적으로 저렴한 스케일링 요소입니다.

영형(N 통나무 N):

이 복잡성은 매우 유사합니다 영형(N). 모든 실제 목적을 위해 두 사람은 동일합니다. 이 수준의 복잡성은 일반적으로 여전히 확장 가능한 것으로 간주됩니다. 가정을 조정함으로써 영형(N 통나무 N) 알고리즘을 변환 할 수 있습니다 영형(N) 알고리즘. 예를 들어, 키 크기를 결합하면 정렬이 줄어 듭니다. 영형(N 통나무 N) 에게 영형(N).

영형(N²):

사각형으로 자랍니다 N 정사각형의 길이입니다. 이것은 네트워크의 모든 사람들이 네트워크의 다른 모든 사람들을 알 수있는 "네트워크 효과"와 동일한 성장률입니다. 성장은 비싸다. 대부분의 확장 가능한 솔루션은 상당한 체조를하지 않고도 이러한 수준의 복잡성을 가진 알고리즘을 사용할 수 없습니다. 이것은 일반적으로 다른 모든 다항식 복잡성에 적용됩니다. 영형(N^케이) - 또한.

o (2^N):

규모가 없습니다. 당신은 사소한 크기의 문제를 해결할 희망이 없습니다. 피해야 할 사항을 아는 데 유용하고 전문가가있는 대략적인 알고리즘을 찾는 데 유용합니다. 영형(N^케이).

Answer 10

Big O는 알고리즘이 입력 크기에 비해 얼마나 많은 시간/공간을 사용하는지 측정합니다.

알고리즘이 O (n) 인 경우 시간/공간이 입력과 동일한 속도로 증가합니다.

알고리즘이 O (n²) 그런 다음 입력 제곱 속도로 시간/공간이 증가합니다.

등등.

Answer 11

소프트웨어 프로그램의 속도를 측정하는 것은 매우 어렵고, 시도 할 때 답은 매우 복잡하고 예외와 특별한 경우로 채워질 수 있습니다. 우리가 두 가지 다른 프로그램을 서로 비교하여 "가장 빠른"것을 알아 내기 위해 두 가지 다른 프로그램을 비교하고 싶을 때 이러한 모든 예외와 특별한 경우는 산만하고 도움이되지 않기 때문에 이것은 큰 문제입니다.

이 모든 도움이되지 않는 복잡성의 결과로, 사람들은 가능한 가장 작고 가장 복잡한 (수학적) 표현을 사용하여 소프트웨어 프로그램의 속도를 설명하려고합니다. 이러한 표현은 매우 조잡한 근사치입니다. 운이 좋으면 소프트웨어가 빠르거나 느립니다.

그것들은 근사치이기 때문에, 우리는 표현에서 "o"(big oh)를 독자에게 심하게 단순화하고 있음을 알리는 협약으로 사용합니다. (그리고 아무도 표현이 어떤 식 으로든 정확하다고 잘못 생각하지 않도록하기 위해).

"OH"를 "순서대로"또는 "대략"의미로 읽으면 너무 잘못되지 않을 것입니다. (나는 Big-OH의 선택이 유머에 대한 시도 일 수 있다고 생각합니다).

이러한 "Big-OH"표현식이 시도한 유일한 것은 소프트웨어가 처리 해야하는 데이터의 양을 늘릴 때 소프트웨어가 얼마나 느려지는지 설명하는 것입니다. 처리 해야하는 데이터의 양을 두 배로 늘리면 소프트웨어가 작업을 완료하기 위해 두 배나 길어야합니까? 10 배 길이? 실제로, 당신이 만나고 걱정해야 할 매우 제한된 수의 큰 OH 표현이 있습니다.

좋은 :

• O(1) 끊임없는: 프로그램은 입력이 아무리 큰지에 관계없이 실행하는 데 동시에 시간이 걸립니다.
• O(log n) 로그: 입력 크기가 크게 증가하더라도 프로그램 런타임은 느리게 증가합니다.

나쁜 :

• O(n) 선의: 프로그램 런타임은 입력 크기에 비례하여 증가합니다.
• O(n^k) 다항식: - 처리 시간은 입력의 크기가 증가함에 따라 다항식 기능으로 더 빠르고 빠르게 증가합니다.

... 그리고 못생긴 :

• O(k^n) 지수 프로그램 런타임은 문제의 크기가 중간 정도 증가함에 따라 매우 빠르게 증가합니다. 지수 알고리즘으로 작은 데이터 세트를 처리하는 것은 실용적입니다.
• O(n!) 계승 프로그램 런타임은 가장 작고 가장 사소한 퇴행 데이터 세트 외에는 아무것도 기다릴 수있는 것보다 길어집니다.

Answer 12

Big O에 대한 평범한 영어 설명은 무엇입니까? 가능한 한 공식적인 정의가 거의없고 간단한 수학.

평범한 영어 설명 필요 Big-O 표기법 :

우리가 프로그램 할 때, 우리는 문제를 해결하려고 노력하고 있습니다. 코드를 알고리즘이라고합니다. 큰 O 표기법을 통해 알고리즘의 더 나쁜 사례 성능을 표준화 된 방식으로 비교할 수 있습니다. 하드웨어 사양은 시간이 지남에 따라 다양하며 하드웨어의 개선으로 인해 알고리즘이 실행되는 데 걸리는 시간이 줄어들 수 있습니다. 그러나 하드웨어를 교체한다고해서 알고리즘이 여전히 동일하기 때문에 알고리즘이 시간이 지남에 따라 더 좋거나 개선된다는 것을 의미하지는 않습니다. 따라서 다른 알고리즘을 비교할 수 있도록 더 나은 알고리즘이 더 나은지 여부를 결정하기 위해 큰 O 표기법을 사용합니다.

평범한 영어 설명 뭐 큰 o 표기법은 다음과 같습니다.

모든 알고리즘이 같은 시간에 실행되는 것은 아니며 입력의 항목 수에 따라 달라질 수 있습니다. N. 이를 기반으로, 우리는 더 나쁜 사례 분석 또는 런타임의 상한을 다음과 같이 고려합니다. N 점점 커지십시오. 우리는 무엇을 알고 있어야합니다 N 많은 큰 o 표기법이 그것을 참조하기 때문에입니다.

Answer 13

간단한 간단한 대답은 다음과 같습니다.

Big O는 해당 알고리즘의 최악의 시간/공간을 나타냅니다. 알고리즘은 해당 한계보다 더 많은 공간/시간을 절대로 사용하지 않습니다. Big O는 극단적 인 경우 시간/공간 복잡성을 나타냅니다.

Answer 14

좋아, 내 2cents.

Big-O, IS 인상 비율 프로그램에 의해 소비되는 리소스, WRT 문제 인스턴스 크기

자원 : 총 CPU 시간이 될 수 있으며 최대 RAM 공간이 될 수 있습니다. 기본적으로 CPU 시간을 나타냅니다.

문제는 "합계 찾기"라고 말하면서

int Sum(int*arr,int size){
      int sum=0;
      while(size-->0) 
         sum+=arr[size]; 

      return sum;
}

문제-인스턴스 = {5,10,15} ==> 문제-인스턴스 크기 = 3, 반복-루프 = 3

문제-인스턴스 = {5,10,15,20,25} ==> 문제-인스턴스 크기 = 5 반복-루프 = 5

크기 "n"의 입력을 위해 프로그램은 배열에서 "n"반복 속도로 성장하고 있습니다. 따라서 big-o는 n이 O (n)로 표현됩니다.

문제는 "조합 찾기"라고 말하면서

    void Combination(int*arr,int size)
    { int outer=size,inner=size;
      while(outer -->0) {
        inner=size;
        while(inner -->0)
          cout<<arr[outer]<<"-"<<arr[inner]<<endl;
      }
    }

문제-인스턴스 = {5,10,15} ==> 문제-인스턴스 크기 = 3, 총계 = 3*3 = 9

문제-인스턴스 = {5,10,15,20,25} ==> 문제-인스턴스 크기 = 5, 총계 = 5*5 = 25

크기 "n"의 입력을 위해 프로그램은 배열에서 "n*n"반복 속도로 성장하고 있습니다. 따라서 big-o는 n입니다² O (n²)

Answer 15

큰 O 표기법은 공간 또는 실행 시간 측면에서 알고리즘의 상한을 설명하는 방법입니다. n은 문제의 요소 수입니다 (즉, 배열의 크기, 트리의 노드 수 등) 우리는 N이 커질 때 달리기 시간을 설명하는 데 관심이 있습니다.

일부 알고리즘이 O (F (N))이라고 말할 때 해당 알고리즘에 의한 실행 시간 (또는 필요한 공간)은 항상 일정한 시간 F (N)보다 낮습니다.

이진 검색에 O (LOGN)의 실행 시간이 있다고 말하는 것은 로그 (N)를 곱할 수있는 상수 C가 존재한다고 말하는 것입니다. 이 경우 항상 로그 (N) 비교의 일정한 요인이 있습니다.

다시 말해서 g (n)가 알고리즘의 실행 시간 인 경우, 우리는 g (n) = o (f (n)) g (n) <= c*f (n) 될 때 n> k, 여기서 어디에 있다고 말합니다. C와 K는 상수입니다.

Answer 16

"Big O에 대한 평범한 영어 설명은 무엇입니까? 가능한 한 공식적인 정의가 거의없고 간단한 수학."

그런 아름답고 간단하고 짧은 질문은 학생이지도하는 동안받을 수있는 것처럼 똑같이 짧은 대답을받을 자격이있는 것 같습니다.

큰 o 표기법은 단순히 알고리즘이 입력 데이터의 양만**.

( *훌륭합니다. 단위가 없습니다 시간 감각!)
(** 사람들이 언제나 더 원해, 오늘 또는 내일 살든)

글쎄, 그게 큰 O 표기법에 대해 그렇게 멋진 것은 무엇입니까?

• 실제로 말하면, 큰 o 분석입니다 너무 유용하고 중요합니다 Big O는 알고리즘의 초점을 정사각 적으로 배치하기 때문입니다. 소유하다 복잡하고 완전히 무시합니다 JavaScript 엔진, CPU의 속도, 인터넷 연결 및 모델만큼 빠르게 구식이되는 모든 것들과 같은 비례 상수 일뿐입니다. 티. Big O는 현재 또는 미래에 사는 사람들에게 똑같이 중요한 방식으로 만 공연에 중점을 둡니다.

• Big O 표기법은 또한 컴퓨터 프로그래밍/엔지니어링의 가장 중요한 원칙에 직접 스포트라이트를 비추고 있습니다. 모든 훌륭한 프로그래머가 생각과 꿈을 꾸는 데 영감을주는 사실 : 느린 전진 기술을 넘어서 결과를 달성하는 유일한 방법은 다음과 같습니다. 더 나은 알고리즘을 발명하십시오.

Answer 17

알고리즘 예제 (Java) :

// given a list of integers L, and an integer K
public boolean simple_search(List<Integer> L, Integer K)
{
    // for each integer i in list L
    for (Integer i : L)
    {
        // if i is equal to K
        if (i == K)
        {
            return true;
        }
    }

    return false;
}

알고리즘 설명 :

• 이 알고리즘은 목록, 항목 별 항목, 키를 찾고있는 목록을 검색합니다.

• 목록의 각 항목을 반복하면 키라면 True를 반환합니다.

• 키를 찾지 않고 루프가 완료되면 False를 반환하십시오.

big-o 표기법은 복잡성 (시간, 공간, ..)의 상위 바운드를 나타냅니다.

시간의 복잡성을 찾기 위해 :

• 최악의 경우 시간을 계산하십시오 (입력 크기와 관련하여).

• 최악의 경우 : 키는 목록에 존재하지 않습니다.

• 시간 (최악의 경우) = 4N+1

• 시간 : o (4n+1) = o (n) | Big-O에서는 상수가 무시됩니다

• o (n) ~ 선형

Big-Omega도 있습니다.

• BEST-CASE : 키는 첫 번째 항목입니다.

• 시간 (최고 사례) = 4

• 시간 : ω (4) = O (1) ~ Instant Constant

Answer 18

큰 o

에프(x) = O (g(x)) X가 A로 이동하면 (예 : a = +∞) 함수가 있음을 의미합니다. 케이 그러한 :

1. 에프(x) = 케이(엑스)g(엑스)

2. k는 a의 일부 지역에 제한되어 있습니다 (a = +∞ 인 경우 숫자 n과 m이 있음을 의미합니다.케이(x) | <m).

다시 말해, 평범한 영어로 : 에프(x) = O (g(x)), x → a는 A의 동네에서 에프 제품으로 분해됩니다 g 그리고 일부 경계 기능.

작은 o

그건 그렇고, 여기에 작은 o의 정의를 비교하기위한 것이 있습니다.

에프(x) = O (g(x)) x로 이동할 때 다음과 같은 함수 k가 있음을 의미합니다.

1. 에프(x) = 케이(엑스)g(엑스)

2. 케이(x) x가 a로 이동하면 0으로갑니다.

예

• sin x = o (x) x → 0 일 때.

• sin x = o (1) x → +∞ 일 때,

• 엑스² + x = o (x) x → 0 일 때,

• 엑스² + x = o (x²) X → +∞ 일 때,

• ln (x) = o (x) = o (x) x → +∞ 일 때.

주목! 동일한 부호 "="가있는 표기법은 "가짜 평등"을 사용합니다. O (g (x)) = o (g (x))이지만 false a (g (x)) = o (g (엑스)). 마찬가지로, "ln (x) = o (x) x → +∞ 일 때"를 쓰는 것이 좋습니다. 그러나 공식 "o (x) = ln (x)"는 의미가 없습니다.

더 많은 예

• o (1) = o (n) = o (n²) N → +∞ (다른 방법으로는 그렇지 않으면 평등은 "가짜"),

• o (n) + o (n²) = O (n²) N → +∞ 일 때

• O (O (n²)) = O (n²) N → +∞ 일 때

• 에²)에³) = O (n⁵) N → +∞ 일 때

---

Wikipedia 기사는 다음과 같습니다. https://en.wikipedia.org/wiki/big_o_notation

Answer 19

Big O 표기법은 임의의 입력 매개 변수가 주어지면 알고리즘이 얼마나 빨리 실행되는지 설명하는 방법입니다. 다른 기계가 다른 속도로 작동하기 때문에 컴퓨터 과학에 유용하며, 단순히 알고리즘에 5 초가 걸린다 고 말하면 4.5GHz Octo-Core 프로세서가있는 시스템을 실행하는 동안 실행 중일 수 있기 때문에 많은 것을 알려주지 않습니다. 15 세의 800MHz 시스템으로 알고리즘에 관계없이 더 오래 걸릴 수 있습니다. 따라서 알고리즘이 시간 측면에서 얼마나 빨리 실행되는지 지정하는 대신 입력 매개 변수 수 또는 "N"측면에서 얼마나 빨리 실행되는지를 말합니다. 이러한 방식으로 알고리즘을 설명함으로써 컴퓨터 자체의 속도를 고려하지 않고도 알고리즘 속도를 비교할 수 있습니다.

Answer 20

내가 주제에 더 기여하고 있지만 여전히 공유 할 것이라고 생각했는지 확실하지 않습니다. 한 번 찾았습니다. 이 블로그 게시물 Big O에 대한 매우 도움이되는 (매우 기본적인) 설명 및 예제를 갖기 위해 :

예를 통해, 이것은 맨발의 기본 사항을 내 거북이 셀과 같은 두개골에 가져 오는 데 도움이되었으므로, 나는 당신이 올바른 방향으로 향하는 10 분 동안 읽는 꽤 강하라고 생각합니다.

Answer 21

당신은 큰 O에 대해 알아야 할 모든 것을 알고 싶습니까? 나도 그래.

그래서 큰 O에 대해 이야기하기 위해, 나는 그들 안에 한 번만 비트를 가진 단어를 사용할 것입니다. 단어 당 하나의 소리. 작은 단어가 빠릅니다. 당신은이 단어들을 알고 있으며 나도 그렇게합니다. 우리는 하나의 소리로 단어를 사용할 것입니다. 그들은 작다. 나는 당신이 우리가 사용할 모든 단어를 알게 될 것이라고 확신합니다!

이제, 당신과 내가 일에 대해 이야기합시다. 대부분의 경우, 나는 일을 좋아하지 않습니다. 당신은 일을 좋아합니까? 당신이하는 경우일지도 모르지만 나는 그렇지 않다고 확신합니다.

나는 일하러 가고 싶지 않다. 나는 직장에서 시간을 보내는 것을 좋아하지 않습니다. 내가 길을 가졌다면, 나는 그냥 놀고 재미있는 일을하고 싶습니다. 나와 같은 느낌이 듭니까?

이제 때때로 나는 일하러 가야합니다. 슬프지만 사실입니다. 그래서 일을 할 때는 규칙이 있습니다. 나는 일을 줄이려고 노력합니다. 내가 할 수있는 한 일이 거의 없다. 그럼 나는 놀다!

여기에 큰 뉴스가 있습니다. 큰 O는 제가 일을하지 않도록 도와 줄 수 있습니다! Big O. Less Work, 더 많은 플레이를 알고 있다면 더 많은 시간을 할 수 있습니다! 그것이 Big O가 저를 도와주는 일입니다.

이제 나는 일이 있습니다. 나는이 목록을 가지고있다 : 1, 2, 3, 4, 5, 6. 이 목록에 모든 것을 추가해야합니다.

와우, 나는 일이 싫다. 하지만 오 글쎄, 나는 이것을해야한다. 그래서 여기에 간다.

하나의 플러스 2는 3입니다.… 3 점은 6입니다 ... 4 명은 ... 모르겠습니다. 나는 길을 잃었다. 내 머릿속에서하는 것은 너무 어렵다. 나는 이런 종류의 일을별로 신경 쓰지 않습니다.

그러니 일을하지 말자. 당신과 내가 얼마나 힘든지 생각합시다. 6 개의 숫자를 추가하기 위해 얼마나 많은 일을해야합니까?

어디 한번 보자. 나는 하나와 2를 추가 한 다음 그것을 3에 추가 한 다음 4에 추가해야합니다. 대체로, 나는 6 개의 추가를 계산합니다. 이것을 해결하기 위해 6 개의 추가를해야합니다.

여기에 큰 o가 있습니다.이 수학이 얼마나 힘든지 알려줍니다.

Big O의 말 : 우리는 이것을 해결하기 위해 6 개의 추가를해야합니다. 하나는 1에서 6까지의 각각에 대해 추가합니다. 6 개의 작은 작품 ... 각 비트의 작업은 하나의 추가입니다.

글쎄, 나는 지금 그들을 추가하기 위해 일을하지 않을 것이다. 그러나 나는 그것이 얼마나 힘든지 알고 있습니다. 6 번의 추가가 될 것입니다.

아뇨, 이제 더 많은 일이 있습니다. theesh. 누가 이런 종류의 물건을 만드나요?!

이제 그들은 나에게 1에서 10까지 추가 해달라고 요청합니다! 내가 그런 짓을 왜 하겠어? 나는 1-6을 추가하고 싶지 않았습니다. 1에서 10까지 추가하기 위해… 음… 그것은 훨씬 더 어려울 것입니다!

얼마나 더 어려울까요? 얼마나 더 많은 일을해야합니까? 더 많은 단계가 필요합니까?

글쎄, 나는 10 첨가를해야 할 것 같다. .. 하나는 1에서 10까지 각각 하나를해야한다. 10은 6 개 이상입니다. 1 ~ 10 개보다 1에서 10까지 추가하기 위해 훨씬 더 많은 일을해야합니다!

나는 지금 바로 추가하고 싶지 않습니다. 나는 단지 그렇게 많이 추가하는 것이 얼마나 힘든지 생각하고 싶습니다. 그리고 가능한 한 빨리 놀기를 바랍니다.

1에서 6까지 추가하는 것은 약간의 작업입니다. 그러나 당신은 1에서 10까지 추가하는 것이 더 많은 일입니다.

Big O는 당신의 친구이자 나의 것입니다. Big O는 우리가 얼마나 많은 일을 해야하는지 생각하는 데 도움이되므로 계획 할 수 있습니다. 그리고 우리가 Big O와 친구라면, 그는 그렇게 어렵지 않은 일을 선택하도록 도울 수 있습니다!

이제 우리는 새로운 일을해야합니다. 안 돼. 나는이 일을 전혀 좋아하지 않는다.

새로운 작품은 다음과 같습니다. 모든 것을 하나에서 n으로 추가하십시오.

기다리다! N은 무엇입니까? 내가 그리워 했어? n이 무엇인지 말하지 않으면 어떻게 하나로 추가 할 수 있습니까?

글쎄, 나는 n이 무엇인지 모른다. 나는 말하지 않았다. 당신은? 아니? 오, 음. 그래서 우리는 일을 할 수 없습니다. 아휴.

그러나 지금 우리는 지금 일을하지 않을 것이지만, 우리가 n을 알고 있다면 그것이 얼마나 힘든지 추측 할 수 있습니다. 우리는 N을 추가해야 할 것입니다. 물론!

이제 여기에 큰 o가 있고, 그는이 일이 얼마나 힘든지 알려줄 것입니다. 그는 말한다 : 모든 것을 하나에서 n으로, 하나씩 추가하는 것은 O (n)입니다. 이 모든 것들을 추가하기 위해, [나는 n 시간을 추가해야한다는 것을 알고 있습니다.] [1] 그것은 큰 o입니다! 그는 어떤 유형의 일을하는 것이 얼마나 힘든지 알려줍니다.

나에게, 나는 큰 O를 크고 느리고, 보스 맨처럼 생각한다. 그는 일에 대해 생각하지만 그렇게하지는 않습니다. 그는 "그 일은 빠릅니다."라고 말할 수 있습니다. 또는 그는 "그 일이 너무 느리고 힘들다"고 말할 수도 있습니다. 그러나 그는 일을하지 않습니다. 그는 그 일을보고 시간이 얼마나 걸리는지 알려줍니다.

나는 Big O에 많은 관심을 가지고 있습니다. 왜? 나는 일하는 것을 좋아하지 않는다! 아무도 일하는 것을 좋아하지 않습니다. 그것이 우리 모두가 큰 O를 사랑하는 이유입니다! 그는 우리가 얼마나 빨리 일할 수 있는지 알려줍니다. 그는 우리가 얼마나 힘든 일인지 생각하도록 도와줍니다.

어, 더 많은 일. 이제 일을하지 말자. 그러나 단계별로 계획을 세우자.

그들은 우리에게 10 장의 카드를 주었다. 그것들은 모두 섞여 있습니다 : Seven, Four, 2, Six… 전혀 똑바로. 그리고 지금 ... 우리의 임무는 그들을 분류하는 것입니다.

에르. 그것은 많은 일처럼 들립니다!

이 데크를 어떻게 정렬 할 수 있습니까? 난 계획을 가지고있어.

나는 각 카드 한 쌍, 쌍으로, 데크를 통해, First에서 Last로 쌍을 보게 될 것입니다. 한 쌍의 첫 번째 카드가 크고 해당 쌍의 다음 카드가 작 으면 교체합니다. 그렇지 않으면, 나는 다음 쌍으로갑니다.

갑판이 완료되면 다음과 같이 묻습니다. 그 패스에서 카드를 교환 했습니까? 그렇다면, 나는 상단에서 다시 한 번 더해야합니다.

어느 시점에서, 어느 시점에서 스왑이 없을 것이며 우리의 데크는 끝날 것입니다. 너무 많은 일!

글쎄, 그 규칙과 함께 카드를 정렬하기 위해 얼마나 많은 일이 될까요?

나는 10 장의 카드가 있습니다. 그리고 대부분의 경우, 즉, 운이 많지 않은 경우, 데크를 통해 매번 최대 10 개의 카드 스왑을 사용하여 전체 데크를 최대 10 배까지 통과해야합니다.

큰 O, 도와주세요!

Big O가 들어오고 말합니다 : N 카드의 데크의 경우,이 방법을 정렬하려면 O (n Squared) 시간으로 수행됩니다.

그는 왜 n을 제곱한다고 말합니까?

글쎄, 당신은 n 제곱이 n 타임 n임을 알고 있습니다. 이제, 나는 그것을 얻는다 : N 카드는 데크를 통해 N 시간이 될 수있는 것까지 확인했다. 그것은 각각 n 단계가있는 두 개의 루프입니다. 그것은 n을 제곱 한 많은 작업입니다. 확실히 많은 일!

이제 Big O가 O (N Squared) 작업이 필요하다고 말하면 N은 코에 N 제곱이 추가 된 것을 의미하지는 않습니다. 어떤 경우에는 약간 적을 수 있습니다. 그러나 최악의 경우, 데크를 분류하기위한 N 제곱 단계 근처에있을 것입니다.

이제 Big O가 우리의 친구 인 곳이 있습니다.

Big O는 이것을 지적합니다. N이 커지면서 카드를 정렬 할 때 작업은 오래된 ADD-THESTHINGS 작업보다 훨씬 어려워집니다. 우리는 이것을 어떻게 알 수 있습니까?

글쎄, n이 정말 커지면, 우리는 N 또는 N 제곱에 추가 할 수있는 것을 신경 쓰지 않습니다.

큰 n의 경우, N 제곱은 n보다 더 큽니다.

Big O는 사물을 분류하는 것이 물건을 추가하는 것보다 어렵다고 말합니다. O (n Squared)는 큰 n의 경우 O (n)보다 많습니다. 즉, n이 크게 커지면 n 혼합 된 것들을 추가하는 것보다 더 많은 시간이 걸리면 더 많은 시간이 걸립니다.

Big O는 우리를 위해 일을 해결하지 않습니다. Big O는 작업이 얼마나 힘든지 알려줍니다.

카드 데크가 있습니다. 나는 그들을 분류했다. 당신은 도와주었습니다. 감사.

카드를 정렬하는 더 빠른 방법이 있습니까? Big O가 우리를 도울 수 있습니까?

예, 더 빠른 방법이 있습니다! 배우는 데 약간의 시간이 걸리지 만 효과가 있습니다 ... 매우 빠르게 작동합니다. 당신도 그것을 시도 할 수 있지만, 각 단계마다 시간을내어 장소를 잃지 마십시오.

데크를 정렬하는이 새로운 방법에서, 우리는 얼마 전에했던 방식으로 카드 쌍을 점검하지 않습니다. 이 데크를 정렬하는 새로운 규칙은 다음과 같습니다.

하나 : 나는 우리가 지금 일하는 데크 부분에서 하나의 카드를 선택합니다. 당신이 좋아한다면 나를 위해 하나를 선택할 수 있습니다. (우리가 처음으로,“우리가 지금 일하는 데크의 일부”는 물론 전체 데크입니다.)

둘째 : 나는 당신이 선택한 카드의 갑판을 펼칩니다. 이것이 바로 무엇입니까? 내가 어떻게 펼쳐 집니까? 글쎄, 나는 시작 카드에서 하나씩 가고, 나는 스플레이 카드보다 더 높은 카드를 찾습니다.

셋째 : 나는 끝 카드에서 가서 스플레이 카드보다 더 낮은 카드를 찾습니다.

이 두 카드를 찾은 후에는 교체하고 계속 교환 할 카드를 찾습니다. 즉, 나는 2 단계로 돌아가서 당신이 좀 더 선택한 카드를 펼친다.

어느 시점 에서이 루프 (2에서 3까지)가 끝납니다. 이 검색의 두 절반이 스플레이 카드에서 만나면 끝납니다. 그런 다음 1 단계에서 선택한 카드로 갑판을 펼쳤습니다. 이제 시작 근처의 모든 카드는 스플레이 카드보다 낮습니다. 그리고 끝 근처의 카드는 스플레이 카드보다 높습니다. 멋진 트릭!

Four (그리고 이것은 재미있는 부분입니다) : 나는 이제 두 개의 작은 데크를 가지고 있으며, 하나는 스플레이 카드보다 낮고, 하나는 더 높습니다. 이제 나는 각 작은 데크에서 1 단계로갑니다! 즉, 첫 번째 작은 데크에서 1 단계에서 시작하고 그 작업이 완료되면 다음 작은 데크에서 1 단계부터 시작합니다.

나는 갑판을 부분적으로 분해하고 각 부분을 더 작고 작게 정렬하며, 때로는 더 이상 할 일이 없습니다. 이제 이것은 모든 규칙에 따라 느리게 보일 수 있습니다. 그러나 나를 믿으십시오. 전혀 느리지 않습니다. 사물을 분류하는 첫 번째 방법보다 훨씬 적은 작업입니다!

이런 종류의 이름은 무엇입니까? 그것은 빠른 정렬이라고합니다! 그런 종류는 전화 한 사람에 의해 만들어졌습니다 자동차 호어 그리고 그는 그것을 빠른 종류라고 불렀습니다. 이제 빠른 정렬이 항상 사용됩니다!

빠른 정렬은 작은 데크를 작은 데크를 분해합니다. 즉, 작은 작업을 작은 작업으로 분류합니다.

흠. 거기에는 규칙이있을 수 있다고 생각합니다. 큰 작업을 작게 만들려면 헤어집니다.

이런 종류는 매우 빠릅니다. 얼마나 빨리? Big O는 우리에게 알려줍니다. 이런 종류의 경우 평균 경우에 수행 해야하는 O (N LOG N) 작업이 필요합니다.

첫 번째 종류보다 훨씬 빠르나요? 큰 O, 제발 도와주세요!

첫 번째 종류는 O (n Squared)였습니다. 그러나 빠른 정렬은 O (n log n)입니다. 당신은 n log n이 n보다 적다는 것을 알고 있습니다. 글쎄, 그것은 우리가 빠른 종류가 빠르다는 것을 아는 방법입니다!

데크를 정렬해야한다면 가장 좋은 방법은 무엇입니까? 글쎄, 당신은 당신이 원하는 것을 할 수 있지만, 나는 빠른 종류를 선택할 것입니다.

빠른 정렬을 선택하는 이유는 무엇입니까? 물론 일하는 것을 좋아하지 않습니다! 나는 그것을 끝내 자마자 일을하고 싶다.

빠른 정렬이 적은 작업이라는 것을 어떻게 알 수 있습니까? 나는 O (n log n)이 O (n Squared)보다 작다는 것을 알고 있습니다. O는 더 작기 때문에 빠른 정렬은 덜 작동합니다!

이제 당신은 내 친구 인 Big O를 알고 있습니다. 그는 우리가 덜 일을하도록 도와줍니다. 그리고 당신이 큰 O를 알고 있다면, 당신은 더 적은 일을 할 수 있습니다!

당신은 나와 함께 모든 것을 배웠습니다! 당신은 너무 똑똑합니다! 정말 고맙습니다!

이제 그 일이 끝났습니다.

---

1] : 한 번에 한 번에 모든 것을 속이고 추가하는 방법이 있습니다. Gauss라는 일부 아이는 8 살 때 이것을 발견했습니다. 그래도 나는 그렇게 똑똑하지 않습니다 그가 어떻게했는지 묻지 마십시오.

Answer 22

우리가 알고리즘에 대해 이야기하고 있다고 가정합니다 ㅏ, 크기의 데이터 세트로 무언가를해야합니다. N.

그 다음에 O( <some expression X involving n> ) 간단한 영어로 :

A를 실행할 때 운이 좋지 않으면 X (N) 작업이 완료 되려면 작동합니다.

발생하는 경우 특정 기능이 있습니다 ( 구현 의 x (n)) 그것은 자주 발생하는 경향이 있습니다. 이것들은 잘 알려져 있고 쉽게 비교됩니다 (예 : 1, Log N, N, N^2, N!, 등..)

이야기 할 때 이것들을 비교함으로써 ㅏ 다른 알고리즘은 작업 수에 따라 알고리즘을 쉽게 순위를 매기는 것이 쉽습니다. 5월 (최악의)는 완료해야합니다.

일반적으로 우리의 목표는 알고리즘을 찾거나 구조화하는 것입니다. ㅏ 함수가있는 방식으로 X(n) 그것은 가능한 한 낮은 숫자를 반환합니다.

Answer 23

시간 복잡성을 계산하기위한 가장 일반적인 메트릭을 이해하는 더 간단한 방법은 큰 표기법입니다. 이는 N이 무한대에 접근함에 따라 N과 관련하여 실행 시간을 추정 할 수 있도록 모든 일정한 요인을 제거합니다. 일반적으로 다음과 같이 생각할 수 있습니다.

statement;

일정합니다. 진술의 실행 시간은 n과 관련하여 변하지 않습니다.

for ( i = 0; i < N; i++ )
  statement;

선형입니다. 루프의 실행 시간은 N에 직접 비례합니다.

for ( i = 0; i < N; i++ ) 
{
for ( j = 0; j < N; j++ )
  statement;
}

2 차입니다. 두 루프의 실행 시간은 N의 제곱에 비례합니다. N의 복식이 2 배로 늘어나면 달리기 시간은 N * N만큼 증가합니다.

while ( low <= high ) 
{
 mid = ( low + high ) / 2;
 if ( target < list[mid] )
 high = mid - 1;
 else if ( target > list[mid] )
  low = mid + 1;
else break;
}

로그입니다. 알고리즘의 실행 시간은 N의 수에 비례하여 2로 나눌 수 있습니다. 이는 알고리즘이 각 반복 할 때 작업 영역을 반으로 나누기 때문입니다.

void quicksort ( int list[], int left, int right )
{
  int pivot = partition ( list, left, right );
  quicksort ( list, left, pivot - 1 );
  quicksort ( list, pivot + 1, right );
}

n * log (n)입니다. 실행 시간은 로그 인 N 루프 (반복 또는 재귀)로 구성되므로 알고리즘은 선형 및 로그의 조합입니다.

일반적으로 모든 항목으로 한 차원으로 무언가를하는 것은 선형이며, 2 차원으로 모든 항목으로 무언가를하는 것은 2 차이며, 작업 영역을 절반으로 나누는 것은 로그입니다. 입방, 지수 및 제곱근과 같은 다른 큰 O 측정이 있지만 거의 일반적이지 않습니다. 큰 o 표기법은 척도가 어디인 O ()로 설명됩니다. QuickSort 알고리즘은 O (n * log (n))로 설명됩니다.

참고 :이 중 어느 것도 최상의, 평균 및 최악의 측정을 고려하지 않았습니다. 각각은 고유 한 큰 O 표기법을 가지고 있습니다. 또한 이것은 매우 단순한 설명입니다. Big O가 가장 일반적이지만 내가 보여준 것보다 더 복잡합니다. Big Omega, Little O 및 Big Theta와 같은 다른 표기법도 있습니다. 아마도 알고리즘 분석 과정 밖에서는 그것들을 만나지 않을 것입니다.

• 자세히보기 : 여기

Answer 24

아마존에서 Harry Potter : 8-Film Collection [Blu-ray]을 주문하고 동시에 동일한 영화 컬렉션을 온라인으로 다운로드한다고 가정 해보십시오. 어떤 방법이 더 빠른지 테스트하려고합니다. 배달은 거의 하루가 걸리고 다운로드는 약 30 분 전에 완료되었습니다. 엄청난! 그래서 그것은 빡빡한 경주입니다.

반지의 제왕, 황혼, 다크 나이트 3 부작 등과 같은 여러 블루 레이 영화를 주문하고 동시에 온라인으로 모든 영화를 다운로드한다면 어떨까요? 이번에는 배송이 여전히 완료하는 데 하루가 걸리지 만 온라인 다운로드는 끝나는 데 3 일이 걸립니다. 온라인 쇼핑의 경우 구매 품목 (입력) 수는 배송 시간에 영향을 미치지 않습니다. 출력은 일정합니다. 우리는 이것을 부릅니다 o (1).

온라인 다운로드의 경우 다운로드 시간은 영화 파일 크기 (입력)에 직접 비례합니다. 우리는 이것을 부릅니다 에).

실험에서 온라인 쇼핑은 온라인 다운로드보다 더 나은 것을 알고 있습니다. 큰 O 표기법을 이해하는 것이 매우 중요합니다. 확장 성 그리고 능률 알고리즘의.

메모: 큰 o 표기법을 나타냅니다 최악의 시나리오 알고리즘의. 그것을 가정합시다 o (1) 그리고 에) 위의 예제의 최악의 시나리오입니다.

참조 : http://carlcheo.com/compsci

Answer 25

머리에 무한대의 적절한 개념이 있다면 매우 간단한 설명이 있습니다.

큰 O 표기법은 무한히 큰 문제를 해결하는 데 드는 비용을 알려줍니다.

또한

일정한 요인은 무시할 수 있습니다

알고리즘을 두 번 빠르게 실행할 수있는 컴퓨터로 업그레이드하면 큰 O 표기법에는 알 수 없습니다. 일정한 요인 개선이 너무 작아서 큰 O 표기법이 작동하는 규모로 알 수 없습니다. 이것은 큰 O 표기법 디자인의 의도적 인 부분입니다.

그러나 일정한 요인보다 "더 큰"것은 감지 될 수 있지만.

크기가 대략 무한대로 간주 될 정도로 "크기가 큰"계산에 관심이있는 경우, 큰 O 표기법은 대략 문제를 해결하는 데 드는 비용입니다.

---

위의 말이 이해되지 않는다면, 당신은 당신의 머리에 무한대의 직관적 인 개념이 없으며, 위의 모든 것을 무시해야 할 것입니다. 이러한 아이디어를 엄격하게 만들거나 아직 직관적으로 유용하지 않은 경우 설명하는 유일한 방법은 먼저 큰 O 표기법이나 비슷한 것을 가르치는 것입니다. (미래에 큰 O 표기법을 잘 이해하면 이러한 아이디어를 다시 방문하는 것이 가치가있을 수 있습니다).

Answer 26

"Big O"표기법에 대한 일반 영어 설명은 무엇입니까?

매우 빠른 참고 :

"Big O"의 O는 "Order"(또는 정확히 "Order of")라고합니다.
따라서 문자 그대로 비교하기 위해 무언가를 주문하는 데 사용된다는 생각을 얻을 수 있습니다.

• "큰 O"는 두 가지를 수행합니다.

  1. 컴퓨터가 작업을 수행하기 위해 적용되는 방법의 몇 단계를 추정합니다.
  2. 그것이 좋은지 아닌지를 결정하기 위해 다른 사람들과 비교할 수있는 과정을 용이하게합니까?
  3. "Big O '는 표준화 된 위의 두 가지를 달성합니다. Notations.

• 가장 많이 사용되는 7 가지 표기법이 있습니다

  1. o (1), 컴퓨터가 작업을 수행하는 것을 의미합니다. 1 단계적으로, 그것은 우수하고, 주문한 No.1입니다
  2. o (logn), 컴퓨터가 작업을 완료한다는 것을 의미합니다. logN 단계, 좋은, 주문 No.2
  3. o (n), 작업을 완료하십시오 N 단계, 공정, 주문 번호 3
  4. o (nlogn)는 작업을 종료합니다 O(NlogN) 단계는 좋지 않습니다. 주문 번호 4
  5. o (n^2), 작업을 완료하십시오. N^2 단계, 나쁘다, 주문 번호 5
  6. o (2^n), 작업을 완료하십시오. 2^N 단계, 그것은 끔찍합니다, 주문 번호 6
  7. o (n!), 작업을 완료하십시오. N! 단계, 그것은 끔찍합니다. 주문 번호 7

표기법이 있다고 가정 해 봅시다 O(N^2), 당신은 방법이 작업을 수행하기 위해 n*n 단계를 취하는 것을 분명히 할뿐만 아니라, 당신은 그것이 좋지 않다는 것을 알 수 있습니다. O(NlogN) 순위에서.

더 나은 이해를 위해서는 라인 끝에서의 순서를 확인하십시오. 모든 가능성이 고려 된 경우 7 개 이상의 표기법이 있습니다.

CS에서 작업을 수행하기위한 일련의 단계를 알고리즘이라고합니다.
용어에서 큰 O 표기법은 알고리즘의 성능 또는 복잡성을 설명하는 데 사용됩니다.

또한 Big O는 최악의 사례를 설정하거나 상체 단계를 측정합니다.
최선의 경우 Big-ω (Big-Omega)를 참조 할 수 있습니다.

Big-ω (Big-Omega) 표기법 (기사) | 칸 아카데미

• 요약
  "Big O"는 알고리즘의 성능을 설명하고이를 평가합니다.

  또는 공식적으로 주소를 지정합니다. "Big O"는 알고리즘을 분류하고 비교 프로세스를 표준화합니다.

Answer 27

그것을 보는 가장 간단한 방법 (일반 영어로)

입력 매개 변수 수가 알고리즘의 실행 시간에 어떤 영향을 미치는지 확인하려고합니다. 응용 프로그램의 실행 시간이 입력 매개 변수 수에 비례하는 경우 N의 큰 O에 있다고합니다.

위의 진술은 좋은 시작이지만 완전히 사실은 아닙니다.

더 정확한 설명 (수학적)

가정하다

n = 입력 매개 변수 수

t (n) = 알고리즘의 실행 시간을 n의 함수로 표현하는 실제 함수

C = 상수

f (n) = 알고리즘의 실행 시간을 n의 함수로 표현하는 대략적인 함수

그런 다음 큰 O에 관한 한, 근사 F (n)은 아래 조건이 사실 인 한 충분히 좋은 것으로 간주됩니다.

lim     T(n) ≤ c×f(n)
n→∞

N이 N의 무한대에 접근함에 따라 방정식은 N의 C 시간 F보다 작거나 동일합니다.

큰 o 표기법에서 이것은 다음과 같이 작성됩니다

T(n)∈O(n)

이것은 n의 t가 n의 큰 o에있는 것처럼 읽습니다.

영어로 돌아갑니다

위의 수학적 정의를 기반으로 알고리즘이 큰 O라고 말하면 N (입력 매개 변수 수)의 함수임을 의미합니다. 또는 더 빨리. 알고리즘이 N의 큰 O 인 경우 자동으로 N Square의 큰 O입니다.

큰 O는 내 알고리즘이 최소한이만큼 빠르게 실행된다는 것을 의미합니다. 알고리즘의 큰 O 표기법을보고 느리게 말할 수 없습니다. 당신은 단지 빠르게 말할 수 있습니다.

확인하다 이것 UC Berkley의 Big O에 대한 비디오 자습서를 위해. 실제로 간단한 개념입니다. Shewchuck 교수 (일명 God Level Teacher)가 설명하는 것을 들으면 "아, 그게 다야!"라고 말할 것입니다.

Answer 28

내가 발견한 정말 위대한 설명에 대해 큰 O 표기 특히 누구의 많지 않으로 수학했다.

https://rob-bell.net/2009/06/a-beginners-guide-to-big-o-notation/

O 표기를 사용하는 컴퓨터 과학에서 설명하는 성능 나 복잡성의 알고리즘이 있습니다.O 특별히 설명합니다 최악의 경우,그리고 설명하는 데 사용할 수 있는 실행 시간 필요하거나 사용하는 공간(예:메모리 또는 디스크)의 알고리즘이 있습니다.

누구나 읽고 프로그래밍 진주 또는 다른 컴퓨터 과학 책과하지 않는 접지 수학에서 있을 것이다 벽에 부딪 도착했을 때는 언급 O(N 로그 N)또는 다른 겉보기 미친 구문입니다.이 문서에서 당신을 도움이 될 것입 얻 기본 지식을 이해하의 빅 오 및 대수.

프로그래머로 첫 번째와 수학자 초(또는 어쩌면 세 번째 또는 네)내가 발견한 가장 좋은 방법을 이해하는 빅 오 철저하게 되었을 일부 생산의 예에서는 코드입니다.그래서,다음과 같은 몇 가지 일반적인 주문 성장과 함께 설명과 예제가 가능합니다.

O(1)

O(1)에 대해 설명합하는 알고리즘은 항상에서 실행할 동일한 시간 (나)공간의 크기에 관계없이 입력된 데이터를 설정합니다.

bool IsFirstElementNull(IList<string> elements) {
    return elements[0] == null; } O(N)

O(N)

O(N)설명하는 알고리즘의 성능 성장할 것입니다 선형 및 에 직접 비례하는 크기의 입력 데이터를 설정합니다.예제 또한 아래 방법을 보여줍 O 호의 최악의 경우 성능 시나리오;일치하는 문자열을 발견될 수 있는 동안 어떤 반복의 루와 기능을 이용하면 초기에 반환하지만,큰 O 표기됩 항 위한 알고리즘 수행합니다 의 최대 수를 반복 합니다.

bool ContainsValue(IList<string> elements, string value) {
    foreach (var element in elements)
    {
        if (element == value) return true;
    }

    return false;
} 

O(N²)

O(N²)을 나타내는 알고리즘의 성능을 직접 에 비례하는 사각형의 크기의 입력 데이터를 설정합니다.이 일반적으로 알고리즘을 포함하는 중첩된 반복을 통해 데이터 설정합니다.깊은 중첩된 반복 발생 O(N³),O(N⁴ 등)

bool ContainsDuplicates(IList<string> elements) {
    for (var outer = 0; outer < elements.Count; outer++)
    {
        for (var inner = 0; inner < elements.Count; inner++)
        {
            // Don't compare with self
            if (outer == inner) continue;

            if (elements[outer] == elements[inner]) return true;
        }
    }

    return false;
}

O(2^N)

O(2^N)을 나타내는 알고리즘의 성장과 복식 각 additon 하기 입력 데이터를 설정합니다.성장 곡선의 O(2^N)기능 급 시작은 매우 얕은 다음 상승 meteorically.인 의 예 O(2^N)함수를 재귀 피보나치 계산 숫자:

int Fibonacci(int number) {
    if (number <= 1) return number;

    return Fibonacci(number - 2) + Fibonacci(number - 1);
}

대수

로그는 약간 까을 설명한 그래서 사용 예제:

바이너리로 검색하는 기술을 사용하여 검색로 정렬 데이터를 설정합니다.그것은 작품 을 선택하여 중소 데이터의 설정,기본적으로 평균과 비교하여 그에 대한 대상 값입니다.값이 일치하면 그것은 는 성공을 반환합니다.는 경우 목표 값보다 더 높은 값의 프로브 요소이 걸릴 것이 상반신 데이터의 설정과 동일한 작업을 수행합니다.마찬가지로 대상 값 보다 낮은 값의 프로브 요소를 수행합니다 작업에 대한 낮은 절반이다.그것은 것을 절반으로 줄이는 데이터 설정으로 각 반복될 때까지 가치가 발견되었을 때까지 할 수 더 이상 쪼개는 데이터를 설정합니다.

이 알고리즘의 유형으로 설명되 O(로그 N).반복적인 절반으로 데이터 세트의 설명에서 검색를 들어 생산하고 성장 곡선 봉우리고 천천히 평평으로 크기 의 데이터 세트를 예를 들어 증가입력 데이터가 포함된 세트 10 항목 중 하나를 번째를 완료하는,데이터가 포함된 세트 100 항목이 걸립 두 초과 데이터가 포함된 세트 1000 항목은 세 초입니다.배 크기의 입력 데이터를 설정하는 작은 효과 그것의 성장으로 번 반복 알고리즘의 데이터 설정 될 것입 절반으로하고 따라서 동등으로 입력된 데이터로 설정 절반 크기입니다.이 알고리즘 처럼 매우 효율적인 검색 다룰 때 큰 데이터를 설정합니다.

Answer 29

이것은 매우 단순화 된 설명이지만 가장 중요한 세부 사항을 다루기를 바랍니다.

문제를 다루는 알고리즘이 일부 '요인'에 달려 있다고 가정 해 봅시다. 예를 들어 N과 X를 만들어 보자.

N과 X에 따라 알고리즘은 일부 작업이 필요합니다. 예를 들어 최악의 경우에는 3(N^2) + log(X) 운영.

Big-O는 상수 요인 (일명 3)에 너무 신경 쓰지 않기 때문에 알고리즘의 Big-O는 다음과 같습니다. O(N^2 + log(X)). 기본적으로 '최악의 경우 척도에 대한 알고리즘이 필요한 작업량'을 번역합니다.

Answer 30

머리말

연산: 문제 해결을위한 절차/공식

---

알고리즘을 어떻게 분석하고 알고리즘을 서로 비교할 수 있습니까?

예시: 당신과 친구는 0에서 N에서 N까지의 숫자를 합산하는 함수를 만들도록 요청받습니다. 당신은 f (x)를 생각해 내고 친구는 g (x)를 생각합니다. 두 기능 모두 동일한 결과를 가지지 만 다른 알고리즘이 있습니다. 우리가 사용하는 알고리즘의 효율성을 객관적으로 비교하기 위해 BIG-O 표기법.

BIG-O 표기법 : 설명합니다 입력이 임의로 커짐에 따라 입력에 비해 런타임이 얼마나 빨리 증가 할 것인가.

3 주요 테이크 아웃 :

1. 비교하다 런타임이 얼마나 빨리 증가하는지 아니다 정확한 런타임을 비교하십시오 (하드웨어에 따라 다름)
2. 런타임에만 관심이있는 것은 입력에 비해 증가합니다 (N)
3. 처럼 N 임의로 커지면 N이 커지면 가장 빠르게 성장할 용어에 중점을 둡니다 (무한대) 일명 점근 분석

공간 복잡성 : 시간 복잡성 외에도 공간 복잡성 (알고리즘이 사용하는 메모리/공간의 양)에도 관심이 있습니다. 작업 시간을 확인하는 대신 메모리 할당 크기를 확인합니다.