1
00:00:07,720 --> 00:00:10,950
[Powered by Google Translate] Bạn đã từng nghe người ta nói về một thuật toán nhanh hoặc hiệu quả

2
00:00:10,950 --> 00:00:13,090
để thực hiện nhiệm vụ cụ thể của bạn,

3
00:00:13,090 --> 00:00:16,110
nhưng chính xác những gì nó có nghĩa là một thuật toán để được nhanh chóng hoặc hiệu quả?

4
00:00:16,110 --> 00:00:18,580
Vâng, nó không nói về đo lường trong thời gian thực,

5
00:00:18,580 --> 00:00:20,500
giống như giây hoặc vài phút.

6
00:00:20,500 --> 00:00:22,220
Điều này là do phần cứng máy tính

7
00:00:22,220 --> 00:00:24,260
và phần mềm khác nhau đáng kể.

8
00:00:24,260 --> 00:00:26,020
Chương trình của tôi có thể chạy chậm hơn so với của bạn,

9
00:00:26,020 --> 00:00:28,000
bởi vì tôi đang chạy nó trên một máy tính cũ,

10
00:00:28,000 --> 00:00:30,110
hoặc bởi vì tôi xảy ra để được chơi một trò chơi video trực tuyến

11
00:00:30,110 --> 00:00:32,670
cùng một lúc, được hogging tất cả các bộ nhớ của tôi,

12
00:00:32,670 --> 00:00:35,400
hoặc tôi có thể chạy chương trình của tôi thông qua phần mềm khác nhau

13
00:00:35,400 --> 00:00:37,550
mà giao tiếp với máy khác nhau ở mức độ thấp.

14
00:00:37,550 --> 00:00:39,650
Nó giống như so sánh táo và cam.

15
00:00:39,650 --> 00:00:41,940
Chỉ vì máy tính của tôi chậm hơn mất nhiều thời gian

16
00:00:41,940 --> 00:00:43,410
hơn của bạn để cung cấp cho một câu trả lời

17
00:00:43,410 --> 00:00:45,510
không có nghĩa là bạn có thuật toán hiệu quả hơn.

18
00:00:45,510 --> 00:00:48,830
>> Vì vậy, kể từ khi chúng tôi không thể so sánh trực tiếp các runtimes của các chương trình

19
00:00:48,830 --> 00:00:50,140
trong vài giây hoặc vài phút,

20
00:00:50,140 --> 00:00:52,310
làm thế nào để chúng ta so sánh 2 thuật toán khác nhau

21
00:00:52,310 --> 00:00:55,030
bất kể phần cứng hoặc phần mềm môi trường?

22
00:00:55,030 --> 00:00:58,000
Để tạo ra một cách đồng đều hơn của đo lường hiệu quả thuật toán,

23
00:00:58,000 --> 00:01:00,360
các nhà khoa học máy tính và toán học đã phát minh ra

24
00:01:00,360 --> 00:01:03,830
khái niệm để đo sự phức tạp tiệm cận của một chương trình

25
00:01:03,830 --> 00:01:06,110
và một ký hiệu được gọi là "Big Ohnotation '

26
00:01:06,110 --> 00:01:08,320
để mô tả điều này.

27
00:01:08,320 --> 00:01:10,820
Định nghĩa chính thức là một hàm f (x)

28
00:01:10,820 --> 00:01:13,390
chạy trên thứ tự của g (x)

29
00:01:13,390 --> 00:01:15,140
nếu có tồn tại một số giá trị (x), x ₀ và

30
00:01:15,140 --> 00:01:17,630
một số không đổi, C, mà

31
00:01:17,630 --> 00:01:19,340
f (x) nhỏ hơn hoặc bằng

32
00:01:19,340 --> 00:01:21,230
rằng thời gian liên tục g (x)

33
00:01:21,230 --> 00:01:23,190
cho tất cả các x lớn hơn x ₀.

34
00:01:23,190 --> 00:01:25,290
>> Tuy nhiên, không được sợ hãi bởi các định nghĩa chính thức.

35
00:01:25,290 --> 00:01:28,020
Điều này có thực sự có ý nghĩa trong ít về lý thuyết?

36
00:01:28,020 --> 00:01:30,580
Vâng, đó là cơ bản một cách phân tích

37
00:01:30,580 --> 00:01:33,580
nhanh như thế nào thời gian chạy của một chương trình phát triển tiệm.

38
00:01:33,580 --> 00:01:37,170
Đó là, như kích thước của đầu vào của bạn tăng theo hướng vô cùng,

