Sắp xếp danh sách các chuỗi theo thứ tự từ điển của các chuỗi được sắp xếp

Đặt là tập hợp các chuỗi trên bảng chữ cái có tổng số ký hiệu.$A$$\{0,\ldots,m-1\}$$n$

Nhiệm vụ của bạn là sắp xếp từng chuỗi bên trong, sau đó sắp xếp các chuỗi kết quả theo thứ tự từ điển. (Thuật toán của bạn không phải vận hành theo cách này.)

Thí dụ:

Đầu vào: 33123 15 1 0 54215 21 12

Đầu ra: 0 1 12 12 12333 12455 15

Tôi tìm thấy một cách để làm điều đó trong thời gian và không gian .$O(m+n)$$O(mn)$

Không gian lớn hơn thời gian vì tôi sử dụng một mảng thông minh cho phép bạn tạo một mảng có kích thước và sắp xếp các giá trị ban đầu cho tất cả các ô trong .$n$$O(1)$

Tôi đã sử dụng sắp xếp xô để sắp xếp từng chuỗi ( thời gian và không gian) và từ cây để sắp xếp bộ sưu tập ( thời gian và không gian ). nhưng giải pháp của tôi quá phức tạp.$O(m+n)$$A$$O(m+n)$$O(mn)$

Có ai có giải pháp tốt hơn, với thời gian và ít không gian hơn, hoặc nhanh hơn không?$O(m+n)$$O(m+n)$

Giải pháp phải có tính xác định để không có bản đồ băm hoặc các thuật toán thống kê khác

Giải pháp của tôi: Mảng thông minh là một mảng có kích thước mà chúng ta có thể tạo và "khởi tạo" trong :$m$$O(1)$

Chúng tôi tạo ra ba mảng kích thước của mà không cần khởi tạo bất kỳ trong số họ và chúng tôi cũng giữ một biến số nguyên duy nhất được gọi là .$m$$C$

Mảng đầu tiên chứa dữ liệu. Mảng thứ hai chứa các con trỏ tới một ô trong mảng thứ ba. Mảng thứ ba chứa các con trỏ tới một ô trong mảng thứ hai. chứa số lượng tế bào được khởi tạo cho đến nay.$C$

Giả sử chúng ta muốn đặt giá trị của ô (giả sử đây là lần đầu tiên chúng ta thực hiện nó trên ô này). Sau đó, chúng ta sẽ đi đến ô trong mảng đầu tiên và đặt nó vào val mong muốn.$i$$i$

Bây giờ chúng ta đi đến ô trong mảng thứ hai và đặt nó vào điểm ở mảng thứ ba. Đặt ô trong mảng thứ ba để trỏ đến ô trong mảng thứ hai. Tăng thêm 1.$i$$C$$C$$i$$C$

Giả sử chúng ta muốn biết nếu ô là rác (Điều đó có nghĩa là chúng ta chưa đặt bất cứ thứ gì cho nó).$j$

Chúng ta sẽ đi đến ô trong mảng thứ hai và xem số ô (trong mảng thứ ba) mà ô (trong mảng thứ hai) trỏ đến - chúng ta sẽ gọi nó là .$j$$j$$k$

Nếu thì là rác (vì chúng ta chỉ khởi tạo các ô cho đến nay và không phải là một trong số chúng).$k>C$$j$$C$$j$

Nếu chúng ta sẽ xem ô nào (trong mảng thứ ba) trỏ đến. Nếu nó không phải thì là rác. Nếu không thì không phải là rác$k<C$$k$$j$$j$$j$

Bằng cách đó, chúng ta có thể biết ở mỗi bước nếu chúng ta khởi tạo ô này và nếu không khởi tạo nó. Vì vậy, chúng tôi đã tạo và "khởi tạo" một mảng có kích thước trong thời gian .$m$$O(1)$

Bí quyết chính không phải là khởi tạo toàn bộ mảng khi bắt đầu mà là tìm cách biết những ô nào chúng ta đã khởi tạo cho đến nay và chỉ khởi tạo một ô khi chúng ta "nhìn" vào nó. Trong mô hình RAM, phải mất thời gian để tạo ra một mảng có kích thước bất kỳ mà không khởi tạo nó.$O(1)$

Một cây từ có thứ tự m là một khái quát của TRIE. Mỗi nút chứa một mảng các con trỏ tới các con trai của nó. Kích thước mảng là . Mỗi nút cũng chứa một bộ đếm để cho biết có bao nhiêu bộ được mô tả bởi nút này.$m$

