Nhận 100 số cao nhất từ ​​danh sách vô hạn

Một người bạn của tôi đã được hỏi câu hỏi phỏng vấn này -

"Có một dòng số liên tục đến từ một số danh sách số vô hạn mà bạn cần duy trì cơ sở hạ tầng để trả về 100 số cao nhất hàng đầu tại bất kỳ thời điểm nào. Giả sử tất cả các số chỉ là số nguyên."

Điều này rất đơn giản, bạn cần giữ một danh sách được sắp xếp theo thứ tự giảm dần và theo dõi số thấp nhất trong danh sách đó. Nếu số mới thu được lớn hơn số thấp nhất đó thì bạn phải xóa số thấp nhất đó và chèn số mới vào danh sách được sắp xếp theo yêu cầu.

Sau đó, câu hỏi đã được mở rộng -

"Bạn có thể chắc chắn rằng Lệnh chèn phải là O (1) không? Có thể không?"

Theo như tôi biết, ngay cả khi bạn thêm một số mới vào danh sách và sắp xếp lại nó bằng bất kỳ thuật toán sắp xếp nào, thì tốt nhất là O (logn) cho quicksort (tôi nghĩ). Vì vậy, bạn tôi nói rằng nó không thể. Nhưng anh ta không bị thuyết phục, anh ta yêu cầu duy trì bất kỳ cấu trúc dữ liệu nào khác hơn là một danh sách.

Tôi đã nghĩ về cây nhị phân cân bằng, nhưng ngay cả ở đó bạn sẽ không nhận được chèn với thứ tự 1. Vì vậy, câu hỏi tương tự bây giờ tôi cũng có. Muốn biết liệu có bất kỳ cấu trúc dữ liệu nào như vậy có thể chèn vào Thứ tự 1 cho vấn đề trên hay không hoàn toàn có thể.

Giả sử k là số lượng số cao nhất bạn muốn biết (100 trong ví dụ của bạn). Sau đó, bạn có thể thêm một số mới trong O(k)đó cũng có O(1). Bởi vì O(k*g) = O(g) if k is not zero and constant.

Giữ danh sách chưa được sắp xếp. Tìm hiểu xem có nên chèn số mới hay không sẽ mất nhiều thời gian hơn, nhưng việc chèn sẽ là O (1).

Điều này thật dễ dàng. Kích thước của danh sách không đổi, do đó thời gian sắp xếp của danh sách là không đổi. Một hoạt động thực hiện trong thời gian không đổi được gọi là O (1). Do đó, sắp xếp danh sách là O (1) cho danh sách kích thước cố định.

Khi bạn vượt qua 100 số, chi phí tối đa bạn sẽ phải trả cho số tiếp theo là chi phí để kiểm tra xem số đó có nằm trong 100 số cao nhất không (hãy gắn nhãn là CheckTime ) cộng với chi phí để nhập số đó vào bộ đó và đẩy ra mức thấp nhất (hãy gọi là EnterTime ), đó là thời gian không đổi (ít nhất là đối với các số bị chặn) hoặc O (1) .

Worst = CheckTime + EnterTime

Tiếp theo, nếu phân phối số là ngẫu nhiên, chi phí trung bình sẽ giảm số lượng bạn có nhiều hơn. Ví dụ: cơ hội bạn sẽ phải nhập số thứ 101 vào tập tối đa là 100/101, cơ hội cho số thứ 1000 sẽ là 1/10 và cơ hội cho số thứ n sẽ là 100 / n. Do đó, phương trình của chúng tôi cho chi phí trung bình sẽ là:

Average = CheckTime + EnterTime / n

Do đó, khi n tiến đến vô cùng, chỉ có CheckTime là quan trọng:

Average = CheckTime

Nếu các số bị ràng buộc, CheckTime không đổi và do đó là thời gian O (1) .

