Sorting in O(n) intersect - algorithm

Question

Let S1 and S2 be two sets of integers (they are not necessarily disjoint).
We know
that |S1| = |S2| = n (i.e. each set has n integers).
Each set is stored in an array of length n, where
its integers are sorted in ascending order.
Let k ≥ 1 be an integer.
Design an algorithm to find the
k smallest integers in S1 ∩ S2 in O(n) time.
This is what I have so far:
Create a new array called Intersection
For each e in S1 add e to hashset in O(n) time
For each e in S2 check if e exists in hashset in O(n) time
If e exists in hashset add e to Intersection
Once comparisons are done sort Intersection by count sort in O(n) time
return the first k integers
Thus O(n) + O(n) + O(n) = O(n)
Am I on the right track?

Answer 1

Yes, you're definitely on the right track but there's actually no need at all to generate a hash-table or extra set. As your two sets are already sorted, you can simply run an index/pointer through both of them, looking for the common elements.
For example, to find the first common element from the two sets, use the following pseudo-code:
start at first index of both sets
while more elements in both sets, and current values are different:
if set1 value is less than set2 value:
advance set1 index
else
advance set2 index
At the end of that, set1 index will refer to an intersect point provided that neither index has moved beyond the last element in their respective list. You can then just use that method in a loop to find the first x intersection values.
Here's a proof of concept in Python 3 that gives you the first three numbers that are in the two lists (multiples-of-two and multiples-of-three). The full intersection would be {0, 6, 12, 18, 24} but you will see that it will only extract the first three of those:
# Create the two lists to be used for intersection.
set1 = [i * 2 for i in range(15)] ; print(set1) # doubles
set2 = [i * 3 for i in range(15)] ; print(set2) # trebles
idx1 = 0 ; count1 = len(set1)
idx2 = 0 ; count2 = len(set2)
# Only want first three.
need = 3
while need > 0:
# Continue until we find next intersect or end of a list.
while idx1 < count1 and idx2 < count2 and set1[idx1] != set2[idx2]:
# Advance pointer of list with lowest value.
if set1[idx1] < set2[idx2]:
idx1 += 1
else:
idx2 += 1
# Break if reached end of a list with no intersect.
if idx1 >= count1 or idx2 >= count2:
break
# Otherwise print intersect and advance to next list candidate.
print(set1[idx1]) ; need -= 1
idx1 += 1 ; idx2 += 1
The output is, as expected:
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42]
0
6
12
If you needed a list at the end rather than just printing out the intersect points, you would simply initialise an empty container before the loop and the append the value to it rather than printing it. This then becomes a little more like your proposed solution but with the advantage of not needing hash tables or sorting.

Answer 2

Create two arrays, call them arr1 and arr2, of size array_size and populate them with integer values in ascending order. Create two indexes, call them i and j, that will be used to iterate over arr1 and arr2 respectively and initialize them to 0. Compare the first two values of each array: if arr1[0] is less than arr2[0] then increment i, else if arr1[0] is greater than arr2[0] increment j, else the values intersect and we can return this value. Once we have returned k intersecting values we can stop iterating. In the worst case scenario this will be i + j, O(n) if no intersections occur between both sets of values and we will have to iterate to the end of each array.
Here is the solution in bash:
#!/bin/bash
#-------------------------------------------------------------------------------
# Design an algorithm to find the k smallest integers in S1 ∩ S2 in O(n) time.
#-------------------------------------------------------------------------------
typeset -a arr1 arr2 arr_answer
typeset -i array_size=20 k=5
function populate_arrs {
typeset -i counter=0
while [[ ${counter} -lt ${array_size} ]]; do
arr1[${counter}]=$((${counter} * 2))
arr2[${counter}]=$((${counter} * 3))
counter=${counter}+1
done
printf "%8s" "Set1: "; printf "%4d" ${arr1[*]}; printf "\n"
printf "%8s" "Set2: "; printf "%4d" ${arr2[*]}; printf "\n\n"
}
function k_smallest_integers_main {
populate_arrs
typeset -i counter=0 i=0 j=0
while [[ ${counter} -lt ${k} ]]; do
if [[ ${arr1[${i}]} -eq ${arr2[${j}]} ]]; then
arr_answer[${counter}]=${arr1[${i}]}
counter=${counter}+1; i=${i}+1; j=${j}+1
elif [[ ${arr1[${i}]} -lt ${arr2[${j}]} ]]; then
i=${i}+1
else
j=${j}+1
fi
done
printf "%8s" "Answer: "; printf "%4d" ${arr_answer[*]}; printf "\n"
}
k_smallest_integers_main
Output:
Set1: 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38
Set2: 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 54 57
Answer: 0 6 12 18 24

Answer 3

In Python:
i1= 0; i2= 0
while k > 0 and i1 < n and i2 < n:
if S1[i1] < S2[i2]:
i1+= 1
elif S1[i1] > S2[i2]:
i2+= 1
else:
Process(S1[i1], S2[i2])
i1+= 1; i2+= 1
k-= 1
Execution will perform less than k calls to Process if there aren't sufficiently many elements in the intersection.