Tôi sẽ làm hết sức mình để giải thích nó ở đây bằng những thuật ngữ đơn giản, nhưng được cảnh báo rằng chủ đề này khiến học sinh của tôi mất vài tháng để cuối cùng nắm bắt. Bạn có thể tìm thêm thông tin về Chương 2 của Cấu trúc dữ liệu và thuật toán trong sách Java .
Không có quy trình cơ học nào có thể được sử dụng để có được BigOh.
Là một "sách dạy nấu ăn", để có được BigOh từ một đoạn mã trước tiên bạn cần nhận ra rằng bạn đang tạo một công thức toán học để đếm xem có bao nhiêu bước tính toán được thực hiện với một đầu vào có kích thước.
Mục đích rất đơn giản: để so sánh các thuật toán theo quan điểm lý thuyết, mà không cần phải thực thi mã. Số bước càng ít, thuật toán càng nhanh.
Ví dụ: giả sử bạn có đoạn mã này:
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
}
Hàm này trả về tổng của tất cả các phần tử của mảng và chúng tôi muốn tạo một công thức để tính độ phức tạp tính toán của hàm đó:
Number_Of_Steps = f(N)
Vì vậy, chúng ta có f(N), một hàm để đếm số bước tính toán. Đầu vào của hàm là kích thước của cấu trúc cần xử lý. Nó có nghĩa là chức năng này được gọi là:
Number_Of_Steps = f(data.length)
Tham số Nlấy data.lengthgiá trị. Bây giờ chúng ta cần định nghĩa thực tế của hàm f(). Điều này được thực hiện từ mã nguồn, trong đó mỗi dòng thú vị được đánh số từ 1 đến 4.
Có nhiều cách để tính toán BigOh. Từ thời điểm này trở đi, chúng ta sẽ giả sử rằng mỗi câu không phụ thuộc vào kích thước của dữ liệu đầu vào sẽ có một Csố bước tính toán không đổi .
Chúng ta sẽ thêm số bước riêng lẻ của hàm và không phải khai báo biến cục bộ cũng như câu lệnh return phụ thuộc vào kích thước của datamảng.
Điều đó có nghĩa là các dòng 1 và 4 có số lượng C mỗi bước và hàm có phần giống như sau:
f(N) = C + ??? + C
Phần tiếp theo là xác định giá trị của forcâu lệnh. Hãy nhớ rằng chúng ta đang đếm số bước tính toán, nghĩa là phần thân của forcâu lệnh được thực thi Nlần. Điều đó giống như thêm C, Nlần:
f(N) = C + (C + C + ... + C) + C = C + N * C + C
Không có quy tắc cơ học nào để đếm số lần cơ thể forđược thực thi, bạn cần đếm nó bằng cách xem mã làm gì. Để đơn giản hóa các tính toán, chúng tôi bỏ qua các phần khởi tạo, điều kiện và phần tăng của biến của forcâu lệnh.
Để có được BigOh thực tế, chúng ta cần phân tích tiệm cận của hàm. Điều này gần như được thực hiện như thế này:
- Lấy đi tất cả các hằng số
C.
- Từ
f()nhận được polynomium trong nó standard form.
- Chia các điều khoản của polynomium và sắp xếp chúng theo tốc độ tăng trưởng.
- Giữ một trong những phát triển lớn hơn khi
Ntiếp cận infinity.
Chúng tôi f()có hai điều khoản:
f(N) = 2 * C * N ^ 0 + 1 * C * N ^ 1
Lấy đi tất cả các Chằng số và các phần dư thừa:
f(N) = 1 + N ^ 1
Vì thuật ngữ cuối cùng là thuật ngữ phát triển lớn hơn khi f()tiếp cận vô hạn (nghĩ về giới hạn ), đây là đối số BigOh và sum()hàm có BigOh là:
O(N)
Có một vài thủ thuật để giải quyết một số mẹo khó: sử dụng tổng kết bất cứ khi nào bạn có thể.
Ví dụ, mã này có thể được giải quyết dễ dàng bằng cách sử dụng tổng:
for (i = 0; i < 2*n; i += 2) { // 1
for (j=n; j > i; j--) { // 2
foo(); // 3
}
}
Điều đầu tiên bạn cần được yêu cầu là thứ tự thực hiện foo(). Trong khi thông thường là như vậy O(1), bạn cần hỏi các giáo sư của bạn về nó. O(1)có nghĩa là (hầu hết, hầu hết) không đổi C, không phụ thuộc vào kích thước N.
Các fortuyên bố về câu số một là khó khăn. Trong khi chỉ số kết thúc tại 2 * N, việc tăng được thực hiện bởi hai. Điều đó có nghĩa là lần đầu tiên forđược thực hiện chỉ Ncác bước và chúng ta cần chia số đếm cho hai.
f(N) = Summation(i from 1 to 2 * N / 2)( ... ) =
= Summation(i from 1 to N)( ... )
Câu số hai thậm chí còn phức tạp hơn vì nó phụ thuộc vào giá trị của i. Hãy xem: chỉ số i lấy các giá trị: 0, 2, 4, 6, 8, ..., 2 * N và lần thứ hai forđược thực hiện: N lần thứ nhất, N - 2 lần thứ hai, N - 4 thứ ba ... cho đến giai đoạn N / 2, trong đó giai đoạn thứ hai forkhông bao giờ được thực thi.
Về công thức, điều đó có nghĩa là:
f(N) = Summation(i from 1 to N)( Summation(j = ???)( ) )
Một lần nữa, chúng tôi đang đếm số bước . Và theo định nghĩa, mọi tổng kết phải luôn bắt đầu tại một và kết thúc ở một số lớn hơn hoặc bằng một.
f(N) = Summation(i from 1 to N)( Summation(j = 1 to (N - (i - 1) * 2)( C ) )
(Chúng tôi đang giả định rằng đó foo()là O(1)và thực Chiện các bước.)
Chúng ta có một vấn đề ở đây: khi iđưa giá trị N / 2 + 1lên cao, Tóm tắt bên trong kết thúc ở một số âm! Điều đó là không thể và sai. Chúng ta cần chia tổng cộng làm hai, là điểm then chốt mà thời điểm này icần có 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 )
Kể từ thời điểm then chốt i > N / 2, bên trong forsẽ không được thực thi và chúng tôi giả định rằng độ phức tạp thực hiện C không đổi trên cơ thể của nó.
Bây giờ các tóm tắt có thể được đơn giản hóa bằng cách sử dụng một số quy tắc nhận dạng:
- Tổng (w từ 1 đến N) (C) = N * C
- Tổng kết (w từ 1 đến N) (A (+/-) B) = Tổng (w từ 1 đến N) (A) (+/-) Tổng kết (w từ 1 đến N) (B)
- Tổng (w từ 1 đến N) (w * C) = C * Tổng (w từ 1 đến N) (w) (C là hằng số, không phụ thuộc vào
w)
- Tổng (w từ 1 đến N) (w) = (N * (N + 1)) / 2
Áp dụng một số đại số:
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
Và BigOh là:
O(N²)