Nếu các số không bị ràng buộc, thời gian kiểm tra sẽ tăng lên với nhiều số hơn. Về mặt lý thuyết, điều này là do nếu số nhỏ nhất trong tập tối đa đủ lớn, thời gian kiểm tra của bạn sẽ lớn hơn vì bạn sẽ phải xem xét nhiều bit hơn. Điều đó làm cho có vẻ như nó sẽ cao hơn một chút so với thời gian không đổi. Tuy nhiên, bạn cũng có thể lập luận rằng cơ hội số tiếp theo nằm trong tập cao nhất tiến đến 0 khi n tiến đến vô cùng và vì vậy cơ hội bạn sẽ cần xem xét thêm các bit cũng tiến đến 0, đó sẽ là đối số cho O (1) thời gian.

Tôi không tích cực, nhưng ruột của tôi nói rằng đó là thời gian O (log (log (n))) . Điều này là do cơ hội số tăng thấp nhất là logarit và cơ hội số bit bạn cần xem xét cho mỗi lần kiểm tra cũng là logarit. Tôi quan tâm đến những người khác đảm nhận việc này, vì tôi không thực sự chắc chắn ...

Điều này là dễ dàng nếu bạn biết Cây nhị phân nhị phân . Các đống nhị phân hỗ trợ chèn trong thời gian trung bình không đổi, O (1). Và cung cấp cho bạn dễ dàng truy cập vào các yếu tố x đầu tiên.

Nếu bằng câu hỏi mà người phỏng vấn thực sự muốn hỏi, chúng ta có thể đảm bảo rằng mỗi số đến được xử lý theo thời gian không đổi, thì như nhiều người đã chỉ ra (ví dụ: xem câu trả lời của @ duedl0r), giải pháp của bạn của bạn đã là O (1) và nó sẽ là như vậy ngay cả khi anh ta đã sử dụng danh sách chưa sắp xếp, hoặc sử dụng sắp xếp bong bóng, hoặc bất cứ điều gì khác. Trong trường hợp này, câu hỏi không có nhiều ý nghĩa, trừ khi đó là câu hỏi khó hoặc bạn nhớ sai.

Tôi cho rằng câu hỏi của người phỏng vấn là có ý nghĩa, rằng anh ta không hỏi làm thế nào để biến một cái gì đó thành O (1) mà rõ ràng là như vậy.