39
00:01:37,170 --> 00:01:41,390
nói rằng, bạn đang phân loại một loạt các kích cỡ 1000 so với một mảng có kích thước là 10.

40
00:01:41,390 --> 00:01:44,950
Thời gian chạy của chương trình của bạn phát triển như thế nào?

41
00:01:44,950 --> 00:01:47,390
Ví dụ, hãy tưởng tượng đếm số ký tự

42
00:01:47,390 --> 00:01:49,350
trong một chuỗi cách đơn giản nhất

43
00:01:49,350 --> 00:01:51,620
 bằng cách đi bộ qua toàn bộ chuỗi

44
00:01:51,620 --> 00:01:54,790
thư-by-thư và cộng thêm 1 vào một truy cập cho mỗi ký tự.

45
00:01:55,700 --> 00:01:58,420
Thuật toán này được cho là chạy trong thời gian tuyến tính

46
00:01:58,420 --> 00:02:00,460
đối với số ký tự,

47
00:02:00,460 --> 00:02:02,670
'N' trong chuỗi.

48
00:02:02,670 --> 00:02:04,910
Trong ngắn hạn, nó chạy trong O (n).

49
00:02:05,570 --> 00:02:07,290
Tại sao điều này?

50
00:02:07,290 --> 00:02:09,539
Vâng, bằng cách sử dụng phương pháp này, thời gian cần thiết

51
00:02:09,539 --> 00:02:11,300
đi qua toàn bộ chuỗi

52
00:02:11,300 --> 00:02:13,920
là tỷ lệ thuận với số lượng ký tự.

53
00:02:13,920 --> 00:02:16,480
Đếm số ký tự trong một chuỗi 20 ký tự

54
00:02:16,480 --> 00:02:18,580
là sẽ mất gấp đôi thời gian như nó cần

55
00:02:18,580 --> 00:02:20,330
để đếm số ký tự trong một chuỗi 10 ký tự,

56
00:02:20,330 --> 00:02:23,000
bởi vì bạn phải nhìn vào tất cả các nhân vật

57
00:02:23,000 --> 00:02:25,740
và mỗi nhân vật có cùng một lượng thời gian để xem xét.

58
00:02:25,740 --> 00:02:28,050
Khi bạn tăng số ký tự,

59
00:02:28,050 --> 00:02:30,950
thời gian chạy sẽ tăng tuyến tính với chiều dài đầu vào.

60
00:02:30,950 --> 00:02:33,500
>> Bây giờ, hãy tưởng tượng nếu bạn quyết định rằng thời gian tuyến tính,

61
00:02:33,500 --> 00:02:36,390
O (n), chỉ là không đủ nhanh cho bạn?

62
00:02:36,390 --> 00:02:38,750
Có lẽ bạn đang lưu trữ chuỗi rất lớn,

63
00:02:38,750 --> 00:02:40,450
và bạn không thể đủ khả năng thêm thời gian nó sẽ mất

64
00:02:40,450 --> 00:02:44,000
đi qua tất cả các ký tự của họ đếm một-by-một.

65
00:02:44,000 --> 00:02:46,650
Vì vậy, bạn quyết định thử một cái gì đó khác nhau.

66
00:02:46,650 --> 00:02:49,270
Bạn nếu những gì sẽ xảy ra cho đã lưu trữ số lượng ký tự

67
00:02:49,270 --> 00:02:52,690
trong chuỗi, nói, trong một biến gọi là 'len,

68
00:02:52,690 --> 00:02:54,210
sớm trong chương trình,

69
00:02:54,210 --> 00:02:57,800
thậm chí trước khi bạn lưu trữ các ký tự đầu tiên trong chuỗi của bạn?

70
00:02:57,800 --> 00:02:59,980
Sau đó, tất cả những gì bạn phải làm bây giờ để tìm ra chiều dài chuỗi,

71
00:02:59,980 --> 00:03:02,570
là kiểm tra những gì giá trị của biến.

72
00:03:02,570 --> 00:03:05,530
Bạn sẽ không phải nhìn vào chuỗi chính nó ở tất cả,

73
00:03:05,530 --> 00:03:08,160
và truy cập các giá trị của một biến như len được coi là

74
00:03:08,160 --> 00:03:11,100
một thời gian hoạt động liên tục tiệm,

75
00:03:11,100 --> 00:03:13,070
O (1).

