Bài này viết về tìm kiếm trên một mảng hữu hạn đã được sắp xếp. Đối với tìm kiếm các giá trị của một hàm liên tục, xem phương pháp chia đôi.Thuật toán tìm kiếm tìm vị trí của một giá trị cần tìm trong một mảng đã được sắp xếp
Trong khoa học máy tính, **tìm kiếm nhị phân** (tiếng Anh: *binary search*), còn gọi là **tìm kiếm nửa khoảng** (*half-interval search*), **tìm kiếm logarit** (*logarithmic search*), hay **chặt nhị phân** (*binary chop*), là một thuật toán tìm kiếm xác định vị trí của một giá trị cần tìm trong một mảng đã được sắp xếp. Thuật toán tiến hành so sánh giá trị cần tìm với phần tử đứng giữa mảng. Nếu hai giá trị không bằng nhau, phần nửa mảng không chứa giá trị cần tìm sẽ bị bỏ qua và tiếp tục tìm kiếm trên nửa còn lại, một lần nữa lấy phần tử ở giữa và so sánh với giá trị cần tìm, cứ thế lặp lại cho đến khi tìm thấy giá trị đó. Nếu phép tìm kiếm kết thúc khi nửa còn lại trống thì giá trị cần tìm không có trong mảng.

Tìm kiếm nhị phân chạy theo thời gian logarit trong trường hợp tệ nhất, thực hiện O(\log n) bước so sánh, trong đó n là số phần tử trong mảng, {\displaystyle O} là kí hiệu O lớn, và {\displaystyle \log } là phép toán logarit. Thuật toán tìm kiếm nhị phân nhanh hơn so với tìm kiếm tuyến tính, ngoại trừ các trường hợp mảng có kích thước nhỏ. Tuy nhiên, mảng phải được sắp xếp trước khi áp dụng tìm kiếm nhị phân. Một số cấu trúc dữ liệu chuyên dụng được thiết kế cho việc tìm kiếm nhanh, ví dụ như bảng băm, có thể thực hiện tìm hiệu quả hơn tìm kiếm nhị phân. Tuy nhiên, thuật toán này có thể dùng để giải quyết nhiều loại vấn đề hơn, như tìm phần tử nhỏ nhất hoặc lớn nhất tiếp theo trong mảng so với giá trị cho trước, kể cả khi nó không có trong mảng.

Có nhiều biến thể của phép tìm kiếm nhị phân. Cụ thể, phương pháp "đổ xuống một phần" (*fractional cascading*) giúp tăng tốc tìm kiếm nhị phân với cùng một giá trị trong nhiều mảng. Phương pháp này cho phép giải quyết hiệu quả một số vấn đề về tìm kiếm trong hình học tính toán và nhiều lĩnh vực khác. Thuật toán tìm kiếm mũ (*exponential search*) mở rộng tìm kiếm nhị phân sang các danh sách không có giới hạn. Các cấu trúc dữ liệu cây tìm kiếm nhị phân và B-cây được xây dựng dựa trên tìm kiếm nhị phân.

Thuật toán
----------

Thuật toán tìm kiếm nhị phân hoạt động trên các mảng đã được sắp xếp. Thuật toán bắt đầu bằng việc so sánh một phần tử đứng chính giữa mảng với giá trị cần tìm. Nếu bằng nhau, vị trí của nó trong mảng sẽ được trả về. Nếu giá trị cần tìm nhỏ hơn phần tử này, quá trình tìm kiếm tiếp tục ở nửa nhỏ hơn của mảng. Nếu giá trị cần tìm lớn hơn phần tử ở giữa, quá trình tìm kiếm tiếp tục ở nửa lớn hơn của mảng. Bằng cách này, ở mỗi phép lặp thuật toán có thể loại bỏ nửa mảng mà giá trị cần tìm chắc chắn không xuất hiện.

### Quy trình

Cho một mảng A có n phần tử với các giá trị hoặc bản ghi {\displaystyle A\_{0},A\_{1},A\_{2},\ldots ,A\_{n-1}}đã được sắp xếp sao cho {\displaystyle A\_{0}\leq A\_{1}\leq A\_{2}\leq \cdots \leq A\_{n-1}}, và giá trị cần tìm T, chương trình con sau đây sử dụng tìm kiếm nhị phân để tìm chỉ số của T trong A.

1. Gán L với giá trị {\displaystyle 0} và R với giá trị {\displaystyle n-1}.
2. Nếu {\displaystyle L>R}, quá trình tìm kiếm thất bại.
3. Gán m (vị trí của phần tử đứng giữa) với giá trị floor của {\displaystyle {\frac {L+R}{2}}}, tức là số nguyên lớn nhất nhỏ hơn hoặc bằng {\displaystyle {\frac {L+R}{2}}}.
4. Nếu {\displaystyle A\_{m}<T}, gán L với {\displaystyle m+1} và quay lại bước 2.
5. Nếu {\displaystyle A\_{m}>T}, gán R với {\displaystyle m-1} và quay lại bước 2.
6. Khi {\displaystyle A\_{m}=T}, quá trình tìm kiếm hoàn tất; trả về m.

Quy trình lặp này dùng hai biến L và R để lưu giới hạn tìm kiếm. Quy trình này có thể diễn giải bằng mã giả như dưới đây, trong đó tên các biến và kiểu giữ nguyên so với như trên, `floor` là hàm floor, và `không_thành_công` là một giá trị cụ thể thông báo tìm kiếm thất bại.

```
**function** binary_search(A, n, T) **is**
    L:= 0
    R:= n − 1
    **while** L ≤ R **do**
        m:= floor((L + R) / 2)
        **if** A[m] < T **then**
            L:= m + 1
        **else if** A[m] > T **then**
            R:= m - 1
        **else**:
            **return** m
    **return** không_thành_công
```

Ngoài ra, thuật toán có thể lấy giá trị ceiling của {\displaystyle {\frac {L+R}{2}}}. Điều này có thể thay đổi kết quả nếu giá trị cần tìm xuất hiện nhiều hơn một lần trong mảng.

#### Cách làm khác

Trong quy trình trên, thuật toán kiểm tra phần tử ở giữa (m) có bằng giá trị cần tìm (T) không ở mỗi phép lặp. Một số cách làm bỏ qua bước này ở mỗi phép lặp. Khi đó thuật toán chỉ kiểm tra điều này khi chỉ còn một phần tử còn lại (khi {\displaystyle L=R}). Nhờ đó mà vòng lặp so sánh được thực hiện nhanh hơn do mỗi phép lặp đã loại bỏ được một bước so sánh. Tuy nhiên, với cách làm này thì số phép lặp trung bình tăng lên.

Hermann Bottenbruch cho xuất bản cách áp dụng đầu tiên bỏ qua bước kiểm tra này vào năm 1962.

1. Gán L với giá trị {\displaystyle 0} và R với giá trị {\displaystyle n-1}.
2. Khi {\displaystyle L\neq R},
	1. Gán m (vị trí của phần tử đứng giữa) với giá trị ceiling của {\displaystyle {\frac {L+R}{2}}}, tức là số nguyên nhỏ nhất lớn hơn hoặc bằng {\displaystyle {\frac {L+R}{2}}}.
	2. Nếu {\displaystyle A\_{m}>T}, gán R với {\displaystyle m-1}.
	3. Trường hợp còn lại, {\displaystyle A\_{m}\leq T}; gán L với m.
3. Khi {\displaystyle L=R}, quá trình tìm kiếm hoàn tất. Nếu {\displaystyle A\_{L}=T}, trả về L. Nếu không, tìm kiếm thất bại.

Với `ceil` là hàm ceiling, mã giả cho phiên bản này như sau:

```
**function** binary_search_alternative(A, n, T) **is**
    L:= 0
    R:= n − 1
    **while** L != R **do**
        m:= ceil((L + R) / 2)
        **if** A[m] > T **then**
            R:= m - 1
        **else**:
            L:= m
    **if** A[L] = T **then**
        **return** L
    **return** không_thành_công
```

### Phần tử lặp lại

Quy trình trên có thể trả về bất cứ chỉ số nào có giá trị phần tử bằng giá trị cần tìm, kể cả khi trong mảng có các phần tử xuất hiện lặp lại. Ví dụ, với mảng {\displaystyle [1,2,3,4,4,5,6,7]} và giá trị cần tìm là {\displaystyle 4}, thuật toán có thể trả về một trong hai kết quả đúng là phần tử thứ 4 (chỉ số là 3) hoặc thứ 5 (chỉ số là 4). Quy trình chuẩn trong trường hợp này sẽ trả về phần tử thứ 4 (chỉ số 3). Thuật toán này không phải lúc nào cũng trả về vị trí đầu tiên xuất hiện giá trị cần tìm (ví dụ với mảng {\displaystyle [1,2,4,4,4,5,6,7]}, kết quả trả về vẫn là phần tử thứ 4). Tuy nhiên, có một số trường hợp cần phải tìm phần tử nằm xa nhất về phía bên trái hoặc bên phải mang giá trị cần tìm khi giá trị này xuất hiện lặp lại trong mảng. Trong ví dụ trên, phần tử thứ 4 là phần tử đứng xa nhất về bên trái mang giá trị 4, trong khi phần tử thứ 5 là phần từ đứng xa nhất về bên phải mang giá trị 4. Cách làm thứ hai ở trên sẽ luôn trả về chỉ số của phần tử đứng xa nhất về bên phải nếu tồn tại các phần tử lặp lại.

