Question

I’ve just read about binary search trees from the “Learn You a Haskell” book, and I’m wondering whether it is effective to search more than one element using this tree? For example, suppose I have a bunch of objects where every object has some index, and

        5
      /   \
     3     7
    / \   / \
   1   4 6   8

if I need to find an element by index 8, I need to do only three steps 5 -> 7 -> 8, instead of iterating over the whole list until the end. But what if I need to find several objects, say 1, 4, 6, 8? It seems like I’d need to repeat the same action for each element 5-> 3 -> 1 5 -> 3 -> 4, 5 -> 7 -> 6 and 5 -> 7 -> 8.

So my question is: does it still make sense to use binary search tree for finding more than one element? Could it be better than checking each element for condition (which leads only to O(n) in the worst case)?

Also, what kind of data structure is better to use if I need to check more than one attribute. E.g. in the example above, I was looking only for the id attribute, but what if I also need to search by name, or color, etc?

Answer 1

You can share some of the work. See members, which takes in a list of values and outputs a list of exactly those values of the input list that are in the tree. Note: The order of the input list is not perserved in the output list.

EDIT: I’m actually not sure if you can get better performance (from a theoretical standpoint) with members over doing map member. I think that if the input list is sorted, then you could by splitting the list in threes (lss, eqs, gts) could be done easily.

data BinTree a
  = Branch (BinTree a) a (BinTree a)
  | Leaf
  deriving (Show, Eq, Ord)

empty :: BinTree a
empty = Leaf

singleton :: a -> BinTree a
singleton x = Branch Leaf x Leaf

add :: (Ord a) => a -> BinTree a -> BinTree a
add x Leaf = singleton x
add x tree@(Branch left y right) = case compare x y of
  EQ -> tree
  LT -> Branch (add x left) y right
  GT -> Branch left y (add x right)

member :: (Ord a) => a -> BinTree a -> Bool
member x Leaf = False
member x (Branch left y right) = case compare x y of
  EQ -> True
  LT -> member x left
  GT -> member x right

members :: (Ord a) => [a] -> BinTree a -> [a]
members xs Leaf = []
members xs (Branch left y right) = eqs ++ members lts left ++ members gts right
  where
    comps = map (\x -> (compare x y, x)) xs
    grab ordering = map snd . filter ((ordering ==) . fst)
    eqs = grab EQ comps
    lts = grab LT comps
    gts = grab GT comps