Soft heaps are a data structure that provide faster operations than regular heaps while allowing some errors. Soft heaps have an error parameter ε such that after n inserts, at most εn elements may be corrupted. This allows operations like delete-min to run in O(1) amortized time and insert to run in O(log(1/ε)) amortized time. Soft heaps work by grouping corrupted elements together using a linked list of heap-ordered binary trees with suffix-min pointers.

1. (a data structure created by Bernard Chazelle)
1
“Be soft, even if you stand to get squashed.”
-- E. M. Forster

2. Outline
 Soft heaps
 What are they?
 Advantages vs. regular heaps
 Soft heap operations:
 sift, combine, updatesufmin, insert, deletemin
 Analysis of running time
 Proof of correctness
 Applications
2

3. Why soft heaps?
 (Because they are used in Chazelle’s MST algorithm)
 But what’s wrong with regular heaps?
 The “problem”: they can be used to sort
 Sorting takes (n log n) time
 So either insert(x) or delete-min() takes (log n)
3

4. How can we improve this LB?
 Inaccuracy:
 Soft heaps have an error parameter 
 After n inserts, at most n elements may be corrupted
 But nice amortized run times:
 delete-min()– O(1)
 insert(x) – O(log 1/)
 Note: with  < 1/n, works just like ordinary heap.
 So… how do they work?
4

5. Overview of soft heaps
 New construction (Kaplan & Zwick, 2009)
 Linked list of heap-ordered binary trees: each tree has a rank,
and one tree per rank
 Each tree also has a suffix-min pointer (black)
5
0 1 3
3 12 8
925
17 11
Trees are not
necessarily balanced
5, 7, 8
2, 10, 11
Each node has list of
elements

6. Corruption
 Each node x has a list of elements, list[x]
 All elements in list are indexed by the node’s key
 If their key is less, then they are corrupted
 (Note that corruption can only increase a key)
 The soft heap has at most n elements corrupted after
n inserts
 These elements move together (“carpooling”), which
allows faster operations
6
8
5, 7, 8

7. Some more notation
 For a node x:
 left[x] is the left child of x, null if none exists
 right[x] is the right child of x, null if none exists
 key[x] is the key value of x, or  if x = null
 size[x] is the target size of list[x] (defined later)
 For a root node x:
 suf-min[x] is the suffix-min pointer of x
 next[x] is the next root in the linked list
 prev[x] is the previous root in the linked list
7

8. Soft heap operations: sift
 For each node x, we want list[x] to have “enough” elements so
that operations are fast
 The sift(x) operation increases the number of elements in list[x]:
 If size[x] > |list[x]|:
 Let y be the child of x with smaller key
 append(list[x], list[y])
 Set key[x] = key[y]
 If y is a leaf, delete it, else call sift(y)
8
4
9
5, 7, 9
9
4, 5, 7, 9

9. Operations: combine
 If we have two trees x, y of the same rank, we can
combine(x, y) them into one tree:
 Create a new node z
 Set left[z] = x, right[z] = y
 Set rank[z] = rank[x] + 1
 Set size[z] appropriately (defined later)
 Call sift(z)
9
12
25
5
18

12
25
5
18
5
12
25
18

10. Operations: updatesufmin
 Recall: each root node x has a suffix-min pointer
 Points to the smallest root from x to the end of the list
 These may become invalid: updatesufmin(x) updates
suf-min[x] and suf-min[y], for y  x
 We do this when we change the key of x (during sift),
add a new root, or delete next[x]:
 If key[x]  key[suf-min[next[x]]]:
 Set suf-min[x] = x
 Else set suf-min[x] = suf-min[next[x]]
 updatesufmin(prev[x])
10

11. Operations: insert, deletemin
 To insert:
 We create a new rank 0 tree and add it to the list of roots
 Then we call combine until there is only one root of
each rank
 Finally, if x was the last root we modified, we call
updatesufmin(x)
 To deletemin:
 Let z be the first root of the linked list
 Then set y = suf-min[z], and return an element of list[y]
 If |list[y]| < size[y]/2, call sift(y)
11

12. Example: insert
1212
0 1 3
3 12 8
925
17 11
5, 7, 8
2, 10, 11
1

13. Example: insert
1313
0 1 3
12 8
925
17 11
5, 7, 8
2, 10, 11

1 3

14. Example: insert
1414
1 3
12 8
925
17 11
5, 7, 8
2, 10, 11
1
3

15. Example: insert
1515
1 3
12
8
9
25
17 11
5, 7, 8
2, 10, 11
1
3


16. Example: insert
1616
2 3
12
8
9
25
17 11
5, 7, 8
2, 10, 11
3
1

17. Example: insert
1717
2 3
12
8
9
25
17 11
5, 7, 8
2, 10, 11
3
1

18. Example: deletemin
18
2 3
12
8
9
25
17 11
7, 5, 8
2, 10, 11
33
10

19. Example: deletemin
19
2 3
12
8
9
25
17 11
5, 8
2, 10, 11
33
10
7
Let’s say 2 < size[8]/2…

