就是围绕一个TODO list,不断取出并处理其中的work item。处理work item的时候,一般先做一些工作,然后可能会产生新的子work item追加到todo list,类似一个大任务分解成若干小任务。
class ToList {
public:
void append(WorkItem wi);
WorkItem fetch();
}
注意这个todo list最自然的就是一个队列,实际上只要是支持添加(push)和取出(pop)的容器都可以,queue, stack, priority_queue, random_queue都行,取决于这些子任务之间是否独立,是否有顺序上的要求。
经典例子:
1快排
todo list中的work item定义为对数组的一段[a, b]进行快排
一开始todo list只有一个任务: 快排整个数组[0, A.size() - 1],每个快排任务的处理是:
1)以第一个元素为轴进行partition
2)添加两个子快排任务到工作列表
int partition(vector<int> &A, int l, int r) {
int i = l;
for (int j = l + 1; j <= r; ++j)
if (A[j] < A[l]) swap(A[++i], A[j]);
swap(A[l], A[i]);
return i;
}
void quick_sort(vector<int> &A) {
if (A.empty()) return;
queue<pair<int, int>> q;
for (q.push(make_pair(0, A.size() - 1)); !q.empty(); q.pop()) {
int l = q.front().first, r = q.front().second;
int p = partition(A, l, r);
if (p - 1 > l) q.push(make_pair(l, p - 1));
if (p + 1 < r) q.push(make_pair(p + 1, r));
}
}
2bfs
任务定义:以s为起点进行遍历
任务处理:先打印s的数据。 然后针对s的每个邻居,(如果没被访问过),产生一个新bfs任务追加到todo list。
3进一步,todo list里的任务可以是多种任务,而且之间可以满足一定顺序,通过选用不同的容器。
经典的后序遍历问题,可以用todo list 任务列表算法很自然的表达:
def postorderTraversal(self, root):
result, todo_list = [], [(root, 1)]
if root is None: return result
while len(todo_list) > 0:
node, taskType = todo_list.pop()
if taskType == 1: # 1 for traverse job
todo_list.append((node, 0)) # 0 for basic print job
if node.right is not None: todo_list.append((node.right, 1))
if node.left is not None: todo_list.append((node.left, 1))
else: result.append(node.val)
return result
定义2种类型的task,
1) print task:打印该节点值
2) traverse task:遍历以该节点为根的树
对于第一种task的处理就是直接打印,对于第二种task,产生生成三个子task, 1个print task, 2个 traverse task,并注意task加入顺序,根, 右, 左
一开始工作列表里只有一个任务:后序遍历以root为跟的树,然后不断衍生子任务。。。
4 merge Sort
def mergeSort(A):
todo_list, aux = [(0, len(A) - 1, 0)], [0] * len(A)
while len(todo_list) > 0:
l, r, type = todo_list.pop()
if type == 0: # mergeSort task: compound task
if l < r:
todo_list.append((l, r, 1)) # merge task
todo_list.append((l, l + (r - l) / 2, 0)) # sort task
todo_list.append((l + (r - l) / 2 + 1, r, 0)) # sort task
else: # merge task: simple task
i, j, k = l, l + (r - l) / 2 + 1, l
while i <= l + (r - 1) / 2 and j <= r:
if A[i] < A[j]:
aux[k] = A[i]
i += 1
else:
aux[k] = A[j]
j += 1
k += 1
while i <= l:
aux[k] = A[i]
k, i = k + 1, i + 1
while j <= r:
aux[k] = A[j]
k, j = k + 1, j + 1
for k in xrange(l, r + 1):
A[k] = aux[k]
5全排列:
两种task:1)全排任务。2)swap 任务
def permute(A):
todoList = [(0, 0, len(A) - 1)]
while len(todoList) > 0:
taskType, l, r = todoList.pop()
if taskType == 0 and l == r: print A
elif taskType == 0:
for i in xrange(r, l - 1, -1):
todoList.append((1, l, i))
todoList.append((0, l + 1, r))
todoList.append((1, l, i))
else:
A[l], A[r] = A[r], A[l]
总结:
2种任务,终端任务和复合任务,终端任务是可以直接做的任务,复合任务是由一系列其他任务序列组成。在快排和BFS的例子中,并没有定义终端任务,因为终端任务处在任务序列前面(或者顺序无关)可以先做,不用放到todo list。而后序遍历和merge sort的例子中,终端任务不能先做,所以先压到箱底。