76
00:03:13,070 --> 00:03:17,110
Tại sao điều này? Vâng, nhớ tiệm cận phức tạp có nghĩa là gì.

77
00:03:17,110 --> 00:03:19,100
Làm thế nào để thay đổi thời gian chạy như kích thước

78
00:03:19,100 --> 00:03:21,400
của bạn đầu vào phát triển?

79
00:03:21,400 --> 00:03:24,630
>> Nói rằng bạn đã cố gắng để có được số ký tự trong một chuỗi lớn hơn.

80
00:03:24,630 --> 00:03:26,960
Vâng, nó sẽ không có vấn đề lớn như thế nào bạn thực hiện các chuỗi,

81
00:03:26,960 --> 00:03:28,690
thậm chí một triệu ký tự dài,

82
00:03:28,690 --> 00:03:31,150
tất cả các bạn sẽ phải làm gì để tìm độ dài của chuỗi với cách tiếp cận này,

83
00:03:31,150 --> 00:03:33,790
là để đọc ra các giá trị của len biến,

84
00:03:33,790 --> 00:03:35,440
mà bạn đã thực hiện.

85
00:03:35,440 --> 00:03:38,200
Chiều dài đầu vào, có nghĩa là, chiều dài của chuỗi bạn đang cố gắng để tìm thấy,

86
00:03:38,200 --> 00:03:41,510
không ảnh hưởng đến ở tất cả các chương trình của bạn chạy nhanh như thế nào.

87
00:03:41,510 --> 00:03:44,550
Điều này một phần của chương trình của bạn sẽ chạy như nhau nhanh trên một chuỗi ký tự

88
00:03:44,550 --> 00:03:46,170
và một chuỗi hàng nghìn ký tự,

89
00:03:46,170 --> 00:03:49,140
và đó là lý do tại sao chương trình này sẽ được gọi là chạy trong thời gian liên tục

90
00:03:49,140 --> 00:03:51,520
đối với kích thước đầu vào.

91
00:03:51,520 --> 00:03:53,920
>> Tất nhiên, có một nhược điểm.

92
00:03:53,920 --> 00:03:55,710
Bạn dành thêm không gian bộ nhớ trên máy tính của bạn

93
00:03:55,710 --> 00:03:57,380
lưu trữ các biến

94
00:03:57,380 --> 00:03:59,270
và thêm thời gian nó sẽ đưa bạn

95
00:03:59,270 --> 00:04:01,490
để làm các việc lưu trữ thực tế của biến,

96
00:04:01,490 --> 00:04:03,390
nhưng điểm vẫn đứng,

97
00:04:03,390 --> 00:04:05,060
tìm ra chuỗi của bạn là bao lâu

98
00:04:05,060 --> 00:04:07,600
không phụ thuộc vào chiều dài của chuỗi ở tất cả.

99
00:04:07,600 --> 00:04:10,720
Vì vậy, nó chạy trong O (1) thời gian liên tục.

100
00:04:10,720 --> 00:04:13,070
Điều này chắc chắn không phải có nghĩa là

101
00:04:13,070 --> 00:04:15,610
rằng mã của bạn chạy trong 1 bước,

102
00:04:15,610 --> 00:04:17,470
nhưng không có vấn đề bao nhiêu bước nó là,

103
00:04:17,470 --> 00:04:20,019
nếu nó không thay đổi với kích thước của các yếu tố đầu vào,

104
00:04:20,019 --> 00:04:23,420
nó vẫn còn tiệm liên tục mà chúng tôi đại diện là O (1).

105
00:04:23,420 --> 00:04:25,120
>> Như bạn có thể đoán,

106
00:04:25,120 --> 00:04:27,940
có rất nhiều khác nhau runtimes O lớn để đo lường các thuật toán với.

107
00:04:27,940 --> 00:04:32,980
O (n) ² thuật toán là tiệm chậm hơn so với các thuật toán O (n).

108
00:04:32,980 --> 00:04:35,910
Đó là, là số phần tử (n) phát triển,

109
00:04:35,910 --> 00:04:39,280
cuối cùng O (n) ² thuật toán sẽ mất thời gian nhiều hơn

110
00:04:39,280 --> 00:04:41,000
hơn so với các thuật toán O (n) để chạy.

111
00:04:41,000 --> 00:04:43,960
Điều này không có nghĩa là thuật toán O (n) luôn luôn chạy nhanh hơn

112
00:04:43,960 --> 00:04:46,410
hơn so với O (n) ² thuật toán, ngay cả trong cùng một môi trường,

