CareerCup

Get the elements from each iterator in the input array one at a time, each time checking if you still can use that iterator(using hasNext). Store them in an ArrayList. Instantiate an iterator over this list of combined elements and use it to serve the next element every time.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

public class CustomIterator implements Iterator<Integer>{
    ArrayList<Integer> listOfCombinedElements  = new ArrayList<>();
    Iterator<Integer> combinedIterator;
    
    public CustomIterator(Iterator<Integer>[] input) {
        while(elementsLeft(input)) {
            for(Iterator i: input) {
                if(i.hasNext()){
                    listOfCombinedElements.add((Integer) i.next());
                }
            }
        }
        
        combinedIterator = listOfCombinedElements.iterator();
    }

    private boolean elementsLeft(Iterator[] input) {
        boolean answer = false;
        
        for(Iterator i: input){
            if(i.hasNext()) {
                return true;
            }
        }
        
        return answer;
    }

    @Override
    public boolean hasNext() {
        return combinedIterator.hasNext();
    }

    @Override
    public Integer next() {
        return combinedIterator.next();
    }

    @Override
    public void remove() {

    }

    public static void main(String[] args) {
        ArrayList<Integer> a = new ArrayList<>(Arrays.asList(10, 20));
        ArrayList<Integer> b = new ArrayList<>(Arrays.asList(30));
        ArrayList<Integer> c = new ArrayList<>(Arrays.asList(40, 50, 60));

        Iterator<Integer>[] input = new Iterator[] {a.iterator(), b.iterator(), c.iterator()};

        CustomIterator customIterator = new CustomIterator(input);

        while(customIterator.hasNext()) {
            System.out.println(customIterator.next());
        }
    }
}

-- Output --
10
30
40
20
50
60

generally the right idea. and I agree with @mithya, no queue. also as @tr030114 mentioned, getting to know the current system is important before beginning to optimize it. For example, what does wait time actually mean? does it simply mean, calling for an elevator and getting into it? Coz, remember this is a really tall building and someone wanting to go to the higher floors from the ground floor might be experiencing a lot to transit time while the elevator picks and drops people on the way up. Your solution although generally good is not clearly addressing this.

This is just a variation of Breadth First traversal on a tree.

void setNextNode(Node root) {
	Queue<Node> mainQueue = new ArrayDequeue<Node>();

	if (root == null) return;

	mainQueue.add(root);
	int nodesInCycle = 1;

	while (!mainQueue.isEmpty()) {
		Queue<Node> holdingQueue = new ArrayDequeue<Node>(); 
		for (int i = 0; i < nodesInCycle; i++) {
			Node current = mainQueue.remove();
			current.next = mainQueue.peek();
			
			if (current.left != null) 
				holdingQueue.add(current.left);

			if (current.right != null)	
				holdingQueue.add(current.right);
		}
		mainQueue.addAll(holdingQueue);
		nodesInCycle = mainQueue.size();
	}
}

@Ravi - That will happen if they constantly travel towards each other.

for maintaining filled slots you can also use Set. Add and remove to and from the Set. All this happens in constant time.

..and there is a general solution for (n-k)th node. start the 2nd pointer k ahead of the 1st pointer. Move them both 1 step each time. when 2nd pointer has no more moves to make, 1st has reached the required node.
In this case, k=1. so p=1, q=2.
then p=2, q=3
...
p=9, q=10.
End.

spot on dude. We can code it using back tracking. But it won't be straight forward.