虽然循环逻辑存在缺陷

Question

The problem is as below: Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

For example, If n = 4 and k = 2, a solution is:

[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4]
]

My Solution is:

public List<List<Integer>> combine(int n, int k) {
    Deque<List<Integer>> queue = new LinkedList<List<Integer>>();
    List<List<Integer>> result = new LinkedList<List<Integer>>();

    for (int i = 1; i <= n; i++) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(i);
        queue.add(list);
    }

    while (!queue.isEmpty()) {
        List<Integer> list = queue.pollFirst();
        if (list.size() == k)
            result.add(list);
        else {
            for (int i = list.get(list.size() - 1) + 1; i <= n; i++) {
                list.add(i);
                queue.addLast(list);
                list.remove(list.size() - 1);
            }
        }
    }
    return result;
}

However the while loop goes into a infinite loop. I have no idea what's wrong with the logic. I traced it for a couple of times but still can't find the logic flaw in this code.

Answer 1

Your problem is that you are adding the same list instance to the queue multiple times, so when you write :

            list.add(i); // suppose that list had 1 element. After adding 1,
                         // it has two elements
            queue.addLast(list); // here you add the list with 2 elements to
                                 // the queue
            list.remove(list.size() - 1); // here you remove the added element
                                          // so the list you just added
                                          // to the queue has just 1 element

The list that you added to the queue remains with the original number of elements.

You should create a new List instance before adding it to the queue :

            list.add(i);
            queue.addLast(new ArrayList<Integer>(list));
            list.remove(list.size() - 1);

Answer 2

以上while（！queue.isEmpty（））{}始终为true