Có một đống ổn định?

Có cấu trúc dữ liệu hàng đợi ưu tiên hỗ trợ các hoạt động sau không?

• Chèn (x, p) : Thêm bản ghi mới x với mức độ ưu tiên p
• StableExtractMin () : Trả lại và xóa bản ghi với mức độ ưu tiên tối thiểu, phá vỡ các mối quan hệ bằng cách chèn thứ tự .

Do đó, sau khi Chèn (a, 1), Chèn (b, 2), Chèn (c, 1), Chèn (d, 2), một chuỗi StableExtractMin sẽ trả về a, rồi c, rồi b, rồi d.

Rõ ràng người ta có thể sử dụng bất kỳ cấu trúc dữ liệu hàng đợi ưu tiên nào bằng cách lưu trữ cặp làm ưu tiên thực tế, nhưng tôi quan tâm đến cấu trúc dữ liệu không lưu trữ rõ ràng thời gian chèn (hoặc thứ tự chèn), bằng cách tương tự để phân loại ổn định.$(p, time)$

Tương đương (?): Có phiên bản heapsort ổn định không cần thêm không gian không?$\Omega(n)$

Phương pháp Bently-Saxe cho hàng đợi ưu tiên ổn định khá tự nhiên.

$A_0,\ldots,A_k$$A_i$$2^i$$c_i$$A_i[c_i],\ldots,A_i[2^i-1]$

$i$$A_i$$A_{i+1}$$A_i$$A_i$$A_{i+1}$$A_{i+1}$

$x$$i$$A_i$$A_0,\ldots,A_{i-1}$$x$$A_i$$c_0,\ldots,c_i$

$i$$A_i[c_i]$$i$$c_i$

$O(\log n)$

$n$$n$$O(\log n)$$\Omega(n)$

$n$$n$

$A_k,\ldots,A_0$$A_k$$A_{k-1}$$n$$n$$i$$A_i$$2^i$

$n$$A_0,\ldots,A_i$

$c_i$$A_i$$c_i$$2^i-c_i-1$$O(\log n)$$A_0[0],\ldots,A_k[0]$$A_i[0]$$A_i[0]$$A_i$$A_i[c_i]$$A_i[0]$$A_i[c_i]$

$n$

Tôi không chắc chắn những hạn chế của bạn là gì; sau đây có đủ điều kiện? Lưu trữ dữ liệu trong một mảng, mà chúng tôi hiểu là cây nhị phân ẩn (như một đống nhị phân), nhưng với các mục dữ liệu ở cấp độ dưới cùng của cây chứ không phải tại các nút bên trong của nó. Mỗi nút bên trong của cây lưu trữ các giá trị nhỏ hơn được sao chép từ hai con của nó; trong trường hợp quan hệ, sao chép con trái.

Để tìm mức tối thiểu, hãy nhìn vào gốc của cây.

Để xóa một phần tử, đánh dấu nó là đã xóa (xóa lười biếng) và truyền lên cây (mỗi nút trên đường dẫn đến gốc chứa một bản sao của phần tử đã xóa nên được thay thế bằng một bản sao của phần tử con khác). Duy trì số lượng phần tử bị xóa và nếu nó trở nên quá lớn, một phần nhỏ của tất cả các phần tử thì xây dựng lại cấu trúc giữ trật tự của các phần tử ở mức dưới cùng - việc xây dựng lại mất thời gian tuyến tính để phần này chỉ thêm thời gian khấu hao không đổi vào độ phức tạp hoạt động.

Để chèn một phần tử, thêm nó vào vị trí miễn phí tiếp theo trên hàng dưới cùng của cây và cập nhật đường dẫn đến thư mục gốc. Hoặc, nếu hàng dưới cùng đầy, tăng gấp đôi kích thước của cây (một lần nữa với đối số khấu hao; lưu ý rằng phần này không khác gì so với nhu cầu xây dựng lại khi một nhị phân chuẩn vượt quá mảng của nó).