113
00:04:46,410 --> 00:04:48,080
trên cùng một phần cứng.

114
00:04:48,080 --> 00:04:50,180
Có lẽ đối với kích thước đầu vào nhỏ,

115
00:04:50,180 --> 00:04:52,900
 O (n) ² thuật toán thực sự có thể làm việc nhanh hơn,

116
00:04:52,900 --> 00:04:55,450
nhưng, cuối cùng, như kích thước đầu vào tăng

117
00:04:55,450 --> 00:04:58,760
hướng tới vô cùng, O (n) ² thời gian chạy của thuật toán

118
00:04:58,760 --> 00:05:02,000
cuối cùng sẽ làm lu mờ thời gian chạy của thuật toán O (n).

119
00:05:02,000 --> 00:05:04,230
Cũng giống như bất kỳ chức năng toán học bậc hai

120
00:05:04,230 --> 00:05:06,510
 cuối cùng sẽ vượt qua bất kỳ chức năng tuyến tính,

121
00:05:06,510 --> 00:05:09,200
không có vấn đề bao nhiêu đầu bắt đầu chức năng tuyến tính bắt đầu.

122
00:05:10,010 --> 00:05:12,000
Nếu bạn đang làm việc với số lượng lớn dữ liệu,

123
00:05:12,000 --> 00:05:15,510
thuật toán chạy trong O (n) ² thời gian thực sự có thể kết thúc làm chậm chương trình của bạn,

124
00:05:15,510 --> 00:05:17,770
nhưng đối với kích thước đầu vào nhỏ,

125
00:05:17,770 --> 00:05:19,420
có thể bạn sẽ không nhận thấy.

126
00:05:19,420 --> 00:05:21,280
>> Một phức tạp tiệm cận là,

127
00:05:21,280 --> 00:05:24,420
lôgarít thời gian, O (log n).

128
00:05:24,420 --> 00:05:26,340
Một ví dụ của một thuật toán chạy một cách nhanh chóng

129
00:05:26,340 --> 00:05:29,060
là thuật toán tìm kiếm nhị phân cổ điển,

130
00:05:29,060 --> 00:05:31,850
cho việc tìm kiếm một phần tử trong một danh sách đã được sắp xếp của các nguyên tố.

131
00:05:31,850 --> 00:05:33,400
>> Nếu bạn không biết những gì tìm kiếm nhị phân,

132
00:05:33,400 --> 00:05:35,170
Tôi sẽ giải thích cho bạn thực sự nhanh chóng.

133
00:05:35,170 --> 00:05:37,020
Hãy nói rằng bạn đang tìm kiếm số 3

134
00:05:37,020 --> 00:05:40,200
trong mảng các số nguyên.

135
00:05:40,200 --> 00:05:42,140
Nó nhìn vào các phần tử giữa của mảng

136
00:05:42,140 --> 00:05:46,830
và hỏi, "các yếu tố tôi muốn lớn hơn, bằng, hoặc ít hơn này?"

137
00:05:46,830 --> 00:05:49,150
Nếu đó là bằng nhau, sau đó tuyệt vời. Bạn tìm thấy các yếu tố, và bạn đang làm.

138
00:05:49,150 --> 00:05:51,300
Nếu nó lớn hơn, sau đó bạn biết các phần tử

139
00:05:51,300 --> 00:05:53,440
có phải là ở phía bên phải của mảng,

140
00:05:53,440 --> 00:05:55,200
và bạn chỉ có thể nhìn vào đó trong tương lai,

141
00:05:55,200 --> 00:05:57,690
và nếu nó nhỏ hơn, sau đó bạn biết nó có phải là ở phía bên trái.

142
00:05:57,690 --> 00:06:00,980
Sau đó, quá trình này được lặp đi lặp lại với các mảng nhỏ hơn kích thước

143
00:06:00,980 --> 00:06:02,870
cho đến khi các yếu tố chính xác được tìm thấy.

144
00:06:08,080 --> 00:06:11,670
>> Thuật toán này mạnh mẽ cắt giảm kích thước mảng một nửa với mỗi hoạt động.

145
00:06:11,670 --> 00:06:14,080
Vì vậy, để tìm một phần tử trong một mảng được sắp xếp có kích thước 8,

146
00:06:14,080 --> 00:06:16,170
nhiều nhất (đăng nhập ₂ 8)

147
00:06:16,170 --> 00:06:18,450
hoặc 3 của các hoạt động này,

