Leftest Heap Structure. Leftest Heap

Transcription

1 Leftest Heap Structure Each node contains the fields: Key, Dist, Left, Right If p is the parent, then p.key > p.left.key p.key > p.right.key p.dist = 1 + min(p.left.dist, p.right.dist) p.left.dist p.right.dist 2001 P.Wolfgang 1 Leftest Heap P.Wolfgang 2 1

2 Leftest Heap Properties There are at least 2 p.dist nodes below p. A Leftest Heap with n nodes has a path of lg(n+1) from the root to a leaf taking the right branch. A new node can be inserted by following this path. Thus, insertion takes O(log n) 2001 P.Wolfgang 3 Merging Leftest Heaps To merge leftest heaps P and Q: If P.Key > Q.Key, make P the root, and merge the leftest heaps P.right and Q. Make this merged heap P.right. Otherwise make Q the root, and merge Q.right and P P.Wolfgang 4 2

3 Removal from a Leftest Heap To remove the node P Merge P.Left and P.Right. Replace P with the merged heap P.Wolfgang 5 Java Implementation /** A leftestheap is a heap implemented using leftest trees as described in Knuth (vol 3, page ) */ public class LeftestHeap private class Node public Comparable Key; public int Dist; public Node Parent; public Node Left; public Node Right; Node (Comparable key, int dist, Node left, Node right) Key = key; Dist = dist; Parent = null; Left = left; Right = right; 2001 P.Wolfgang 6 3

4 private static int getdist(node n) if (n == null) return 0; else return n.dist; private Node Root; public LeftestHeap(Comparable Key) Root = new Node(Key, 1, null, null); public LeftestHeap() Root = null; private LeftestHeap(Node n) Root = n; 2001 P.Wolfgang 7 public static LeftestHeap Merge(LeftestHeap P, LeftestHeap Q) Node NewRoot; if (P.Root == null) return Q; if (Q.Root == null) return P; if (P.Root.Key.compareTo(Q.Root.Key) > 0) NewRoot = Q.Root; NewRoot.Right = Merge(P, new LeftestHeap(Q.Root.Right)).Root; else NewRoot = P.Root; NewRoot.Right = Merge(new LeftestHeap(P.Root.Right), Q).Root; if (getdist(newroot.left) < getdist(newroot.right)) Node temp = NewRoot.Left; NewRoot.Left = NewRoot.Right; NewRoot.Right = temp; NewRoot.Dist = getdist(newroot.right) + 1; if (NewRoot.Left!= null) NewRoot.Left.Parent = NewRoot; if (NewRoot.Right!= null) NewRoot.Right.Parent = NewRoot; return new LeftestHeap(NewRoot); 2001 P.Wolfgang 8 4

5 public class Handel private Node localroot; public Handel() localroot = null; public String tostring() return (localroot!= null? localroot.tostring() : "null"); public Comparable Remove() return LeftestHeap.this.Remove(localRoot); 2001 P.Wolfgang 9 public Handel Insert(Comparable newkey) LeftestHeap newheap = new LeftestHeap(newKey); Handel handel = new Handel(); handel.localroot = newheap.root; Node newroot = Merge(this, newheap).root; Root = newroot; return handel; 2001 P.Wolfgang 10 5

6 public Comparable Pop() if (Root!= null) Comparable result = Root.Key; Node newroot = Merge(new LeftestHeap(Root.Left), new LeftestHeap(Root.Right)).Root; Root = newroot; if (Root!= null) Root.Parent = null; return result; else return null; 2001 P.Wolfgang 11 private Comparable Remove(Node oldroot) if (oldroot == null) return null; Node newroot = Merge(new LeftestHeap(oldRoot.Left), new LeftestHeap(oldRoot.Right)).Root; if (oldroot.parent == null) Root = newroot; if (Root!= null) Root.Parent = null; else if (oldroot.parent.left == oldroot) oldroot.parent.left = newroot; else oldroot.parent.right = newroot; if (newroot!= null) newroot.parent = oldroot.parent; return oldroot.key; 2001 P.Wolfgang 12 6

7 boolean isempty() return Root == null; public Comparable Top() if (Root!= null) return Root.Key; else return null; 2001 P.Wolfgang 13 public Comparable Second() if (Root == null) return null; if (Root.Left == null) return Root.Right!= null? Root.Right.Key : null; if (Root.Right == null) return Root.Left.Key; if (Root.Left.Key.compareTo(Root.Right.Key) > 0) return Root.Right.Key; else return Root.Left.Key; 2001 P.Wolfgang 14 7

8 Hu-Tucker Algorithm Constructs the optimal binary search tree for the special case in which all of the β i s are zero. (I.E. the internal nodes have zero probability). By using leftest heaps, the algorithm can run in O(nlogn) time P.Wolfgang 15 Hu-Tucker Phase1 Start with a sequence of α i s as external nodes. Repeatedly combine two nodes α i and α j, i<j such that: No external nodes occur between α i and α j. The sum α i + α j is minimum over all (α i, α j ) The index i is the minimum The index j is the minimum 2001 P.Wolfgang 16 8

9 Result of Phase E F G H I J K L M N O 2001 P.Wolfgang 17 Hu-Tucker Phase2 Assign a level to each node starting with the root as zero. Remove the internal nodes created in Phase1 leaving a new working sequence of external nodes at the assigned levels P.Wolfgang 18 9

10 Result of Phase E H I N O F G M 6 32 L 1 5 J K 2001 P.Wolfgang 19 Ready for Phase3 103 E H I N O F G 20 M 32 L 1 5 J K 2001 P.Wolfgang 20 10

11 Hu-Tucker Phase3 Recombining the nodes into a new tree that preserves both the level of the external nodes and the sequence of the external nodes. Nodes α i and α j must be adjacent The levels l i and l j must be both the maximum of all remaining levels The index i is the minimum P.Wolfgang 21 Result of Phase E H I N O F G M 6 32 L 1 5 J K 2001 P.Wolfgang 22 11

12 Implementation in O(nlogn) time Construct a sequence of heaps that contain pairs of adjacent external nodes. Place this sequence into a master heap that is sorted by the sum of the weights of the smallest two elements of the heaps P.Wolfgang 23 Hu-Tucker in O(nlogn) time [2] Loop until the master heap has only one element: Remove the heap that has the smallest sum. Remove the smallest two nodes. If one (or both) of the nodes is (are) external Remove the heap(s) that contains the external node(s) from the master heap. Remove the external node(s) from this(these) heap(s). Combine the two (or three) heaps. Combine the two smallest nodes and insert the combined node back into the heap. Re-insert the heap into the master heap. Continue to combine the nodes of the remaining heap until it has only one node P.Wolfgang 24 12

13 Example Using the data of the figures, the initial heap of heaps looks as follows: After removing 1,5 and combining nodes we get: Next 15, 21 come out: Then 6, P.Wolfgang 25 Next 20, Then 36, Finally 57, 57 gives the final heap: Example [2] 2001 P.Wolfgang 26 13