Question

I have a sorted list of inputs:

let x = [2; 4; 6; 8; 8; 10; 12]
let y = [-8; -7; 2; 2; 3; 4; 4; 8; 8; 8;]

I want to write a function which behaves similar to an SQL INNER JOIN. In other words, I want to return the cartesian product of x and y which contains only items shared in both lists:

join(x, y) = [2; 2; 4; 4; 8; 8; 8; 8; 8; 8]

I’ve written a naive version as follows:

let join x y =
    [for x' in x do
        for y' in y do
            yield (x', y')]
    |> List.choose (fun (x, y) -> if x = y then Some x else None)

It works, but this runs in O(x.length * y.length). Since both my lists are sorted, I think its possible to get the results I want in O(min(x.length, y.length)).

How can I find common elements in two sorted lists in linear time?

Answer 1

O(min(n,m)) time is impossible: Take two lists [x;x;…;x;y] and [x;x;…;x;z]. You have to browse both lists till the end to compare y and z.

Even O(n+m) is impossible. Take
[1,1,…,1] – n times
and
[1,1,…,1] – m times
Then the resulting list should have n*m elements. You need at least O(n m) (correctly Omega(n m)) time do create such list.

Without cartesian product (simple merge), this is quite easy. Ocaml code (I don’t know F#, should be reasonably close; compiled but not tested):

let rec merge a b = match (a,b) with
   ([], xs) -> xs
|  (xs, []) -> xs
|  (x::xs, y::ys) -> if x <= y then x::(merge xs (y::ys))
                else y::(merge (x::xs) (y::ys));;

(Edit: I was too late)

So your code in O(n m) is the best possible in worst case. However, IIUIC it performs always n*m operations, which is not optimal.

My approach would be

1) write a function

group : ‘a list -> (‘a * int) list

that counts the number of same elements:

group [1,1,1,1,1,2,2,3] == [(1,5);(2,2);(3,1)]

2) use it to merge both lists using similar code as before (there you can multiply those coefficients)

3) write a function

ungroup : (‘a * int) list -> ‘a list

and compose those three.

This has complexity O(n+m+x) where x is the length of resulting list. This is the best possible up to constant.

Edit: Here you go:

let group x =
  let rec group2 l m =
    match l with
    | [] -> []
    | a1::a2::r when a1 == a2 -> group2 (a2::r) (m+1)
    | x::r -> (x, m+1)::(group2 r 0)
  in group2 x 0;;

let rec merge a b = match (a,b) with
   ([], xs) -> []
|  (xs, []) -> []
|  ((x, xm)::xs, (y, ym)::ys) -> if x == y then (x, xm*ym)::(merge xs ys)
                           else  if x <  y then merge xs ((y, ym)::ys)
                                           else merge ((x, xm)::xs) ys;;

let rec ungroup a =
  match a with
    [] -> []
  | (x, 0)::l -> ungroup l
  | (x, m)::l -> x::(ungroup ((x,m-1)::l));;

let crossjoin x y = ungroup (merge (group x) (group y));;



# crossjoin [2; 4; 6; 8; 8; 10; 12] [-7; -8; 2; 2; 3; 4; 4; 8; 8; 8;];;
- : int list = [2; 2; 4; 4; 8; 8; 8; 8; 8; 8]