148
00:06:18,450 --> 00:06:22,260
sẽ được yêu cầu kiểm tra các yếu tố trung lưu, sau đó cắt các mảng trong một nửa,

149
00:06:22,260 --> 00:06:25,670
trong khi một mảng có kích thước 16 mất (đăng nhập ₂ 16),

150
00:06:25,670 --> 00:06:27,480
4 hoạt động.

151
00:06:27,480 --> 00:06:30,570
Đó là chỉ có 1 hoạt động cho một mảng tăng gấp đôi kích thước.

152
00:06:30,570 --> 00:06:32,220
Tăng gấp đôi kích thước của mảng

153
00:06:32,220 --> 00:06:35,160
tăng thời gian chạy chỉ có 1 đoạn mã này.

154
00:06:35,160 --> 00:06:37,770
Một lần nữa, kiểm tra các yếu tố giữa của danh sách, sau đó chia tách.

155
00:06:37,770 --> 00:06:40,440
Vì vậy, nó hoạt động trong thời gian lôgarít,

156
00:06:40,440 --> 00:06:42,440
O (log n).

157
00:06:42,440 --> 00:06:44,270
Nhưng chờ đợi, bạn nói,

158
00:06:44,270 --> 00:06:47,510
không phụ thuộc vào nơi trong danh sách các yếu tố bạn đang tìm kiếm?

159
00:06:47,510 --> 00:06:50,090
Điều gì sẽ xảy ra nếu các yếu tố đầu tiên bạn nhìn vào sẽ xảy ra là một trong những quyền?

160
00:06:50,090 --> 00:06:52,040
Sau đó, nó chỉ mất 1 hoạt động,

161
00:06:52,040 --> 00:06:54,310
không có vấn đề lớn như thế nào trong danh sách là.

162
00:06:54,310 --> 00:06:56,310
>> Vâng, đó là lý do tại sao các nhà khoa học máy tính có nhiều điều kiện hơn

163
00:06:56,310 --> 00:06:58,770
phức tạp tiệm cận, phản ánh trường hợp tốt nhất

164
00:06:58,770 --> 00:07:01,050
và trường hợp xấu nhất biểu diễn của một thuật toán.

165
00:07:01,050 --> 00:07:03,320
Đúng hơn, trên và dưới giới hạn

166
00:07:03,320 --> 00:07:05,090
thời gian chạy.

167
00:07:05,090 --> 00:07:07,660
Trong trường hợp tốt nhất cho tìm kiếm nhị phân, phần tử của chúng tôi là

168
00:07:07,660 --> 00:07:09,330
phải có ở giữa,

169
00:07:09,330 --> 00:07:11,770
và bạn nhận được nó trong thời gian liên tục,

170
00:07:11,770 --> 00:07:14,240
không có vấn đề lớn như thế nào phần còn lại của mảng.

171
00:07:15,360 --> 00:07:17,650
Các biểu tượng được sử dụng cho điều này là Ω.

172
00:07:17,650 --> 00:07:19,930
Vì vậy, thuật toán này được cho là để chạy trong Ω (1).

173
00:07:19,930 --> 00:07:21,990
Trong trường hợp tốt nhất, nó tìm thấy các phần tử một cách nhanh chóng,

174
00:07:21,990 --> 00:07:24,200
không có vấn đề mảng lớn như thế nào,

175
00:07:24,200 --> 00:07:26,050
nhưng trong trường hợp xấu nhất,

176
00:07:26,050 --> 00:07:28,690
nó có để thực hiện (log n) kiểm tra phân chia

177
00:07:28,690 --> 00:07:31,030
của mảng để tìm các phần tử bên phải.

178
00:07:31,030 --> 00:07:34,270
Giới hạn trường hợp xấu nhất trên được gọi lớn "O" mà bạn đã biết.

179
00:07:34,270 --> 00:07:38,080
Vì vậy, nó là O (log n), nhưng Ω (1).

180
00:07:38,080 --> 00:07:40,680
>> Một tìm kiếm tuyến tính, ngược lại,

181
00:07:40,680 --> 00:07:43,220
trong đó bạn đi bộ qua tất cả các phần tử của mảng

182
00:07:43,220 --> 00:07:45,170
để tìm thấy một trong những bạn muốn,

183
00:07:45,170 --> 00:07:47,420
là tốt nhất Ω (1).

184
00:07:47,420 --> 00:07:49,430
Một lần nữa, các yếu tố đầu tiên mà bạn muốn.