Bởi vì độ phức tạp của thuật toán đặt câu hỏi chỉ có ý nghĩa khi kích thước của đầu vào tăng vô hạn và đầu vào duy nhất có thể phát triển ở đây là 100 kích thước danh sách; Tôi cho rằng câu hỏi thực sự là chúng tôi có thể đảm bảo rằng chúng tôi nhận được Top N dành O (1) thời gian cho mỗi số (không phải O (N) như trong giải pháp của bạn bè bạn không?

Điều đầu tiên bạn nghĩ đến là tính sắp xếp, sẽ mua độ phức tạp của thời gian O (1) cho mỗi số cho bài toán Top-N cho giá sử dụng không gian O (m), trong đó m là độ dài của phạm vi số đến . Vì vậy, có, nó là có thể.

Sử dụng hàng đợi ưu tiên tối thiểu được triển khai với một đống Fibonacci , có thời gian chèn không đổi:

1. Insert first 100 elements into PQ
2. loop forever
       n = getNextNumber();
       if n > PQ.findMin() then
           PQ.deleteMin()
           PQ.insert(n)

Nhiệm vụ rõ ràng là tìm một thuật toán có O (1) theo độ dài N của danh sách các số cần thiết. Vì vậy, không có vấn đề gì nếu bạn cần 100 số hàng đầu hoặc 10000 số, thời gian chèn phải là O (1).

Mẹo ở đây là mặc dù yêu cầu O (1) được đề cập cho phần chèn danh sách, câu hỏi không nói gì về thứ tự thời gian tìm kiếm trong toàn bộ không gian số, nhưng hóa ra điều này có thể được thực hiện O (1) cũng. Giải pháp sau đó là như sau:

1. Sắp xếp một hashtable với các số cho các khóa và các cặp con trỏ danh sách được liên kết cho các giá trị. Mỗi cặp con trỏ là điểm bắt đầu và kết thúc của chuỗi danh sách được liên kết. Điều này thường sẽ chỉ là một yếu tố sau đó tiếp theo. Mỗi phần tử trong danh sách được liên kết đi bên cạnh phần tử có số cao nhất tiếp theo. Do đó, danh sách được liên kết chứa chuỗi các số được yêu cầu sắp xếp. Giữ một bản ghi của số thấp nhất.

2. Lấy một số mới x từ luồng ngẫu nhiên.

3. Có cao hơn con số thấp nhất được ghi nhận cuối cùng không? Có => Bước 4, Không => Bước 2

4. Nhấn bảng băm với số vừa lấy. Có một mục? Có => Bước 5. Không => Lấy số mới x-1 và lặp lại bước này (đây là một tìm kiếm tuyến tính đi xuống đơn giản, chỉ cần chịu đựng ở đây, điều này có thể được cải thiện và tôi sẽ giải thích làm thế nào)

5. Với phần tử danh sách vừa thu được từ bảng băm, hãy chèn số mới ngay sau phần tử trong danh sách được liên kết (và cập nhật hàm băm)

6. Lấy số l thấp nhất được ghi lại (và xóa nó khỏi hàm băm / danh sách).

7. Nhấn bảng băm với số vừa lấy. Có một mục? Có => Bước 8. Không => Lấy số mới l + 1 và lặp lại bước này (đây là một tìm kiếm tuyến tính đi lên đơn giản)

8. Với một hit tích cực, số trở thành số thấp nhất mới. Chuyển đến bước 2

Để cho phép các giá trị trùng lặp, hàm băm thực sự cần duy trì bắt đầu và kết thúc chuỗi danh sách được liên kết của các phần tử được sao chép. Thêm hoặc xóa một phần tử tại một khóa đã cho, do đó làm tăng hoặc giảm phạm vi được trỏ đến.

Chèn ở đây là O (1). Các tìm kiếm được đề cập là, tôi đoán một cái gì đó như, O (chênh lệch trung bình giữa các số). Sự khác biệt trung bình tăng theo kích thước của không gian số, nhưng giảm theo độ dài cần thiết của danh sách các số.

Vì vậy, chiến lược tìm kiếm tuyến tính khá kém, nếu không gian số lớn (ví dụ: đối với loại int 4 byte, 0 đến 2 ^ 32-1) và N = 100. Để giải quyết vấn đề về hiệu suất này, bạn có thể giữ các bộ hashtables song song, trong đó các số được làm tròn đến cường độ cao hơn (ví dụ 1, 10, 100, 1000) để tạo các khóa phù hợp. Bằng cách này, bạn có thể bước lên và xuống bánh răng để thực hiện các tìm kiếm cần thiết nhanh hơn. Hiệu suất sau đó trở thành một O (log numberrange), tôi nghĩ, không đổi, tức là O (1) cũng vậy.

Để làm cho điều này rõ ràng hơn, hãy tưởng tượng rằng bạn có số 197 trong tay. Bạn nhấn bảng băm 10 giây, với '190', nó được làm tròn đến mười điểm gần nhất. Có gì không Không. Vì vậy, bạn đi xuống sau 10 giây cho đến khi bạn nhấn 120. Sau đó, bạn có thể bắt đầu ở 129 trong hashtable 1s, sau đó thử 128, 127 cho đến khi bạn đạt được điều gì đó. Bây giờ bạn đã tìm thấy vị trí trong danh sách được liên kết để chèn số 197. Trong khi đưa nó vào, bạn cũng phải cập nhật hashtable 1s với mục 197, hashtable 10s với số 190, 100 với 100, v.v. bạn phải làm ở đây gấp 10 lần nhật ký của dãy số.

Tôi có thể đã có một số chi tiết sai, nhưng vì đây là trao đổi của các lập trình viên, và bối cảnh là các cuộc phỏng vấn, tôi hy vọng những điều trên là một câu trả lời đủ thuyết phục cho tình huống đó.

EDIT Tôi đã thêm một số chi tiết bổ sung ở đây để giải thích sơ đồ băm song song và ý nghĩa của các tìm kiếm tuyến tính kém mà tôi đã đề cập có thể được thay thế bằng tìm kiếm O (1). Tất nhiên tôi cũng nhận ra rằng không cần phải tìm kiếm số thấp nhất tiếp theo, bởi vì bạn có thể bước thẳng tới nó bằng cách tìm trong hàm băm với số thấp nhất và chuyển sang phần tử tiếp theo.

Chúng ta có thể giả sử rằng các số có kiểu dữ liệu cố định, chẳng hạn như Integer không? Nếu vậy, sau đó giữ một kiểm đếm của mỗi số được thêm vào. Đây là một hoạt động O (1).

1. Khai báo một mảng có càng nhiều phần tử càng tốt:
2. Đọc từng số khi nó được truyền phát.
3. Kiểm đếm số lượng. Bỏ qua nó nếu con số đó đã được tính 100 lần vì bạn sẽ không bao giờ cần đến nó. Điều này ngăn chặn tràn ra kiểm đếm nó vô số lần.
4. Lặp lại từ bước 2.

Mã VB.Net:

Const Capacity As Integer = 100

Dim Tally(Integer.MaxValue) As Integer ' Assume all elements = 0
Do
    Value = ReadValue()
    If Tally(Value) < Capacity Then Tally(Value) += 1
Loop

Khi bạn trả lại danh sách, bạn có thể mất bao lâu tùy thích. Chỉ cần lặp lại từ cuối danh sách và tạo một danh sách mới gồm 100 giá trị cao nhất được ghi lại. Đây là một hoạt động O (n), nhưng điều đó không liên quan.

Dim List(Capacity) As Integer
Dim ListCount As Integer = 0
Dim Value As Integer = Tally.Length - 1
Dim ValueCount As Integer = 0
Do Until ListCount = List.Length OrElse Value < 0
    If Tally(Value) > ValueCount Then
        List(ListCount) = Value
        ValueCount += 1
        ListCount += 1
    Else
        Value -= 1
        ValueCount = 0
    End If
Loop
Return List

Chỉnh sửa: Trên thực tế, nó không thực sự quan trọng nếu đó là loại dữ liệu cố định. Do không có giới hạn áp đặt đối với mức tiêu thụ bộ nhớ (hoặc đĩa cứng), bạn có thể thực hiện công việc này cho bất kỳ phạm vi số nguyên dương nào.

Một trăm số được lưu trữ dễ dàng trong một mảng, kích thước 100. Bất kỳ cây, danh sách hoặc tập hợp nào đều quá mức, được giao nhiệm vụ trong tay.

Nếu số đến cao hơn mức thấp nhất (= cuối cùng) trong mảng, hãy chạy qua tất cả các mục. Khi bạn tìm thấy số đầu tiên nhỏ hơn số mới của mình (bạn có thể sử dụng các tìm kiếm ưa thích để làm điều đó), hãy chạy qua phần còn lại của mảng, đẩy từng mục "xuống" một.

Vì bạn giữ danh sách được sắp xếp từ đầu, bạn không cần phải chạy bất kỳ thuật toán sắp xếp nào cả. Đây là O (1).

Bạn có thể sử dụng Binary Max-Heap. Bạn sẽ phải theo dõi một con trỏ đến nút tối thiểu (có thể không xác định / null).

Bạn bắt đầu bằng cách chèn 100 số đầu tiên vào heap. Tối đa sẽ ở trên cùng. Sau khi hoàn thành, bạn sẽ luôn giữ 100 số trong đó.

Sau đó, khi bạn nhận được một số mới:

if(minimumNode == null)
{
    minimumNode = findMinimumNode();
}
if(newNumber > minimumNode.Value)
{
    heap.Remove(minimumNode);
    minimumNode = null;
    heap.Insert(newNumber);
}

Thật không may findMinimumNodelà O (n) và bạn phải chịu chi phí đó một lần cho mỗi lần chèn (nhưng không phải trong quá trình chèn :). Trung bình loại bỏ nút tối thiểu và chèn nút mới, trung bình là O (1) vì chúng sẽ có xu hướng về phía dưới của heap.

Đi theo một cách khác với Heap Mininary Heap, min ở trên cùng, rất phù hợp để tìm min để so sánh, nhưng thật tệ khi bạn phải thay thế tối thiểu bằng một số mới> min. Đó là bởi vì bạn phải loại bỏ nút min (luôn là O (logN)) và sau đó chèn nút mới (trung bình O (1)). Vì vậy, bạn vẫn có O (logN) tốt hơn Max-Heap, nhưng không có O (1).

Tất nhiên, nếu N không đổi, thì bạn luôn có O (1). :)