Tuy nhiên, đây không phải là câu trả lời cho câu hỏi chặt chẽ hơn của Mihai bởi vì nó sử dụng bộ nhớ gấp đôi so với cấu trúc dữ liệu ngầm thực sự, ngay cả khi chúng ta bỏ qua chi phí không gian để xử lý xóa một cách lười biếng.

Đây có phải là một cách giải thích hợp lệ cho vấn đề của bạn:

Bạn phải lưu trữ N khóa trong một mảng A [1..N] không có thông tin phụ trợ để bạn có thể hỗ trợ: * chèn phím * xóa min, chọn phần tử được chèn sớm nhất nếu có nhiều cực tiểu

Điều này có vẻ khá khó khăn, do hầu hết các cấu trúc dữ liệu ngầm đều chơi trò lừa các bit mã hóa theo thứ tự cục bộ của một số phần tử. Ở đây nếu nhiều kẻ bằng nhau, thứ tự của họ phải được giữ nguyên, vì vậy không có thủ đoạn nào như vậy có thể.

Hấp dẫn.

Câu trả lời ngắn gọn: Bạn không thể.

Câu trả lời dài hơn một chút:

$\Omega(n)$$\Omega(n)$

$addr(X) < addr(Y)$

Câu trả lời rất dài với giả toán không chính xác:

Lưu ý: phần cuối của phần thứ hai là sơ sài, như đã đề cập. Nếu một số người toán học có thể cung cấp một phiên bản tốt hơn, tôi sẽ rất biết ơn.

$P$

$(a,1) < (a,2)$$(a,1) = (a,1)$$(a,1)$$(b,1)$

$X < Y$$X$$Y$

$(?,1)$$?$

• $X - log_2(P)$$2^X$
• $P$

$X - log_2(P)$$O(n)$$n$

Bây giờ, mỗi "bộ nhớ" cung cấp cho chúng ta bao nhiêu bit thông tin?

• $W$$W$
• $X$

$P \geq 1$$X - log_2(P) < X$

Vì vậy, để lưu trữ tất cả thông tin của chúng tôi, chúng tôi có hai khả năng:

• Lưu trữ thứ tự chèn trong địa chỉ và tải trọng trong bộ nhớ.
• Lưu trữ cả trong bộ nhớ và để lại địa chỉ miễn phí cho một số sử dụng khác.

Rõ ràng, để tránh lãng phí, chúng tôi sẽ sử dụng giải pháp đầu tiên.

Bây giờ cho các hoạt động. Tôi cho rằng bạn muốn có:

• $Insert(task, priority)$$O(log n)$
• $StableExtractMin()$$O(log n)$

$StableExtractMin()$

Thuật toán thực sự thực sự chung như sau:

1. $O(log n)$
2. $O(log n)$
3. Trả lại.

$0(1)$$O(1)$$O(1)$

$O(log n)$$2^(X - log_2(P))$

$X - log_2(P)$$O(log n)$$O(log n)$

$O(log n)$

$O(log n)$$X - log_2(P)$

$O(log n)$

$X - log_2(P)$$O(log n)$

Thuật toán chèn thường chỉ cần cập nhật một phần thông tin này, tôi không nghĩ rằng nó sẽ tốn nhiều tiền hơn (thông minh bộ nhớ) để nó hoạt động nhanh.

$X - log_2(P)$

• $X - log_2(P)$
• $P$
• $X - log_2(P)$

$\Omega(n)$

Nếu bạn triển khai hàng đợi ưu tiên của mình dưới dạng cây nhị phân cân bằng (một lựa chọn phổ biến), thì bạn chỉ cần đảm bảo rằng khi bạn thêm một phần tử vào cây, nó sẽ được chèn vào bên trái của bất kỳ phần tử nào có mức độ ưu tiên như nhau.
Bằng cách này, thứ tự chèn được mã hóa trong cấu trúc của chính cây.

Tôi không nghĩ điều đó là có thể

trường hợp cụ thể:

       x
    x    x
  x  x  1  x
1  x  

đống tối thiểu với tất cả x> 1

heapifying cuối cùng sẽ cho một cái gì đó lựa chọn như vậy

       x
    1    1
  x  x  x  x
x  x  

Bây giờ cái nào để nhân giống đến root?