185
00:07:49,430 --> 00:07:51,930
Vì vậy, nó không quan trọng mảng lớn như thế nào.

186
00:07:51,930 --> 00:07:54,840
Trong trường hợp xấu nhất, đó là yếu tố cuối cùng trong mảng.

187
00:07:54,840 --> 00:07:58,560
Vì vậy, bạn phải đi bộ qua tất cả các yếu tố n trong mảng để tìm thấy nó,

188
00:07:58,560 --> 00:08:02,170
giống như nếu bạn đang tìm kiếm 3 a.

189
00:08:04,320 --> 00:08:06,030
Vì vậy, nó chạy trong thời gian O (n)

190
00:08:06,030 --> 00:08:09,330
bởi vì nó tỷ lệ thuận với số lượng phần tử trong mảng.

191
00:08:10,800 --> 00:08:12,830
>> Một biểu tượng được sử dụng là Θ.

192
00:08:12,830 --> 00:08:15,820
Điều này có thể được sử dụng để mô tả các thuật toán của các trường hợp tốt nhất và tồi tệ nhất

193
00:08:15,820 --> 00:08:17,440
đều giống nhau.

194
00:08:17,440 --> 00:08:20,390
Đây là trường hợp trong các thuật toán chuỗi dài, chúng ta đã nói trước đó.

195
00:08:20,390 --> 00:08:22,780
Đó là, nếu chúng ta lưu trữ nó trong một biến trước khi

196
00:08:22,780 --> 00:08:25,160
chúng tôi lưu trữ các chuỗi và truy cập nó sau trong thời gian liên tục.

197
00:08:25,160 --> 00:08:27,920
Không có vấn đề gì số

198
00:08:27,920 --> 00:08:30,130
chúng tôi đang lưu trữ trong biến đó, chúng tôi sẽ phải nhìn vào nó.

199
00:08:33,110 --> 00:08:35,110
Trường hợp tốt nhất, chúng ta nhìn vào nó

200
00:08:35,110 --> 00:08:37,120
và tìm thấy chiều dài của chuỗi.

201
00:08:37,120 --> 00:08:39,799
Vì vậy, Ω (1) hoặc tốt nhất trường hợp thời gian liên tục.

202
00:08:39,799 --> 00:08:41,059
Trường hợp xấu nhất là,

203
00:08:41,059 --> 00:08:43,400
chúng ta nhìn vào nó và tìm ra chiều dài của chuỗi.

204
00:08:43,400 --> 00:08:47,300
Vì vậy, O (1) thời gian liên tục trong trường hợp xấu nhất.

205
00:08:47,300 --> 00:08:49,180
Vì vậy, kể từ khi trường hợp tốt nhất và trường hợp xấu nhất là như nhau,

206
00:08:49,180 --> 00:08:52,520
này có thể được cho biết để chạy trong thời gian (1) Θ.

207
00:08:54,550 --> 00:08:57,010
>> Tóm lại, chúng ta có những cách tốt để lý do về mã hiệu quả

208
00:08:57,010 --> 00:09:00,110
mà không biết bất cứ điều gì về thời gian thực tế họ để chạy,

209
00:09:00,110 --> 00:09:02,270
bị ảnh hưởng bởi rất nhiều yếu tố bên ngoài,

210
00:09:02,270 --> 00:09:04,190
bao gồm cả phần cứng khác nhau, phần mềm,

211
00:09:04,190 --> 00:09:06,040
hoặc các chi tiết cụ thể của mã của bạn.

212
00:09:06,040 --> 00:09:08,380
Ngoài ra, nó cho phép chúng ta để lý do về những gì sẽ xảy ra

213
00:09:08,380 --> 00:09:10,180
khi kích thước của sự gia tăng đầu vào.

214
00:09:10,180 --> 00:09:12,490
>> Nếu bạn đang chạy trong thuật toán O ² (n),

215
00:09:12,490 --> 00:09:15,240
hoặc tệ hơn, một O (2 ⁿ) thuật toán,

216
00:09:15,240 --> 00:09:17,170
một trong những loại phát triển nhanh nhất,

217
00:09:17,170 --> 00:09:19,140
bạn thực sự sẽ bắt đầu nhận thấy sự suy giảm

218
00:09:19,140 --> 00:09:21,220
khi bạn bắt đầu làm việc với số lượng lớn dữ liệu.

219
00:09:21,220 --> 00:09:23,590
>> Đó là tiệm cận phức tạp. Cảm ơn.