#### Quy trình tìm phần tử xa nhất về bên trái

Để tìm phần tử xa nhất về bên trái, ta có thể dùng quy trình sau:

1. Gán L với giá trị {\displaystyle 0} và R với n.
2. Khi {\displaystyle L<R},
3. Gán m (vị trí của phần tử đứng giữa) với giá trị floor của {\displaystyle {\frac {L+R}{2}}}, tức là số nguyên lớn nhất nhỏ hơn hoặc bằng {\displaystyle {\frac {L+R}{2}}}.
	1. Nếu {\displaystyle A\_{m}<T}, gán L với {\displaystyle m+1}.
	2. Trường hợp còn lại, {\displaystyle A\_{m}\geq T}; gán *R* với m.
4. Trả về L.

Nếu {\displaystyle L<n} và {\displaystyle A\_{L}=T} thì {\displaystyle A\_{L}} là phần tử đứng xa nhất về bên trái có giá trị bằng T. Kể cả khi T không nằm trong mảng, L là hạng của T trong mảng, hay số phần tử trong mảng nhỏ hơn T.

Với `floor` là hàm floor, mã giả cho phiên bản này như sau:

```
**function** binary_search_leftmost(A, n, T):
    L:= 0
    R:= n
    **while** L < R:
        m:= floor((L + R) / 2)
        **if** A[m] < T:
            L:= m + 1
        **else**:
            R:= m
    **return** L
```

#### Quy trình tìm phần tử xa nhất về bên phải

Để tìm phần tử xa nhất về bên phải, ta có thể dùng quy trình sau:

1. Gán L với giá trị {\displaystyle 0} và R với n.
2. Khi {\displaystyle L<R},
3. Gán m (vị trí của phần tử đứng giữa) với giá trị floor của {\displaystyle {\frac {L+R}{2}}}, tức là số nguyên lớn nhất nhỏ hơn hoặc bằng {\displaystyle {\frac {L+R}{2}}}.
	1. Nếu {\displaystyle A\_{m}>T}, gán R với m.
	2. Trường hợp còn lại, {\displaystyle A\_{m}\leq T}; gán *L* với {\displaystyle m+1}.
4. Trả về {\displaystyle R-1}.

Nếu {\displaystyle L>0} và {\displaystyle A\_{L-1}=T}, thì {\displaystyle A\_{L-1}} là phần tử đứng xa nhất về phía bên phải có giá trị bằng T. Kể cả khi *T* không có trong mảng, {\displaystyle n-L} sẽ là số phần tử trong mảng lớn hơn *T*.

Với `floor` là hàm floor, mã giả cho phiên bản này như sau:

```
**function** binary_search_rightmost(A, n, T):
    L:= 0
    R:= n
    **while** L < R:
        m:= floor((L + R) / 2)
        **if** A[m] > T:
            R:= m
        **else**:
            L:= m + 1
    **return** R - 1
```

Hiệu suất
---------

Một cây biểu diễn tìm kiếm nhị phân. Mảng được dùng trong ví dụ này là {\displaystyle [20,30,40,50,80,90,100]} và giá trị cần tìm là {\displaystyle 40}.
Trường hợp tệ nhất là khi quá trình tìm kiếm phải đi tới bậc sâu nhất của cây, còn trường hợp tốt nhất là khi giá trị cần tìm chính là phần tử đứng giữa.
Về mặt số phép so sánh, hiệu suất của thuật toán tìm kiếm nhị phân có thể được phân tích bằng cách biểu diễn quá trình chạy thuật toán trên cây nhị phân. Nút gốc của cây là phần tử đứng giữa mảng. Phần tử đứng giữa nửa nhỏ hơn là nút con bên trái của nút gốc, và phần tử đứng giữa nửa lớn hơn là nút con bên phải của nút gốc. Phần còn lại của cây cũng được dựng như vậy. Bắt đầu từ nút gốc, tùy theo giá trị cần tìm nhỏ hơn hay lớn hơn nút đang xét mà thuật toán sẽ duyệt theo cây con bên trái hay bên phải.

Trong trường hợp tệ nhất, thuật toán thực hiện {\textstyle \lfloor \log \_{2}(n)+1\rfloor } lần lặp so sánh, trong đó {\textstyle \lfloor \rfloor } là ký hiệu của hàm floor cho kết quả là số nguyên lớn nhất nhỏ hơn hoặc bằng giá trị bên trong, và {\textstyle \log \_{2}} là phép logarit nhị phân. Nguyên nhân là do khi gặp phải trường hợp tệ nhất, thuật toán phải đi tới bậc sâu nhất trong cây, và số bậc trong cây luôn bằng {\textstyle \lfloor \log \_{2}(n)+1\rfloor } với bất cứ phép tìm kiếm nhị phân nào.

Trường hợp tệ nhất còn có thể xảy ra khi giá trị cần tìm không có trong mảng. Nếu {\textstyle n} ở dạng {\textstyle 2^{\alpha }-1} thì trường hợp này luôn xảy ra. Nếu không, thuật toán có thể thực hiện {\textstyle \lfloor \log \_{2}(n)+1\rfloor }phép lặp nếu phải đi tới bậc sâu nhất của cây. Tuy nhiên, nếu thuật toán kết thúc ngay ở bậc sâu thứ hai của cây, quá trình tìm kiếm có thể chỉ cần thực hiện {\textstyle \lfloor \log \_{2}(n)\rfloor } phép lặp, ít hơn trường hợp tệ nhất một phép.

Giả sử mỗi phần tử có xác suất được thực hiện tìm kiếm như nhau, trung bình thuật toán tìm kiếm nhị phân thực hiện {\displaystyle \lfloor \log \_{2}(n)\rfloor +1-(2^{\lfloor \log \_{2}(n)\rfloor +1}-\lfloor \log \_{2}(n)\rfloor -2)/n} phép lặp khi phần tử cần tìm có mặt trong mảng, hay xấp xỉ bằng {\displaystyle \log \_{2}(n)-1}. Khi phần tử cần tìm không có trong mảng, thuật toán thực hiện trung bình {\displaystyle \lfloor \log \_{2}(n)\rfloor +2-2^{\lfloor \log \_{2}(n)\rfloor +1}/(n+1)} phép lặp, nếu giả sử khoảng giữa và bên ngoài các phần tử đều có xác suất được tìm như nhau.

Trong trường hợp tốt nhất, khi giá trị cần tìm nằm ngay giữa mảng, vị trí của nó được trả về ngay sau một phép lặp.

Về mặt số phép lặp, không có thuật toán tìm kiếm nào chỉ bằng so sánh các phần tử có thể có hiệu suất trung bình hay thậm chí trong trường hợp tệ nhất tốt hơn tìm kiếm nhị phân. Cây so sánh biểu diễn tìm kiếm nhị phân có số bậc ít nhất có thể do mọi bậc phía trên bậc thấp nhất của cây đều được lấp đầy hoàn toàn. Nếu không, thuật toán tìm kiếm có thể loại bỏ một vài phần tử trong mỗi phép lặp, làm tăng số phép lặp cần thực hiện trong trường hợp trung bình và tệ nhất. Các thuật toán tìm kiếm khác dùng cách so sánh đều bị rơi vào trường hợp này, do mặc dù chúng có thể chạy nhanh hơn với một số giá trị cần tìm nhất định, hiệu suất trung bình trên *tất cả* phần tử vẫn kém hơn tìm kiếm nhị phân. Bằng cách chia mảng thành hai nửa, thuật toán tìm kiếm nhị phân đảm bảo được kích thước của hai mảng con giống nhau nhất có thể.

#### Độ phức tạp không gian

Thuật toán tìm kiếm nhị phân cần ba con trỏ để trỏ tới các phần tử, bất kể kích thước của mảng; đó có thể là chỉ số các phần tử trong mảng hoặc con trỏ tới địa chỉ trong bộ nhớ. Tuy nhiên, thuật toán cần ít nhất {\displaystyle \left\lceil \log \_{2}(n)\right\rceil } bit để mã hóa một con trỏ tới một phần tử trong mảng có n phần tử. Do đó, độ phức tạp không gian của tìm kiếm nhị phân là O(\log n). Ngoài ra, thuật toán còn cần O(n) không gian để lưu trữ mảng.

### Trường hợp trung bình

