Tần số từ với độ phức tạp trong O (n)

Trong một cuộc phỏng vấn cho vị trí nhà phát triển Java, tôi đã được hỏi như sau:

Viết hàm có hai tham số:

1. Chuỗi đại diện cho một tài liệu văn bản và
2. một số nguyên cung cấp số lượng các mặt hàng để trả lại.

Thực hiện chức năng sao cho nó trả về một danh sách các Chuỗi được sắp xếp theo tần số từ, từ xuất hiện thường xuyên nhất trước tiên. Giải pháp của bạn sẽ chạy trong thời gian trong đó là số lượng ký tự trong tài liệu.$O(n)$$n$

Sau đây là những gì tôi đã trả lời (bằng mã giả), đó không phải là thời gian mà là vì sắp xếp. Tôi không thể tìm ra làm thế nào để làm điều đó thời gian. O ( n log n ) O ( n $O(n)$$O(n \log n)$$O(n)$

wordFrequencyMap = new HashMap<String, Integer>();
words = inputString.split(' ');

for (String word : words) {
  count = wordFrequencyMap.get(word);
  count = (count == null) ? 1 : ++count;
  wordFrequencyMap.put(word, count);
}

return wordFrequencyMap.sortByValue.keys

Có ai biết hoặc ai đó có thể cho tôi một số gợi ý?

Tôi đề nghị một biến thể của đếm phân phối:

1. Đọc văn bản và chèn tất cả các từ gặp phải vào một Trie , duy trì trong mỗi nút đếm, từ đại diện bởi nút này đã xảy ra như thế nào thường xuyên. Ngoài ra theo dõi số lượng từ cao nhất nói maxWordCound. - $O(n)$
2. Khởi tạo một mảng kích thước maxWordCount. Kiểu nhập là danh sách các chuỗi. - , vì số lượng không thể cao hơn.$O(n)$
3. Di chuyển qua bộ ba và cho mỗi nút thêm chuỗi tương ứng vào mục nhập mảng được chỉ định bởi số đếm. - , vì tổng chiều dài của chuỗi được giới hạn bởi n .$O(n)$$n$
4. Di chuyển mảng theo thứ tự giảm dần và xuất ra số chuỗi mong muốn. - , vì đó là một ràng buộc về cả kích thước và lượng dữ liệu trong mảng.$O(n)$

Bạn có thể có thể thay thế trie bằng các cấu trúc dữ liệu khác trong giai đoạn đầu tiên.

Tập hợp số lần xuất hiện là O (n), vì vậy mẹo thực sự chỉ là tìm số lần xuất hiện k hàng đầu.

Heap là một cách phổ biến để tổng hợp các giá trị k hàng đầu, mặc dù các phương pháp khác có thể được sử dụng (xem https://en.wikipedia.org/wiki/Partial_sorting ).

Giả sử k là tham số thứ hai ở trên và đó là hằng số trong báo cáo vấn đề (có vẻ như vậy):

1. Xây dựng một bộ ba từ với số lần xuất hiện trên mỗi nút.
2. Khởi tạo một đống kích thước k.
3. Di chuyển ngang qua trie và min-thăm dò / chèn từng cặp (lá, số lần xuất hiện) trong heap top-k.
4. Xuất ra k lá và số đếm trên cùng (đây thực sự là một nỗi đau vì bạn cần con trỏ cha mẹ để ánh xạ mỗi lá trở lại một từ).

Vì kích thước heap là một hằng số, các hoạt động của heap là O (1), vì vậy bước 3 là O (n).

Heap cũng có thể được duy trì linh hoạt trong khi xây dựng bộ ba.

Thuật toán của bạn thậm chí không chạy trong thời gian ; chèn Θ ( n ) điều trong một chi phí Hashtable thời gian Ω ( n 2 ) đã (trường hợp xấu nhất).$O(n \log n)$$\Theta(n)$$\Omega(n^2)$

Điều gì sau là sai ; Tôi để nó ở đây trong thời gian này là cho mục đích minh họa.

Chạy sau thuật toán trong trường hợp xấu nhất thời gian (giả sử một bảng chữ cái Σ kích thước không đổi), n là số ký tự trong văn bản.$O(n)$$\Sigma$$n$

1. Xây dựng một cây hậu tố của văn bản, ví dụ với thuật toán của Ukkonen .

   Nếu việc xây dựng chưa làm điều này, hãy thêm số lượng lá có thể tiếp cận vào mỗi nút (bên trong).

2. Đi qua cây từ gốc và cắt tất cả các nhánh ở khoảng trống (màu trắng) đầu tiên.

3. Đi qua cây và sắp xếp danh sách con của mỗi nút theo số lá của chúng.

4. Năng suất của cây (lá từ trái sang phải) hiện là danh sách tất cả các từ, được sắp xếp theo tần số.

Về thời gian chạy:

1. Thuật toán của Ukkonen (ở dạng nâng cao) chạy trong thời gian ; duy trì đếm lá không làm tăng Θ -cost của thuật toán.$O(n)$$\Theta$
2. Chúng ta phải duyệt qua một nút trên mỗi ký tự của mỗi từ xuất hiện trong văn bản. Vì có nhiều nhất cặp từ-ký tự khác nhau, chúng tôi truy cập vào tối đa n nút.$n$$n$
3. Chúng tôi ghé thăm nhiều nhất là lần chi tiêu hạch (cf 2.) và O ( | Σ | ⋅ log | Σ | ) = O ( 1 ) mỗi node.$n$$O(|\Sigma| \cdot \log |\Sigma|) = O(1)$
4. Chúng ta có thể thu được sản lượng (có kích thước khóa học ) bằng cách di chuyển đơn giản trong thời gian O ( n ) (cf 2.).$O(n)$$O(n)$

Giới hạn chính xác hơn có thể thu được bằng thời gian chạy tham số với số lượng từ khác nhau; nếu có ít thì cây nhỏ sau 2.

Sử dụng bảng băm (ví dụ HashMap:) để thu thập tất cả các từ và tần số của chúng. Sau đó, sử dụng sắp xếp đếm để sắp xếp các từ theo thứ tự tần số giảm dần. Vì tất cả các tần số là số nguyên trong phạm vi , nên việc sắp xếp sẽ mất thời gian O ( n ) . Tổng thời gian chạy dự kiến ​​là O ( n ) , nhiều hơn có thể là quá đủ cho tất cả các mục đích thực tế (trừ khi người phỏng vấn đề cập đến một cái gì đó bị bỏ qua câu hỏi của bạn). Hãy chắc chắn đề cập rằng đây là thời gian chạy dự kiến thay vì thời gian chạy trong trường hợp xấu nhất .$1..n$$O(n)$$O(n)$

$O(n)$$O(n)$$O(n)$

$O(n)$$O(n)$

Giải pháp dựa trên Hashtable

$\Omega(n^2)$$n$

$n$$\Omega(n)$

$O(1)$$O(n)$$O(n^2)$$n$

Giả định là thuật toán băm là tuyến tính theo thời gian liên quan đến số lượng ký tự.

Giải pháp dựa trên cơ sở sắp xếp

$O(kN)$$k$$N$$n$$k$$O(n)$

$2n$$n$$O(n)$

Một vài từ dài nhất trong tiếng Anh dài một cách lố bịch , nhưng sau đó người ta có thể giới hạn độ dài từ ở một số hợp lý (chẳng hạn như 30 hoặc nhỏ hơn) và cắt ngắn các từ chấp nhận lề lỗi có thể đi kèm với nó.