Bởi vì chúng ta đang sử dụng các mảng thông minh mỗi lần chúng ta thêm một chữ (một bộ) chỉ mất thời gian và không gian.$A$$O(|A|)$$O(m|A|)$

Bạn cũng có thể giải quyết điều này trong thời gian và không gian :$O(n \log n)$$O(n)$

• Đầu tiên, sắp xếp từng từ bằng cách sử dụng mergesort. Thời gian chạy này sẽ nhiều nhất là và không gian sử dụng là .$O(n \log n)$$O(n)$

• Sau đó, lưu trữ tất cả các từ trong một trie từ. Thời gian và không gian cho việc này sẽ là , nếu bạn thực hiện từ trie đúng cách. Đặc biệt, tại mỗi nút của bộ ba, bạn nên lưu trữ tập hợp con dưới dạng hashtable (không phải là một mảng). Theo cách này, việc lưu trữ tại một nút tỷ lệ thuận với số lượng trẻ em có và việc tìm kiếm một đứa trẻ có thể được thực hiện trong thời gian . Do đó, thời gian chạy của giai đoạn này là thời gian và không gian .$O(n)$$O(1)$$O(n)$$O(n)$

• Cuối cùng, đọc tất cả các từ trong bộ ba. Điều này liên quan đến việc lấy từng hashtable và sắp xếp nội dung của nó, giả sử sử dụng mergesort. Tất cả các bước sắp xếp đó sẽ mất nhiều thời gian nhất là .$O(n \log n)$

Cấu trúc dữ liệu kết quả có vẻ khá đơn giản. Điều này đặc biệt đơn giản nếu bạn triển khai bằng ngôn ngữ có hỗ trợ tích hợp cho hashmap (ví dụ: Javascript, Python).

Ngoài ra, bạn có thể thay thế hashmap bằng cấu trúc dữ liệu cây nhị phân cân bằng và có thời gian chạy tương tự.

Như một lưu ý chung về "mảng thông minh":

Bạn có thể thay thế việc sử dụng "mảng thông minh" bằng hashtable. Bằng cách đó, bạn sẽ duy trì khả năng đọc và viết (dự kiến). Cụ thể, thay vì đặt , bạn lưu trữ giá trị tại khóa (nghĩa là thêm ánh xạ vào hàm băm). Khi bạn muốn đọc giá trị của , thay vào đó bạn tra cứu trong hashtable và trả lại bất cứ thứ gì bạn tìm thấy ở đó. Theo cách này, việc sử dụng không gian tỷ lệ thuận với số lượng mục khởi tạo trong "mảng thông minh" và mỗi lần truy cập mất thời gian (dự kiến).$O(1)$$A[i] := v$$v$$k$$k \mapsto v$$A[i]$$i$$O(1)$

Bạn có thể sắp xếp một tập của chuỗi trên một bảng chữ cái số nguyên kích thước sử dụng một Trie trong thời gian và không gian, nơi là phân biệt tiền tố của .$S$$\{0,1,\dots,\sigma-1\}$$\sigma$$O(d\sigma)$$d$$S$

Đây là một giải pháp không sử dụng bảng băm.

Hãy được chiều dài của tiền tố ngắn của chuỗi mà phân biệt nó với các dây khác trong . Tiền tố phân biệt của được định nghĩa là .$d_s$$s \in S$$S$$S$$d = \sum_{s\in S}d_s$

Thuật toán để giải quyết vấn đề sử dụng phương pháp phân chia & chinh phục, đó là RadixSort bắt đầu từ chữ số có nghĩa nhất (char).

1) Tạo xô$\sigma$$0,1,\dots,\sigma-1$

2) Xử lý chuỗi ký tự theo từng ký tự từ đầu và phân phối chúng vào các thùng bằng cách sử dụng CountingSort trong thời gian .$\sigma$$O(1)$

3) Lặp lại quy trình trên các thùng chứa nhiều hơn một phần tử bằng cách sử dụng ký tự tiếp theo để sắp xếp chúng.

4) Nối các nhóm từ trái sang phải để có được thứ tự.

Thuật toán này tạo ra một bộ ba -ary, trong đó mỗi nút là một mảng có kích thước và các chuỗi được lưu trữ trong các lá.$\sigma$$\sigma$

Đây là một ví dụ.

Đặt là và .$\sigma$$5$$S=\{410,013,042,111,001,444\}$

Sau đây là bộ ba được tạo bởi thuật toán:

Mỗi chuỗi phát ra một đường dẫn có kích thước trước khi nút trỏ đến được tạo. Mỗi nút trong những con đường mất không gian và thời gian được phân bổ.$s$$O(d_s)$$s$$O(\sigma)$$O(\sigma)$