Số phép lặp trung bình được thực hiện bởi thuật toán tùy thuộc vào xác suất mỗi phần tử được thực hiện tìm kiếm. Trường hợp trung bình khi tìm kiếm thành công và không thành công là khác nhau. Ta giả sử mỗi phần tử có xác suất được tìm như nhau nếu tìm kiếm thành công. Nếu tìm kiếm không thành công, ta giả sử các khoảng giữa và ngoài các phần tử có xác suất được tìm giống nhau. Trường hợp trung bình khi tìm kiếm thành công là số phép lặp cần thực hiện để tìm mọi phần tử chính xác một lần, chia cho n, số phần tử trong mảng. Trường hợp trung bình khi tìm kiếm không thành công là số phép lặp cần thực hiện để tìm một phần tử trong mọi khoảng chính xác một lần, chia cho {\displaystyle n+1} khoảng.

#### Tìm kiếm thành công

Khi biểu diễn bằng cây nhị phân, một lần tìm kiếm thành công có thể được biểu diễn bằng một đường đi từ gốc tới nút cần tìm, gọi là *đường đi trong* (*internal path*). Độ dài của một đường đi là số cạnh (đường nối giữa các nút) mà đường đó đi qua. Số phép lặp mà một lần tìm kiếm thực hiện, với điều kiện độ dài của đường đi tương ứng với lần tìm đó là {\displaystyle l}, là {\displaystyle l+1} tính cả phép lặp ban đầu. *Độ dài đường đi trong* (*internal path length*) là tổng độ dài tất cả các đường đi trong. Do chỉ có một đường đi duy nhất từ gốc tới bất cứ nút nào, mỗi đường trong đó biểu diễn cho một phép tìm kiếm phần tử tương ứng. Nếu có n phần tử, và độ dài đường trong là {\displaystyle I(n)}, thì số phép lặp trung bình cho một lần tìm kiếm thành công là {\displaystyle T(n)=1+{\frac {I(n)}{n}}}, trong đó đã cộng thêm một bước lặp ở đầu.

Do tìm kiếm nhị phân là thuật toán tối ưu cho việc tìm kiếm bằng cách so sánh, bài toán được đơn giản hóa thành việc tính độ dài đường đi trong tối thiểu của tất cả cây nhị phân có n nút, tức là bằng:

{\displaystyle I(n)=\sum \_{k=1}^{n}\left\lfloor \log \_{2}(k)\right\rfloor }

Ví dụ, với một mảng 7 phần tử, phần tử gốc cần một phép lặp, hai phần tử bên dưới gốc cần hai phép lặp, và bốn phần tử dưới nữa gần ba phép lặp. Trong trường hợp này, độ dài đường đi trong là:

{\displaystyle \sum \_{k=1}^{7}\left\lfloor \log \_{2}(k)\right\rfloor =0+2(1)+4(2)=2+8=10}

Số phép lặp trung bình sẽ là {\displaystyle 1+{\frac {10}{7}}=2{\frac {3}{7}}} dựa theo công thức với trường hợp trung bình. Tổng {\displaystyle I(n)} có thể rút gọn thành:

{\displaystyle I(n)=\sum \_{k=1}^{n}\left\lfloor \log \_{2}(k)\right\rfloor =(n+1)\left\lfloor \log \_{2}(n+1)\right\rfloor -2^{\left\lfloor \log \_{2}(n+1)\right\rfloor +1}+2}

Thay {\displaystyle I(n)} vào phương trình {\displaystyle T(n)}:

{\displaystyle T(n)=1+{\frac {(n+1)\left\lfloor \log \_{2}(n+1)\right\rfloor -2^{\left\lfloor \log \_{2}(n+1)\right\rfloor +1}+2}{n}}=\lfloor \log \_{2}(n)\rfloor +1-(2^{\lfloor \log \_{2}(n)\rfloor +1}-\lfloor \log \_{2}(n)\rfloor -2)/n}

Với n là một số nguyên, phương trình trên tương đương với phương trình trong trường hợp trung bình cho một lần tìm kiếm thành công như đã chỉ ra ở trên.

#### Tìm kiếm không thành công