20. Example: deletemin
20
2 3
12
9

25
17 11
5, 8, 9
2, 10, 11
33
10
7
Note: 8 is now
corrupted

21. Example: deletemin
21
2 3
12
9
11
25
17 
5, 8, 9
2, 10, 11
33
10
7

22. Example: deletemin
22
2 3
12
9
11
25
17 34
5, 8, 9
2, 10, 11
33
10
7
19, 34

23. Amortized Analysis
 Potential analysis:
 Let M be the max rank of the heap
 Each internal node has potential of 1
 Each root node x has potential of:
 rank[x] + 5
 The heap itself has potential M
 For each tree T, let del(T) be the number of deletions
from T since the last sift
 We also give T a potential of (r + 2)del(T)
 (r will be defined later)
23

24. Analysis of combine(x, y)
 x, y root nodes with rank of k
 The potentials of x, y decrease from 2k + 10 to 2.
 Creating a new node z increases the potential by k + 6
 The potential may increase by 1 if M increases
 We charge 1 cost for the operation
 After doing combines, we may have to do an
updatesufmin, which costs k
 This gives an amortized cost of 2-2k-10+k+6+2+k = 0
24

25. Analysis of sift(x)
 Let x be a node of rank k, y its child and we move the
elements of list[y] to list[x]
 If |list[y]| < size[y]/2, then y is a leaf and it is deleted,
so the potential decreases by 1, which pays for this
operation
 Otherwise…
 We have |list[y]|  size[y]/2, so we charge each element
2/size[y] for the operation
 Each element can be charged at most once per rank, (in
its whole history of existence)
 So the max cost of sift is:
25


0 krankofnodeofsizemax
2
k

26. What is this size[y] function?
 Consider: if size[y] = 1, then the cost of sift is just O(M), which
will be O(log n) (also, no elements will be corrupted)
 So having size[y] > 1 is what makes soft heaps “soft”
 We want the sum from the previous slide to be O(log 1/)
 So we will make size[y] = 1 for ranks up to O(log 1/), and then
exponentially increasing
 So let r = C + log 1/, then we can define (for 0 <  < 1):
 With this definition, the previous sum indeed gives O(log 1/)
26






 rks
rk
s
k
k
1)1(
1


27. Analysis of insert
 We create a new root node (potential increased by 5)
 Every combine pays for itself, and the final
updatesufmin
 Finally, the sift cost of the new element and the
eventual delete cost will be O(log 1/)
 (see next slide)
 So insert takes O(log 1/) amortized
27

28. Analysis of deletemin
 Finding the key takes 1 operation
 Deleting raises the potential by r+2 (so cost of r+3) – we
have charged this to nodes when they were inserted
 If we have a leaf with more elements in its list or |list[x]| >
size[x]/2, we do nothing
 (If it is a leaf and we delete it, then the potential is reduced by
k+5)
 Otherwise: If we do sift, del(x)  size[x]/2
 So the potential of the tree was at least (r + 2)sk/2
 Can show: (r + 2)sk/2 > k + 1
 Either way we have k+1 potential, which pays for the
updatesufmin operation, so O(1) amortized
28

29. Proof of correctness
 Lemma 1: The number of nodes of rank k is at most
n/2k.
 Lemma 2: If x has rank k, size[x]  2(1 + )k-r
 Proof of both: Easy induction.
 Lemma 3: |list[x]|  (1 + 1/)size[x]
 Proof: By induction on the rank of x. If we move nodes
from list[y] of lower rank, we have
|list[y]|  ((1 + )/)size[y] = size[x]/
 So the new size is size[x] + size[x]/ = (1 + 1/)size[x]
29

30. Proof of correctness (cont’d)
 Theorem: After n insertions, at most n elements are corrupted.
 Proof:
 Elements can only be corrupted in nodes of rank > r
 For a node of rank k,
|list[x]|  (1 + 1/)size[x]  2 (1 + 1/) (1 + )k-r
 Since r = C + log 1/ the # of corrupted elements is at most:
30
i
i
r
rk
rk
rk
r
rk
k
rk
nn
n  









 





0 2
)1(
2
)/11(2
2
)1(
2
)/11(2
2
)1(
)/11(2







n
n
Cr
2)1(
)/11(4
1
2
2
)/11(2






So we choose C such that this is < n
(We needed  < 1 for the sum to converge)

31. Applications of Soft Heaps
 Selection in O(n) time:
 Make a soft heap with  = 1/3:
 Insert all the elements, then remove n/3 + 1 elements
 Let x be the largest element removed
 x is greater than 1/3 of the elements, and it is less than 1/3 of
the elements (because only 1/3 could be corrupted)
 So partition the elements around x, in the worst case you are
left with (2/3)n elements, then we continue recursively
 Running time: O(n + (2/3)n + (4/9)n + …) = O(n)
 More interesting application:
 Finding the MST in O(α(m, n) m) time
31

32. (I hope you have enjoyed soft heaps.)
32