Ta có thể biểu diễn lần tìm kiếm không thành công bằng cách thêm vào cây các *nút ngoài*, tạo thành *cây nhị phân mở rộng*. Nếu một nút trong, hoặc một nút có trong cây, có ít hơn hai nút con, thì ta sẽ thêm vào các nút con bổ sung, gọi là các nút ngoài, để mỗi nút trong đều có hai nút con. By doing so, an unsuccessful search can be represented as a path to an external node, whose parent is the single element that remains during the last iteration. *Đường đi ngoài* (*external path*) là đường đi từ gốc đến một nút ngoài. *Độ dài đường đi ngoài* (*external path length*) là tổng độ dài tất cả đường đi ngoài unique. Nếu số phần tử là n (n là số nguyên dương), và độ dài đường đi ngoài là {\displaystyle E(n)}, thì số phép lặp trung bình cho một lần tìm kiếm không thành công là {\displaystyle T'(n)={\frac {E(n)}{n+1}}}, trong đó đã tính một phép lặp lúc đầu. Trong công thức này, ta lấy độ dài đường đi ngoài chia cho {\displaystyle n+1} chứ không phải n vì có {\displaystyle n+1} đường đi ngoài biểu diễn cho các khoảng giữa và ngoài các phần tử trong mảng.

Tương tự, bài toán này có thể đơn giản hóa thành bài toán tính độ dài đường đi ngoài tối thiếu của tất cả cây nhị phân có n nút. Với tất cả các cây nhị phân, độ dài đường đi ngoài bằng độ dài đường đi trong cộng với {\displaystyle 2n}. Thay {\displaystyle I(n)} vào ta có:

{\displaystyle E(n)=I(n)+2n=\left[(n+1)\left\lfloor \log \_{2}(n+1)\right\rfloor -2^{\left\lfloor \log \_{2}(n+1)\right\rfloor +1}+2\right]+2n=(n+1)(\lfloor \log \_{2}(n)\rfloor +2)-2^{\lfloor \log \_{2}(n)\rfloor +1}}

Thay {\displaystyle E(n)} vào công thức tính {\displaystyle T'(n)}, ta có thể xác định trường hợp trung bình cho những lần tìm kiếm không thành công:

{\displaystyle T'(n)={\frac {(n+1)(\lfloor \log \_{2}(n)\rfloor +2)-2^{\lfloor \log \_{2}(n)\rfloor +1}}{(n+1)}}=\lfloor \log \_{2}(n)\rfloor +2-2^{\lfloor \log \_{2}(n)\rfloor +1}/(n+1)}

#### Hiệu suất của các cách thay thế

Mỗi phép lặp trong cách tìm kiếm nhị phân trên thực hiện một hoặc hai lần so sánh để kiểm tra phần tử ở giữa có bằng với giá trị cần tìm không. Giả sử mỗi phần tử có xác suất được tìm bằng nhau, mỗi phép lặp thực hiện trung bình 1,5 lần so sánh. Một cách làm khác của thuật toán sẽ thực hiện kiểm tra phần tử giữa ở cuối mỗi lần tìm kiếm. Theo cách này, trung bình mỗi phép lặp bỏ qua 0,5 lần so sánh, tiết kiệm thời gian hơn một chút trên mỗi phép lặp ở hầu hết các loại máy tính. Tuy nhiên, cách này lại khiến mỗi lần tìm kiếm luôn phải thực hiện số phép lặp tối đa, trung bình mỗi lần tìm cộng thêm một phép lặp. Vì vòng lặp so sánh chỉ được thực hiện {\textstyle \lfloor \log \_{2}(n)+1\rfloor } lần trong trường hợp tệ nhất, việc tăng nhẹ hiệu suất ở mỗi phép lặp không thể bù lại cho phép lặp cần thực hiện thêm khi {\textstyle n} không lớn.

### Thời gian chạy và mức sử dụng cache

Trong quá trình phân tích hiệu suất của thuật toán, một vấn đề khác cần lưu ý là thời gian cần để so sánh hai phần tử. Với các số nguyên và chuỗi ký tự, khoảng thời gian này tăng tuyến tính do độ dài mã hóa (thường là số bit) của các phần tử tăng theo. Ví dụ, một cặp số nguyên dương 64 bit sẽ cần phải so sánh số bit gấp đôi so với một cặp số nguyên dương 32 bit. Trường hợp tệ nhất được đạt đến khi hai số nguyên bằng nhau. Điều này có thể đáng lưu tâm khi độ dài mã hóa của các phần tử ở mức lớn, ví dụ như khi so sánh các số thuộc kiểu nguyên lớn hơn hay so sánh các chuỗi ký tự dài, khiến cho việc so sánh rất tốn thời gian. Hơn nữa, so với các số nguyên hoặc chuỗi ký tự ngắn thì so sánh các giá trị dấu phẩy động (cách biểu diễn số thông dụng nhất của số thực) thường còn tốn thời gian hơn..

Trên hầu hết các kiểu kiến trúc máy tính, bộ vi xử lý có bộ nhớ cache riêng tách biệt khỏi RAM. Do nằm ngay trong bộ xử lý, bộ nhớ cache có thể truy cập nhanh hơn nhưng thường chỉ chứa được ít dữ liệu hơn RAM. Do đó, hầu hết các bộ xử lý lưu địa chỉ những vùng bộ nhớ đã được truy cập gần đây và cả những vùng bộ nhớ xung quanh chúng. Ví dụ, khi truy cập vào một phần tử trong mảng, phần tử này, cùng với cả những phần tử được lưu gần đó, có thể được lưu vào trong RAM để sau đó có thể truy cập nhanh hơn được vào các phần tử khác liền kề (tính địa phương trong truy xuất - *locality of reference*). Với một mảng đã sắp xếp, quá trình tìm kiếm nhị phân có thể phải nhảy sang các vùng bộ nhớ nằm xa nếu mảng có kích thước lớn, không giống như các thuật toán (như tìm kiếm tuyến tính hay dò tuyến tính trong bảng băm) truy cập các phần tử theo thứ tự lần lượt. Điều này làm thời gian chạy của thuật toán tăng lên đôi chút với các mảng lớn trên hầu hết các hệ thống.

Tìm kiếm nhị phân với các hệ thống khác
---------------------------------------

Áp dụng tìm kiếm nhị phân với các mảng đã được sắp xếp là một giải pháp rất không hiệu quả khi xen giữa các phép chèn và xóa còn là các phép truy hồi, mỗi thao tác đó phải mất {\textstyle O(n)} thời gian để thực hiện. Ngoài ra, yêu cầu phải sắp xếp trước các mảng có thể làm phức tạp việc sử dụng bộ nhớ, đặc biệt là khi các phần tử thường được chèn vào trong mảng. Một số cấu trúc dữ liệu khác có thể hỗ trợ các thao tác chèn và xóa hiệu quả hơn nhiều. Tìm kiếm nhị phân có thể được dùng để thực hiện so khớp chính xác và thao tác quan hệ tập hợp (xác định giá trị cần tìm có phải là một tập hợp nhiều giá trị không). Hai bài toán này cũng có thể được thực hiện nhanh hơn trên các cấu trúc dữ liệu khác. Tuy nhiên, khác với các hệ thống tìm kiếm khác, tìm kiếm nhị phân hiệu quả hơn trong phép so khớp xấp xỉ, thường chỉ thực hiện trong {\textstyle O(\log n)} thời gian bất kể kiểu hay cấu trúc của các giá trị. Ngoài ra còn có một số phép toán, như tìm phần tử nhỏ nhất và lớn nhất, có thể được thực hiện hiệu quả trên mảng đã được sắp xếp.

### Tìm kiếm tuyến tính

Tìm kiếm tuyến tính là một thuật toán tìm kiếm đơn giản: nó kiểm tra mọi bản ghi cho tới khi tìm thấy giá trị cần tìm. Tìm kiếm tuyến tính có thể được thực hiện trên danh sách liên kết, cho phép các thao tác chèn và xóa nhanh hơn so với mảng. Tìm kiếm nhị phân nhanh hơn tìm kiếm tuyến tính trên các mảng đã được sắp xếp trừ khi mảng có kích thước nhỏ, mặc dù trước khi tìm kiếm cần phải thực hiện sắp xếp lại mảng trước. Tất cả các thuật toán sắp xếp dựa trên thao tác so sánh các phần tử, như sắp xếp nhanh và sắp xếp trộn, cần ít nhất {\textstyle O(n\log n)} phép so sánh trong trường hợp tệ nhất. Khác với tìm kiếm tuyến tính, tìm kiếm nhị phân có thể được ứng dụng để tìm so khớp xấp xỉ một cách hiệu quả. Một số thao tác như tìm phần tử nhỏ nhất và lớn nhất có thể được thực hiện hiệu quả chỉ khi mảng đã được sắp xếp.

### Cây

Phép tìm kiếm trên cây tìm kiếm nhị phân sử dụng một thuật toán tương tự tìm kiếm nhị phân.
Cây tìm kiếm nhị phân là một cấu trúc dữ liệu dạng cây nhị phân hoạt động dựa trên nguyên lý của tìm kiếm nhị phân. Các bản ghi trong cây được biểu diễn theo thứ tự đã được sắp xếp, và mỗi bản ghi có thể được tìm bằng một thuật toán tương tự tìm kiếm nhị phân, thực hiện trung bình theo thời gian logarit. Các phép chèn và xóa cũng cần trung bình thời gian logarit trong cây tìm kiếm nhị phân. Chúng có thể được thực hiện nhanh hơn so với các thao tác chèn và xóa theo thời gian tuyến tính trên các mảng đã được sắp xếp, đồng thời các thao tác có thể thực hiện trên mảng đã được sắp xếp cũng có thể được thực hiện trên cây nhị phân, bao gồm cả các phép truy vấn khoảng và truy vấn xấp xỉ.

Tuy nhiên, tìm kiếm nhị phân thường hiệu quả hơn trong việc tìm kiếm, do các cây nhị phân hầu như đều không cân bằng tuyệt đối, khiến hiệu suất kém hơn đôi chút so với tìm kiếm nhị phân. Điều này thậm chí vẫn áp dụng với các cây tìm kiếm nhị phân tự cân bằng, vì chúng hiếm khi tạo ra cây có số bậc nhỏ nhất có thể. Ngoại trừ các cây tìm kiếm nhị phân đã cân bằng, việc có quá ít số nút trong có đúng hai nút con có thể khiến cây bị mất cân bằng rất nhiều, khiến thời gian tìm kiếm ở trường hợp trung bình và tệ nhất có thể tiến tới ngưỡng {\textstyle n} phép so sánh. Cây tìm kiếm nhị phân cần nhiều không gian hơn so với mảng đã được sắp xếp.

Cây tìm kiếm nhị phân hữu ích nhất cho việc tìm kiềm nhanh trong các ổ cứng ngoài, bởi cây tìm kiếm nhị phân có thể được dựng hiệu quả trong các hệ thống tập tin. Cấu trúc B-cây tổng quát hóa phương pháp tổ chức cây này. B-cây thường được dùng để tổ chức các ổ lưu trữ dài hạn như cơ sở dữ liệu và hệ thống tập tin.

### Băm

Với các mảng kết hợp, bảng băm, một cấu trúc dữ liệu dùng hàm băm để ánh xạ các khóa thành các bản ghi, thường hoạt động nhanh hơn tìm kiếm nhị phân trên một mảng chứa các bản ghi đã được sắp xếp. Hầu hết các cách triển khai bảng băm chỉ yêu cầu trung bình thời gian hằng số khấu hao. Tuy nhiên, việc băm có thể không hữu ích khi thực hiện các bài toán so khớp xấp xỉ, ví dụ như tính khóa nhỏ nhất tiếp theo, khóa lớn nhất tiếp theo và khóa gần nhất, do khi tìm kiếm thất bại, thông tin duy nhất được đưa ra là giá trị cần tìm không có trong bất cứ bản ghi nào. Tìm kiếm nhị phân là cách làm lý tưởng đối với những bài toán như vậy, khi chỉ thực hiện với thời gian chạy logarit. Tìm kiếm nhị phân cũng hỗ trợ so khớp xấp xỉ. Một số phép toán, như tìm phần tử nhỏ nhất và lớn nhất, có thể được thực hiện hiệu quả trên các mảng đã được sắp xếp, nhưng không thể trên bảng băm.

### Các thuật toán quan hệ tập hợp

Một vấn đề liên quan tới tìm kiếm là quan hệ tập hợp. Bất cứ thuật toán nào thực hiện tra cứu, như tìm kiếm nhị phân, cũng có thể dùng cho quan hệ tập hợp. Một số thuật toán khác được thiết kế phù hợp hơn với quan hệ tập hợp. Mảng bit là cách làm đơn giản nhất, thường được dùng khi số khóa bị giới hạn. Cấu trúc này lưu trữ các bit một cách nhỏ gọn, mỗi bit biểu diễn cho một khóa trong khoảng cho trước. Mảng bit hoạt động rất nhanh, chỉ trong thời gian {\textstyle O(1)}. Một loại mảng Judy là Judy1 có thể xử lý hiệu quả các khóa 64-bit.

Nếu chỉ cần kết quả xấp xỉ, ta có thể sử dụng bộ lọc Bloom, một cấu trúc dữ liệu xác suất khác dựa trên hàm băm, lưu trữ một tập hợp các khóa bằng cách sử dụng một mảng bit và nhiều hàm băm để mã hóa các khóa. Các bộ lọc Bloom chiếm ít không gian hơn nhiều so với các mảng bit trong hầu hết mọi trường hợp và không hoạt động chậm hơn là bao: với {\textstyle k} hàm băm, các phép truy vấn kiểm tra phần tử chỉ cần thời gian {\textstyle O(k)}. Tuy nhiên, sử dụng bộ lọc Bloom có thể đem kết quả dương tính giả.

### Các cấu trúc dữ liệu khác

Còn có các cấu trúc dữ liệu khác có thể cải thiện tìm kiếm nhị phân trong một số trường hợp với cả mục đích tìm kiếm lẫn các thao tác khác có thể được thực hiện trên các mảng đã được sắp xếp. Ví dụ, các phép tìm kiếm, so khớp xấp xỉ và các thao tác khác trên mảng đã được sắp xếp có thể được thực hiện hiệu quả hơn tìm kiếm nhị phân nếu áp dụng trên các cấu trúc dữ liệu chuyên biệt như cây van Emde Boas, fusion trees, trie và mảng bit. Các cấu trúc dữ liệu chuyên biệt này thường chỉ nhanh hơn vì chúng sử dụng các tính chất của những khóa có điều kiện nhất định (thông thường những khóa này là các số nguyên nhỏ), và do đó thời gian chạy hoặc không gian cần sử dụng có thể lớn nếu không đáp ứng được các điều kiện ấy. Với điều kiện có thể sắp xếp được các khóa, các thao tác này luôn luôn có thể được thực hiện hiệu quả trên một mảng đã được sắp xếp trước, không phụ thuộc vào các khóa. Một số cấu trúc như mảng Judy sử dụng kết hợp nhiều phương pháp nhằm đơn giản hóa điều kiện trên, nhưng vẫn giữ được sự hiệu quả và khả năng thực hiện so khớp xấp xỉ.

Biến thể
--------

### Tìm kiếm nhị phân đồng nhất

Bài chi tiết: Tìm kiếm nhị phân đồng nhất
Tìm kiếm nhị phân đồng nhất lưu khoảng cách giữa phần tử giữa hiện tại và hai phần tử giữa ở các vòng lặp tiếp theo thay vì sử dụng các giới hạn cụ thể.
Thay vì lưu các giới hạn trên và dưới, tìm kiếm nhị phân đồng nhất lưu khoảng cách về chỉ số của phần tử đứng giữa ở vòng lặp này với vòng lặp tiếp theo. Thuật toán sẽ lập một bảng dò tìm (*lookup table*) chứa các khoảng cách này. Ví dụ, nếu mảng cần tìm là [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], phần tử giữa (m) sẽ là 6. Trong trường hợp này, phần tử giữa của mảng con bên trái ([1, 2, 3, 4, 5]) là 3 và phần tử giữa của mảng con bên phải ([7, 8, 9, 10, 11]) là 9. Thuật toán sẽ lưu giá trị 3, chính là khoảng cách từ hai chỉ số con trên tới phần tử giữa ban đầu là 6. Để giảm không gian tìm kiếm, thuật toán sẽ cộng thêm hoặc trừ bớt lượng thay đổi này so với chỉ số của phần tử đứng giữa. Tìm kiếm nhị phân đồng nhất có thể chạy nhanh hơn trên các hệ thống không có khả năng tính được điểm giữa một cách hiệu quả, như trên các máy tính thập phân.

### Tìm kiếm mũ

Bài chi tiết: Tìm kiếm mũ
Minh họa thuật toán tìm kiếm mũ tìm giới hạn trên để thực hiện tìm kiếm nhị phân
Tìm kiếm mũ là thuật toán mở rộng của tìm kiếm nhị phân với các danh sách không có giới hạn. Thuật toán bắt đầu bằng việc tìm phần tử đầu tiên có chỉ số là một lũy thừa của hai và đồng thời có giá trị lớn hơn giá trị cần tìm. Sau đó, chỉ số này sẽ được đặt làm giới hạn trên, và quá trình tìm kiếm tiếp tục dưới dạng tìm kiếm nhị phân. Một lần tìm kiếm thực hiện {\textstyle \lfloor \log \_{2}x+1\rfloor } phép lặp trước khi bắt đầu tìm kiếm nhị phân, cộng thêm nhiều nhất {\textstyle \lfloor \log \_{2}x\rfloor } phép lặp khi thực hiện tìm kiếm nhị phân, trong đó {\textstyle x} là vị trí của giá trị cần tìm. Tìm kiếm mũ cũng hoạt động với các danh sách có giới hạn, nhưng chỉ hiệu quả hơn tìm kiếm nhị phân khi giá trị cần tìm nằm gần đầu mảng.

### Tìm kiếm nội suy

Bài chi tiết: Tìm kiếm nội suy
Minh họa thuật toán tìm kiếm nội suy sử dụng nội suy tuyến tính. Trong trường hợp này, việc tìm kiếm không cần thực hiện nữa do vị trí ước lượng của giá trị cần tìm trong mảng đã chính xác. Các cách áp dụng khác có thể dùng một hàm khác để ước lượng vị trí của giá trị cần tìm.
Thay vì tính điểm giữa, tìm kiếm nội suy ước lượng vị trí của giá trị cần tìm dựa vào các phần tử lớn nhất, nhỏ nhất và kích thước của mảng. Thuật toán này hoạt động dựa trên thực tế rằng trong nhiều trường hợp, vị trí đứng giữa có thể không phải vị trí ước lượng tốt nhất. Ví dụ, nếu giá trị cần tìm nằm gần với phần tử lớn nhất trong mảng, nhiều khả năng nó sẽ nằm ở cuối mảng.

Một loại hàm nội suy thường được sử dụng là nội suy tuyến tính. Nếu A là mảng cần tìm, {\displaystyle L,R} lần lượt là các giới hạn dưới và trên, và T là giá trị cần tìm, thì giá trị cần tìm được ước lượng nằm ở khoảng {\displaystyle (T-A\_{L})/(A\_{R}-A\_{L})} khoảng cách giữa L và R. Khi áp dụng nội suy tuyến tính, and the distribution of the array elements is uniform or near uniform, tìm kiếm nội suy thực hiện {\textstyle O(\log \log n)} phép so sánh.

Trong thực tế, tìm kiếm nội suy chạy chậm hơn tìm kiếm nhị phân đối với các mảng nhỏ, do tìm kiếm nội suy cần nhiều tính toán hơn. Độ phức tạp thời gian của thuật toán này tăng chậm hơn so với tìm kiếm nhị phân, nhưng chỉ bù đắp được cho phần tính toán cộng thêm khi mảng có kích thước lớn.

### Đổ xuống một phần

Bài chi tiết: Đổ xuống một phần
Trong đổ xuống một phần, mỗi mảng chứa các con trỏ trỏ tới mỗi phần tử thứ hai của một mảng khác, do đó chỉ cần thực hiện một lần tìm kiếm nhị phân để tìm trong tất cả các mảng.
Đổ xuống một phần là kỹ thuật nhằm làm tăng tốc tìm kiếm nhị phân với cùng một giá trị trong nhiều mảng khác nhau đã được sắp xếp. Nếu thực hiện tìm từng mảng tách riêng nhau ta phải cần {\textstyle O(k\log n)} thời gian, trong đó {\textstyle k} là số mảng. Phương pháp đổ xuống một phần làm giảm con số này xuống còn {\textstyle O(k+\log n)} bằng cách lưu các thông tin cụ thể ở mỗi mảng về mỗi phần tử và vị trí của chúng ở các mảng khác.

Phương pháp đổ xuống một phần ban đầu được phát triển để giải quyết các bài toán trong hình học tính toán. Phương pháp này đã được áp dụng trong nhiều lĩnh vực khác, như khai phá dữ liệu và định tuyến giao thức Internet.

### Tổng quát với đồ thị

Tìm kiếm nhị phân đã được tổng quát để hoạt động với một số loại đồ thị, trong đó giá trị cần tìm được lưu trong một đỉnh thay vì phần tử của một mảng. Cây tìm kiếm nhị phân chính là một trong số những cách tổng quát đó—khi một đỉnh (nút) trong cây được truy vấn, thuật toán sẽ xác định hoặc là đỉnh đó chính là giá trị cần tìm, hoặc đi tìm cây con có giá trị cần tìm. Quá trình này còn có thể khái quát hơn nữa như sau: cho một đồ thị vô hướng, trọng số dương và một đỉnh cần tìm, khi truy vấn một đỉnh, thuật toán sẽ xác định hoặc đỉnh đó bằng đỉnh cần tìm, hoặc tìm được cạnh kề nằm trong đường đi ngắn nhất từ đỉnh đang xét đến đỉnh cần tìm. Thuật toán tìm kiếm nhị phân tiêu chuẩn là trường hợp đặc biệt khi đồ thị chỉ là một đường đi. Tương tự, các cây tìm kiếm nhị phân là trường hợp mà các cạnh thuộc cây con bên trái hoặc bên phải được tìm ra nếu đỉnh được truy vấn không bằng đỉnh cần tìm. Với mọi đồ thị vô hướng có trọng số dương, luôn tồn tại một thuật toán có thể tìm ra một đỉnh cho trước trong O(\log n) phép truy vấn ở trường hợp tệ nhất.

### Tìm kiếm nhị phân nhiễu

Trong tìm kiếm nhị phân nhiễu, chắc chắn tồn tại xác suất phép so sánh cho kết quả sai.
Các thuật toán tìm kiếm nhị phân nhiễu (*noisy binary search*) có thể giải quyết các trường hợp mà thuật toán không thể so sánh chính xác các phần tử trong mảng. Ở mỗi cặp phần tử đều tồn tại một xác suất nhất định rằng thuật toán thực hiện sai phép so sánh. Tìm kiếm nhị phân nhiễu có thể tìm vị trí chính xác của giá trị cần tìm với một xác suất cho trước, nhằm kiểm soát độ chính xác của kết quả. Mỗi lần tìm kiếm nhị phân nhiễu phải thực hiện trung bình ít nhất {\displaystyle (1-\tau ){\frac {\log \_{2}(n)}{H(p)}}-{\frac {10}{H(p)}}} phép so sánh, trong đó {\displaystyle H(p)=-p\log \_{2}(p)-(1-p)\log \_{2}(1-p)} là hàm entropy nhị phân và \tau  là xác suất một lần tìm kiếm cho ra kết quả sai. Bài toán tìm kiếm nhị phân nhiễu có thể được coi là một trường hợp của trò chơi Rényi-Ulam, một biến thể của trò chơi Hai mươi câu hỏi trong đó các câu trả lời có thể sai.

### Tìm kiếm nhị phân lượng tử

Các máy tính cổ điển khi thực hiện tìm kiếm nhị phân bị giới hạn số phép lặp ở mức {\textstyle \lfloor \log \_{2}n+1\rfloor } trong trường hợp tệ nhất. Các thuật toán lượng tử dành cho tìm kiếm nhị phân vẫn chỉ bó buộc trong khoảng {\textstyle \log \_{2}n} phép truy vấn (biểu diễn cho phép lặp trong trường hợp cổ điển), nhưng có hệ số nhỏ hơn một, do đó làm giảm độ phức tạp thời gian trên các máy tính lượng tử. Bất cứ thao tác tìm kiếm nhị phân lượng tử *chính xác* nào—tức là thao tác luôn cho kết quả đúng—cần ít nhất {\textstyle {\frac {1}{\pi }}(\ln n-1)\approx 0.22\log \_{2}n} phép truy vấn ở trường hợp tệ nhất, trong đó {\textstyle \ln } là hàm logarit tự nhiên. Có một phương pháp tìm kiếm nhị phân lượng tử chính xác chạy trong {\textstyle 4\log \_{605}n\approx 0.433\log \_{2}n} phép truy vấn ở trường hợp tệ nhất. So với các thuật toán khác, thuật toán Grover là thuật toán lượng tử tối ưu cho việc tìm kiếm trong một danh sách các phần tử chưa được sắp xếp, với O({\sqrt {n}}) phép truy vấn.

Lịch sử
-------

Ý tưởng về việc sắp xếp một danh sách để tìm kiếm được nhanh hơn đã có từ thời cổ xưa. Ví dụ được biết tới sớm nhất là tấm bảng của Inakibit-Anu từ thời Babylon vào k. 200 TCN. Tấm bảng này chứa khoảng 500 con số ở hệ thập lục phân và các số nghịch đảo của chúng được sắp xếp theo thứ tự từ điển, khiến việc tìm kiếm dễ dàng hơn. Ngoài ra trên Quần đảo Aegean còn phát hiện được một vài danh sách những cái tên được sắp xếp theo chữ cái đầu tiên. *Catholicon*, một cuốn từ điển Latin được hoàn thành vào năm 1286 SCN, là tác phẩm đầu tiên mô tả các quy tắc sắp xếp các từ theo thứ tự bảng chữ cái, thay vì chỉ theo vài ký tự đầu tiên.

Vào năm 1946, John Mauchly là người đầu tiên nhắc tới tìm kiếm nhị phân trong *Moore School Lectures*, một khóa học về máy tính tại Trường Kỹ thuật Điện tử Moore, Đại học Pennsylvania. Năm 1957, William Wesley Peterson xuất bản phương pháp đầu tiên cho giải thuật tìm kiếm nội suy. Mọi thuật toán tìm kiếm nhị phân đã được xuất bản chỉ hoạt động với các mảng có độ dài ở dạng {\displaystyle 2^{\alpha }-1} cho tới năm 1960, khi Derrick Henry Lehmer cho xuất bản một thuật toán tìm kiếm nhị phân có thể hoạt động với mọi mảng. Năm 1962, Hermann Bottenbruch trình bày thuật toán tìm kiếm nhị phân được áp dụng bằng ngôn ngữ ALGOL 60, trong đó bước kiểm tra phần tử giữa được đưa xuống cuối, làm tăng số phép lặp trung bình thêm một, nhưng giảm được một bước so sánh mỗi phép lặp. Thuật toán uniform binary search được phát triển bởi A. K. Chandra tại Đại học Stanford vào năm 1971. Năm 1986, Bernard Chazelle và Leonidas J. Guibas giới thiệu phương pháp đổ xuống một phần (*fractional cascading*) nhằm giải quyết nhiều vấn đề về tìm kiếm trong hình học tính toán.

Thư viện hỗ trợ
---------------

Nhiều thư viện chuẩn của các ngôn ngữ có các chương trình con thực hiện tìm kiếm nhị phân:

* C cung cấp hàm `bsearch()` trong thư viện chuẩn, thường được triển khai bằng tìm kiếm nhị phân, mặc dù tiêu chuẩn chính thức không yêu cầu.
* Standard Template Library của C++ cung cấp các hàm `binary_search()`, `lower_bound()`, `upper_bound()` và `equal_range()`.
* COBOL cung cấp động từ `SEARCH ALL` có chức năng thực hiện tìm kiếm nhị phân trên các bảng được sắp xếp trong COBOL.
* Gói thư viện chuẩn `sort` của Go cung cấp các hàm `Search`, `SearchInts`, `SearchFloat64s`, và `SearchStrings`, lần lượt có chức năng thực hiện tìm kiếm nhị phân tổng quát, tìm kiếm các lát số nguyên, số thập phân dấu phẩy động và chuỗi ký tự.
* Java cung cấp một bộ các phương thức static chồng `binarySearch()` trong các lớp `Arrays` và `Collections` chứa trong gói `java.util` chuẩn, lần lượt có chức năng thực hiện tìm kiếm nhị phân trên các mảng trong Java và trên các `List`.
* Microsoft's .NET Framework 2.0 cung cấp các phiên bản static tổng quát của thuật toán tìm kiếm nhị phân trong các lớp collection base. Ví dụ như phương thức `BinarySearch<T>(T[] array, T value)` trong `System.Array`
* Với Objective-C, framework Cocoa cung cấp phương thức `NSArray -indexOfObject:inSortedRange:options:usingComparator:` trong Mac OS X từ bản 10.6 trở lên. Framework Core Foundation C của Apple cũng chứa hàm `CFArrayBSearchValues()`.
* Python cung cấp mô đun `bisect`.
* Lớp Array của Ruby có chứa phương thức `bsearch` có cả chức năng so khớp xấp xỉ.

Ghi chú và tham khảo
--------------------

### Ghi chú

1. ↑  Bất cứ thuật toán tìm kiếm nào chỉ dựa trên các phép so sánh có thể được biểu diễn bằng cây so sánh nhị phân. *Đường đi trong* (*internal path*) là bất kỳ đường nào đi từ gốc tới một nút có sẵn. Gọi I là *độ dài đường đi trong* (*internal path length*), hay tổng độ dài tất cả các đường đi trong của cây. Nếu mỗi phần tử có xác suất được tìm như nhau, trường hợp trung bình là {\displaystyle 1+{\frac {I}{n}}}, hoặc đơn giản hơn là một cộng với trung bình toàn bộ độ dài các đường đi trong trong cây. Nguyên nhân là do các đường đi trong biểu diễn các phần tử mà thuật toán tìm kiếm tiến hành so sánh với giá trị cần tìm. Độ dài của các đường này biểu diễn số phép lặp *sau* nút gốc. Làm phép cộng trung bình tổng độ dài các đường này với thêm một phép lặp nữa ở nút gốc sẽ ra trường hợp trung bình. Do đó, để giảm tối đa số phép so sánh trung bình, cần phải giảm độ dài đường đi trong I. Thực chất cây biểu diễn tìm kiếm nhị phân đã giảm tối đa độ dài đường đi trong. Knuth 1998 chứng minh được rằng độ dài *đường đi ngoài* (*external path* - the path length over all nodes where both children are present for each already-existing node) được giảm tối đa khi các nút ngoài (các nút không có nút con) nằm trong hai bậc liên tiếp của cây. Điều này cũng áp dụng với các đường đi trong do độ dài đường đi trong I có liên hệ tuyến tính với độ dài đường đi ngoài E. Với mỗi cây có n nút, {\displaystyle I=E-2n}. Khi mỗi cây con có số nút bằng nhau, tương đương với khi mảng được chia thành hai nửa ở mỗi phép lặp, các nút ngoài và các nút cha phía trong của chúng nằm trong vòng hai bậc. Như vậy, thuật toán tìm kiếm nhị phân đã giảm được tối đa số phép so sánh trung bình do cây so sánh của thuật toán này có độ dài đường trong nhỏ nhất.
2. ↑  Knuth 1998 cho thấy trên mẫu máy tính MIX của ông, được Knuth thiết kế để biểu diễn cho một chiếc máy tính thông thường, rằng thời gian chạy trung bình của cách làm này cho một lần tìm thành công là {\textstyle 17.5\log \_{2}n+17} đơn vị thời gian so với {\textstyle 18\log \_{2}n-16} đơn vị với tìm kiếm nhị phân thông thường. Độ phức tạp thời gian của cách làm này tăng nhẹ ở tốc độ chậm hơn, nhưng độ phức tạp ban đầu lớn hơn.
3. ↑  Knuth 1998 đã thực hiện phân tích hiệu suất thời gian của cả hai thuật toán tìm kiếm này. Trên chiếc máy tính MIX của Knuth, được ông thiết kế để biểu diễn cho một chiếc máy tính thông thường, tìm kiếm nhị phân trung bình mất {\textstyle 18\log n-16} đơn vị thời gian cho một lần tìm kiếm thành công, trong khi tìm kiếm tuyến tính khi có một sentinel node ở cuối danh sách mất {\textstyle 1.75n+8.5-{\frac {n{\text{ mod }}2}{4n}}} đơn vị. Tìm kiếm tuyến tính có độ phức tạp ban đầu thấp hơn do nó chỉ yêu cầu các tính toán tối thiểu, nhưng sau đó nhanh chóng vượt qua tìm kiếm nhị phân về độ phức tạp. Trên máy tính MIX, binary search only outperforms linear search with a sentinel if {\textstyle n>44}.
4. ↑  Đưa các giá trị vào theo thứ tự được sắp xếp hay theo quy luật khóa thấp nhất-cao nhất luân phiên sẽ tạo ra một cây tìm kiếm nhị phân có thời gian tìm kiếm tối đa ở trung bình và tệ nhất.
5. ↑  Một số cách triển khai bảng băm có thể thực hiện tìm kiếm với thời gian hằng số đảm bảo.
6. ↑  This is because simply setting all of the bits which the hash functions point to for a specific key can affect queries for other keys which have a common hash location for one or more of the functions.
7. ↑  Có một số bản cải thiện của bộ lọc Bloom giúp cải thiện độ phức tạp hoặc cho phép thao tác xóa; ví dụ, bộ lọc cuckoo sử dụng cách băm cuckoo nhằm những mục đích trên.
8. ↑  Tức là các mảng có độ dài 1, 3, 7, 15, 31...

### Chú thích

1. ↑  Williams, Jr. Louis F. (ngày 22 tháng 4 năm 1976). *A modification to the half-interval search (binary search) method*. Proceedings of the 14th ACM Southeast Conference. ACM. tr. 95–101. doi:10.1145/503561.503582. Lưu trữ bản gốc ngày 12 tháng 3 năm 2017. Truy cập ngày 29 tháng 6 năm 2018.
2. ↑  Knuth 1998, §6.2.1 ("Searching an ordered table"), subsection "Binary search".
3. ↑  Butterfield & Ngondi 2016, tr. 46.
4. ↑  Cormen và đồng nghiệp 2009, tr. 39.
5. ↑  Weisstein, Eric W. "Binary search" từ MathWorld.
6. 1 2  Flores, Ivan; Madpis, George (ngày 1 tháng 9 năm 1971). "Average binary search length for dense ordered lists". *Communications of the ACM*. **14** (9): 602–603. Bibcode:1985CACM...28...22S. doi:10.1145/362663.362752. ISSN 0001-0782.
7. 1 2  Knuth 1998, §6.2.1 ("Searching an ordered table"), phân mục "Algorithm B".
8. ↑  Knuth 1998, §6.2.1 ("Searching an ordered table"), subsection "Algorithm B".
9. 1 2 3  Bottenbruch, Hermann (ngày 1 tháng 4 năm 1962). "Structure and use of ALGOL 60". *Journal of the ACM*. **9** (2): 161–221. doi:10.1145/321119.321120. ISSN 0004-5411. Procedure is described at p. 214 (§43), titled "Program for Binary Search".
10. 1 2 3 4 5  Knuth 1998, §6.2.1 ("Searching an ordered table"), phân mục "History and bibliography".
11. 1 2  Kasahara & Morishita 2006, tr. 8–9.
12. 1 2 3 4 5 6  Knuth 1998, §6.2.1 ("Searching an ordered table"), phân mục "Further analysis of binary search".
13. ↑  Knuth 1998, §6.2.1 ("Searching an ordered table"), "Theorem B".
14. ↑  Chang 2003, tr. 169.
15. 1 2 3 4 5 6  Knuth 1998, §6.2.1 ("Searching an ordered table"), subsection "Further analysis of binary search".
16. ↑  Shannon, Claude E. (tháng 7 năm 1948). "A Mathematical Theory of Communication". *Bell System Technical Journal*. **27** (3): 379–423. doi:10.1002/j.1538-7305.1948.tb01338.x. hdl:11858/00-001M-0000-002C-4314-2.
17. 1 2 3  Knuth 1997, §2.3.4.5 ("Path length").
18. ↑  Knuth 1998, §6.2.1 ("Searching an ordered table"), phân mục "Exercise 23".
19. ↑  Knuth 1998, §6.2.1 ("Searching an ordered table"), subsection "Exercise 23".
20. ↑  Rolfe, Timothy J. (1997). "Analytic derivation of comparisons in binary search". *ACM SIGNUM Newsletter*. **32** (4): 15–19. doi:10.1145/289251.289255.
21. ↑  Khuong, Paul-Virak; Morin, Pat. "Array Layouts for Comparison-Based Searching". *Journal of Experimental Algorithmics*. **22**. Article 1.3. doi:10.1145/289251.289255.
22. ↑  Knuth 1997, §2.2.2 ("Sequential Allocation").
23. 1 2 3 4  Beame, Paul; Fich, Faith E. (2001). "Optimal bounds for the predecessor problem and related problems". *Journal of Computer and System Sciences*. **65** (1): 38–72. doi:10.1006/jcss.2002.1822.
24. ↑  Sedgewick & Wayne 2011, §3.1, subsection "Rank and selection".
25. ↑  Knuth 1998, Answers to Exercises (§6.2.1) cho "Exercise 5".
26. ↑  Knuth 1998, §6.2.1 ("Searching an ordered table").
27. ↑  Knuth 1998, §5.3.1 ("Minimum-Comparison sorting").
28. ↑  Sedgewick & Wayne 2011, §3.2 ("Ordered symbol tables").
29. ↑  Sedgewick & Wayne 2011, §3.2 ("Binary Search Trees"), subsection "Order-based methods and deletion".
30. ↑  Knuth 1998, §6.2.2 ("Binary tree searching"), phân mục "But what about the worst case?".
31. ↑  Sedgewick & Wayne 2011, §3.5 ("Applications"), "Which symbol-table implementation should I use?".
32. ↑  Knuth 1998, §5.4.9 ("Disks and Drums").
33. ↑  Knuth 1998, §6.2.4 ("Multiway trees").
34. ↑  Knuth 1998, §6.4 ("Hashing").
35. ↑  Knuth 1998, §6.4 ("Hashing"), phân mục "History".
36. ↑  Dietzfelbinger, Martin; Karlin, Anna; Mehlhorn, Kurt; Meyer auf der Heide, Friedhelm; Rohnert, Hans; Tarjan, Robert E. (tháng 8 năm 1994). "Dynamic perfect hashing: upper and lower bounds". *SIAM Journal on Computing*. **23** (4): 738–761. doi:10.1137/S0097539791194094.
37. ↑  Morin, Pat. "Hash tables" (PDF). tr. 1. Truy cập ngày 28 tháng 3 năm 2016.
38. ↑  Knuth 2011, §7.1.3 ("Bitwise Tricks and Techniques").
39. 1 2  Silverstein, Alan, *Judy IV shop manual* (PDF), Hewlett-Packard, tr. 80–81
40. 1 2  Fan, Bin; Andersen, Dave G.; Kaminsky, Michael; Mitzenmacher, Michael D. (2014). *Cuckoo filter: practically better than Bloom*. Proceedings of the 10th ACM International on Conference on Emerging Networking Experiments and Technologies. tr. 75–88. doi:10.1145/2674005.2674994.
41. ↑  Bloom, Burton H. (1970). "Space/time trade-offs in hash coding with allowable errors". *Communications of the ACM*. **13** (7): 422–426. Bibcode:1985CACM...28...22S. CiteSeerX 10.1.1.641.9096. doi:10.1145/362686.362692.
42. ↑  Knuth 1998, §6.2.1 ("Searching an ordered table"), phân mục "An important variation".
43. ↑  Knuth 1998, §6.2.1 ("Searching an ordered table"), subsection "Algorithm U".
44. ↑  Moffat & Turpin 2002, tr. 33.
45. 1 2 3  Knuth 1998, §6.2.1 ("Searching an ordered table"), phân mục "Interpolation search".
46. ↑  Knuth 1998, §6.2.1 ("Searching an ordered table"), phân mục "Exercise 22".
47. ↑  Perl, Yehoshua; Itai, Alon; Avni, Haim (1978). "Interpolation search—a log log *n* search". *Communications of the ACM*. **21** (7): 550–553. Bibcode:1985CACM...28...22S. doi:10.1145/359545.359557.
48. 1 2 3  Chazelle, Bernard; Liu, Ding (ngày 6 tháng 7 năm 2001). *Lower bounds for intersection searching and fractional cascading in higher dimension*. 33rd ACM Symposium on Theory of Computing. ACM. tr. 322–329. doi:10.1145/380752.380818. ISBN 978-1-58113-349-3. Truy cập ngày 30 tháng 6 năm 2018.
49. ↑  Chazelle, Bernard; Liu, Ding (ngày 1 tháng 3 năm 2004). "Lower bounds for intersection searching and fractional cascading in higher dimension" (PDF). *Journal of Computer and System Sciences* (bằng tiếng Anh). **68** (2): 269–284. CiteSeerX 10.1.1.298.7772. doi:10.1016/j.jcss.2003.07.003. ISSN 0022-0000. Truy cập ngày 30 tháng 6 năm 2018.
50. ↑  Emamjomeh-Zadeh, Ehsan; Kempe, David; Singhal, Vikrant (2016). *Deterministic and probabilistic binary search in graphs*. 48th ACM Symposium on Theory of Computing. tr. 519–532. arXiv:1503.00805. doi:10.1145/2897518.2897656.
51. ↑  Ben-Or, Michael; Hassidim, Avinatan (2008). "The Bayesian learner is optimal for noisy binary search (and pretty good for quantum as well)" (PDF). *49th Symposium on Foundations of Computer Science*. tr. 221–230. doi:10.1109/FOCS.2008.58. ISBN 978-0-7695-3436-7.
52. ↑  Pelc, Andrzej (1989). "Searching with known error probability". *Theoretical Computer Science*. **63** (2): 185–202. doi:10.1016/0304-3975(89)90077-7.
53. ↑  Rivest, Ronald L.; Meyer, Albert R.; Kleitman, Daniel J.; Winklmann, K. *Coping with errors in binary search procedures*. 10th ACM Symposium on Theory of Computing. doi:10.1145/800133.804351.
54. ↑  Pelc, Andrzej (2002). "Searching games with errors—fifty years of coping with liars". *Theoretical Computer Science*. **270** (1–2): 71–109. doi:10.1016/S0304-3975(01)00303-6.
55. ↑  Rényi, Alfréd (1961). "On a problem in information theory". *Magyar Tudományos Akadémia Matematikai Kutató Intézetének Közleményei* (bằng tiếng Hungary). **6**: 505–516. MR 0143666.
56. ↑  Høyer, Peter; Neerbek, Jan; Shi, Yaoyun (2002). "Quantum complexities of ordered searching, sorting, and element distinctness". *Algorithmica*. **34** (4): 429–448. arXiv:quant-ph/0102078. doi:10.1007/s00453-002-0976-3.
57. ↑  Childs, Andrew M.; Landahl, Andrew J.; Parrilo, Pablo A. (2007). "Quantum algorithms for the ordered search problem via semidefinite programming". *Physical Review A*. **75** (3). 032335. arXiv:quant-ph/0608161. Bibcode:2007PhRvA..75c2335C. doi:10.1103/PhysRevA.75.032335.
58. ↑  Grover, Lov K. (1996). *A fast quantum mechanical algorithm for database search*. 28th ACM Symposium on Theory of Computing. Philadelphia, PA. tr. 212–219. arXiv:quant-ph/9605043. doi:10.1145/237814.237866.
59. ↑  Knuth 1998, §6.2.1 ("Searching an ordered table"), subsection "History and bibliography".
60. ↑  Peterson, William Wesley (1957). "Addressing for random-access storage". *IBM Journal of Research and Development*. **1** (2): 130–146. doi:10.1147/rd.12.0130.
61. ↑  "2*n*−1". OEIS A000225 Lưu trữ 2016-06-08 tại Wayback Machine. Truy cập ngày 7 tháng 5 năm 2016.
62. ↑  Lehmer, Derrick (1960). *Teaching combinatorial tricks to a computer*. *Proceedings of Symposia in Applied Mathematics*. **10**. tr. 180–181. doi:10.1090/psapm/010.
63. ↑  Chazelle, Bernard; Guibas, Leonidas J. (1986). "Fractional cascading: I. A data structuring technique" (PDF). *Algorithmica*. **1** (1–4): 133–162. CiteSeerX 10.1.1.117.8349. doi:10.1007/BF01840440.
64. ↑  Chazelle, Bernard; Guibas, Leonidas J. (1986), "Fractional cascading: II. Applications" (PDF), *Algorithmica*, **1** (1–4): 163–191, doi:10.1007/BF01840441
65. ↑  "bsearch – binary search a sorted table". *The Open Group Base Specifications* (ấn bản 7). The Open Group. 2013. Lưu trữ bản gốc ngày 21 tháng 3 năm 2016. Truy cập ngày 28 tháng 3 năm 2016.
66. ↑  Stroustrup 2013, tr. 945.
67. ↑  Unisys (2012), *COBOL ANSI-85 programming reference manual*, **1**, tr. 598–601
68. ↑  "Package sort". *The Go Programming Language*. Lưu trữ bản gốc ngày 25 tháng 4 năm 2016. Truy cập ngày 28 tháng 4 năm 2016.
69. ↑  "java.util.Arrays". *Java Platform Standard Edition 8 Documentation*. Oracle Corporation. Lưu trữ bản gốc ngày 29 tháng 4 năm 2016. Truy cập ngày 1 tháng 5 năm 2016.
70. ↑  "java.util.Collections". *Java Platform Standard Edition 8 Documentation*. Oracle Corporation. Lưu trữ bản gốc ngày 23 tháng 4 năm 2016. Truy cập ngày 1 tháng 5 năm 2016.
71. ↑  "List<T>.BinarySearch method (T)". *Microsoft Developer Network*. Lưu trữ bản gốc ngày 7 tháng 5 năm 2016. Truy cập ngày 10 tháng 4 năm 2016.
72. ↑  "NSArray". *Mac Developer Library*. Apple Inc. Lưu trữ bản gốc ngày 17 tháng 4 năm 2016. Truy cập ngày 1 tháng 5 năm 2016.
73. ↑  "CFArray". *Mac Developer Library*. Apple Inc. Lưu trữ bản gốc ngày 20 tháng 4 năm 2016. Truy cập ngày 1 tháng 5 năm 2016.
74. ↑  "8.6. bisect — Array bisection algorithm". *The Python Standard Library*. Python Software Foundation. Lưu trữ bản gốc ngày 25 tháng 3 năm 2018. Truy cập ngày 26 tháng 3 năm 2018.
75. ↑  Fitzgerald 2007, tr. 152.

### Tài liệu

* Bentley, Jon (2000). *Programming pearls* (ấn bản 2). Addison-Wesley. ISBN 978-0-201-65788-3.
* Butterfield, Andrew; Ngondi, Gerard E. (2016). *A dictionary of computer science* (ấn bản 7). Oxford, UK: Oxford University Press. ISBN 978-0-19-968897-5.
* Chang, Shi-Kuo (2003). *Data structures and algorithms*. *Software Engineering and Knowledge Engineering*. **13**. Singapore: World Scientific. ISBN 978-981-238-348-8.
* Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford (2009). *Introduction to algorithms* (ấn bản 3). MIT Press and McGraw-Hill. ISBN 978-0-262-03384-8.
* Fitzgerald, Michael (2007). *Ruby pocket reference*. Sebastopol, California: O'Reilly Media. ISBN 978-1-4919-2601-7.
* Goldman, Sally A.; Goldman, Kenneth J. (2008). *A practical guide to data structures and algorithms using Java*. Boca Raton, Florida: CRC Press. ISBN 978-1-58488-455-2.
* Kasahara, Masahiro; Morishita, Shinichi (2006). *Large-scale genome sequence processing*. London, UK: Imperial College Press. ISBN 978-1-86094-635-6.
* Knuth, Donald (1997). *Fundamental algorithms*. The Art of Computer Programming. **1** (ấn bản 3). Reading, MA: Addison-Wesley Professional. ISBN 978-0-201-89683-1.
* Knuth, Donald (1998). *Sorting and searching*. The Art of Computer Programming. **3** (ấn bản 2). Reading, MA: Addison-Wesley Professional. ISBN 978-0-201-89685-5.
* Knuth, Donald (2011). *Combinatorial algorithms*. The Art of Computer Programming. **4A** (ấn bản 1). Reading, MA: Addison-Wesley Professional. ISBN 978-0-201-03804-0.
* Moffat, Alistair; Turpin, Andrew (2002). *Compression and coding algorithms*. Hamburg, Germany: Kluwer Academic Publishers. doi:10.1007/978-1-4615-0935-6. ISBN 978-0-7923-7668-2.
* Sedgewick, Robert; Wayne, Kevin (2011). *Algorithms* (ấn bản 4). Upper Saddle River, New Jersey: Addison-Wesley Professional. ISBN 978-0-321-57351-3. Condensed web version Ấn phẩm cho phép truy cập mở - đọc miễn phí; book version closed access publication – behind paywall.
* Stroustrup, Bjarne (2013). *The C++ programming language* (ấn bản 4). Upper Saddle River, New Jersey: Addison-Wesley Professional. ISBN 978-0-321-56384-2.