如果分类之间的父级关系形成闭环，那么从该闭环中的任意一个分类节点不断向上寻找父分类的过程中，一定是可以最终回到起始分类节点的，利用这一点可以得到简单的闭环检测方法：

def check_loop(category):
____parent = category.get_parent()
____while parent is not None:
________if parent == category:
____________return True
________category = parent
________parent = category.get_parent()
____return False

此时 start_urls 初始化为列表页的首页 url 即可，
不必关心总页数到底有多少，该写法比较通用

去页面里解析翻取下一页的 link ，然后递归调用 parse 方法即可:

def parse(self, response):
____# parse the page and yield items
____next_page = response.xpath("some link element for the next page")
____if next_page is not None:
________url_next_page = next_page.get_url()
________yield scrapy.Request(url_next_page, self.parse)

@zeal7s 数组也无妨，思路是一样的。不过按照以往的经验，一般此类问题多以链表为主，因为对链表查询的好处是可以记录节点指针，这样为了查询出堆元素所在链表的下一个元素只需将指针后移即可。而数组显然做不到这个。

这个题，有这么几个需要注意的点吧：
1 ）题中所给的是 n 个有序链表，因此在归并排序时要充分利用这一点，少做无用功
2 ）题中要求了，同一链表内出现的重复数字只能计为 1 次，因此最后的输出结果一定要满足这一条件

那么事实上，主要工作就是怎么对这 n 个有序链表进行归并了，而这一问题还算是一个比较经典的问题，
简而述之，不妨假设有序链表均为升序排列，为此维护一个空间复杂度为 O(n)的最小堆即可。若是假设平均每个链表长度为 m 的话，时间复杂度上也是比较可观的，可以控制在 O(nmlgn)。

初始化时，将 n 个链表的头部元素入堆，此时堆顶即当前 n 个有序链表的最小元素。那么，只要最小堆不空，就不断的弹出堆顶元素输出到归并结果序列。需要注意的是，每次在弹出 1 个堆顶元素时，随即需要入堆 1 个元素，入堆的那个元素即弹出元素所在链表的下一个元素。这一点不难理解，只不过这里就有一个 trick ，为了满足条件 2 ）所要求的，在寻找下一个入堆元素时，若是弹出元素所在链表不空时，要注意略过和弹出元素值相同的那些元素，直到找到第一个与弹出元素值不同的元素入堆。以确保可以维护这一性质，即最小堆堆顶保存的始终是当前 n 个有序链表中最小的那个元素值。

最后，当最小堆中的元素全部出堆，输出得到的序列即归并以后的有序结果序列，而这一序列中也已排除那些因为出现于同一有序链表中而重复计入的元素次数。因为归并后的结果序列已然有序，因此相同元素必定相邻，那么剩下的事就变得简单多了，只要最后遍历一下这个结果序列，时间代价 O(mn)，利用两个变量，一个保存当前元素值，一个作为计数器，便可找到那些出现次数大于 K 的元素。找到以后，把这些元素按照出现次数再排序一番即是原题所求。

综上所述，这种方法的时间代价是 O(nmlgn)，空间代价也较小，控制在 O(n)左右，楼主不妨参考。

更倾向于方法 2 ，对订单业务数据表和统计数据表进行分离。

可以基于业务数据表每天的最新数据，每天同步写一份日志，统计数据表基于该日志统计并输出。

另外，针对订单状态时有变化的情况，在统计时需要维护一份历史订单的最新状态文件，每次统计时一旦发现历史订单的状态发生变化，就要同步更新统计结果数据（因为这可能牵涉到退款以及订单金额的统计）。

最后，针对楼主考虑到的两边统计数据不一致的状况，可以另外开发一个简单的异步对单任务，对业务数据表的数据和统计数据表的数据每日进行一次对帐，当然考虑到可能需要全表扫描业务数据表，因此在非业务高峰期调度对单任务较宜。

这个回帖过滤代码缩进真是闹心啊，站主是不是可以考虑加一个代码缩进和高亮啊？

def find(s):
____ret = []
____if s is None or len(s) == 0:
________return ret
____start = 0
____curr = s[0]
____for i in range(0, len(s)):
________if s[i] != curr:
____________ret.append((start+1, i))
____________start = i
____________curr = s[i]
____________if i == len(s) - 1:
________________ret.append((start+1, len(s)))
________else:
____________if i == len(s) - 1:
________________ret.append((start+1, len(s)))
____return ret

def find(s):
ret = []
if s is None or len(s) == 0:
return ret
start = 0
curr = s[0]
for i in range(0, len(s)):
if s[i] != curr:
ret.append((start+1, i))
start = i
curr = s[i]
if i == len(s) - 1:
ret.append((start+1, len(s)))
else:
if i == len(s) - 1:
ret.append((start+1, len(s)))
return ret


算法上没有特别之处，只是处理一些边界 case 时要细致一些，提供一些测试用例

find("")


find("10")
(1, 1)
(2, 2)

find("1111")
(1, 4)

find("1")
(1, 1)

find("11111111000001111101111100000001111")
(1, 8)
(9, 13)
(14, 18)
(19, 19)
(20, 24)
(25, 31)
(32, 35)

void countingSort(int array[], int arraySize, int result[], int k) {
int * countArray = (int *)malloc((k + 1) * sizeof(int));
int countArraySize = k + 1;

for (int i = 0; i < countArraySize; i++) {
countArray[i] = 0;
}

for (int i = 0; i < arraySize; i++) {
countArray[array[i]]++;
}

for (int i = 1; i < countArraySize; i++) {
countArray[i] += countArray[i - 1];
}

for (int i = arraySize - 1; i >= 0; i--) {
result[--countArray[array[i]]] = array[i];

}

countArray[i] 表示原数组中小于等于 i 的元素个数，因此 i 在结果数组 result 中的位置应该就是 countArray[i] - 1 。

对图片进行了文字识别然后参与了全文搜索吧

http://www.ietf.org/rfc/rfc2616.txt

refer to 14-Header Field Definitions

可能还需要用到的几个组件或者模块，比如session（用户会话状态记录）、orm（关系型数据实例对象化）以及cache（必要的缓存机制），另外可能还需要一些三方的邮件服务、文件存储服务（比如图片的存储）、全文检索服务等等，仅供楼主参考。

看准一只股票就all in吧，年轻人！

非递归不难实现，用一个栈就可解。
初始化时，将根节点入栈。
每次弹出栈顶元素（如果有），swap该元素的左右孩子节点（如果有孩子节点，注意左右孩子节点是否均存在），
然后依次把swap之后的左右孩子节点（如果存在）重新压回栈内。
重复上述操作，直到栈空，done。
递归实现的话，就更符合人类思维的自然逻辑了，此处skip。

一个经典的topK问题，这里N = 40w，K = 200，
全量排序再取topK的代价是O(NlgN)，另外，全量排序的内存开销至少是O(N)，不是最优解，可进一步优化。
这里因为要找前topK大，可以为此维护一个最小堆，堆的size始终维护为K，
（1）初始化最小堆，顺序扫描所有N个值中的前K个，将K个入堆
（2）顺序扫描剩余N - K个值，发现比最小堆堆顶小时，不必入堆（必定不是topK大）；
若发现比最小堆堆顶大时，弹出当前堆顶，并入堆这一新值。
以上时间代价O(NlgK)，空间代价O(K)

@xxxpara 另外数组应该至少有9个元素，外部x迭代值的边界条件也需要更正一下，再次更正一下两个方案 :)

方案一：
int Y[9] = {1, 2, 4, 6, 6, 6, 4, 2, 1}

for (int x = 0; x < 9; x++) {
int y = Y[x];
// do something else
}


方案二：
int Y(int x) {
if (6 <= x && x <= 8) {
x = 8 - x;
}
if (0 <= x && x <= 2) {
return power(2, x);
}
return 6;
}

for (int x = 0; x < 9; x++) {
int y = Y(x);
// do something else
}

@miterleo 多谢指正，粗心大意了 :)
@xxxpara 方案二的Y()可能实现的有些小问题，简单更正一下，

int Y(int x) {
if (6 <= x && x <= 8) {
x = 8 - x;
}
if (0 <= x && x <= 2) {
return power(2, x);
}
return 6;
}

方案一：预置一个类似映射关系的数组，计算过程直接读取
int Y[8] = {1, 2, 4, 6, 6, 6, 4, 2, 1}
for (int x = 0; x < 8; x++) {
int y = Y[x];
}

方案二：尝试建立动态的映射关系，计算过程中动态执行计算
int Y(int x) {
if (0 <= (x%8) && (x%8) <= 2) {
return power(2, x%8);
}
return 6;
}
for (int x = 0; x < 8; x++) {
int y = Y(x);
}

以上，就是简单的两种思路吧，
方案一基于空间换时间的思想，
可以节省相应的映射计算开销，保证较好的查询效率；

方案二基于时间换空间的思想，
如果可以找到比较高效的映射函数，
一方面不会浪费存储资源，另一方面也可以实现较好的执行效率

本硕都是 CS专业，
本科期间做了一个基于GAE的教学资源管理平台，偏工程应用，部分内容发表于第278期《中国教育信息化》学术期刊（2012年），
硕士期间的研究方向是ITS（智能交通），最后的毕业论文是一个智能交通流的调度算法，部分内容发表于第9届Mobile Ad-hoc and Sensor Networks国际学术会议（2013年），改论文已由Peter Stone教授2015年的最新发表文章引用（有关Stone教授可参见 http://www.cs.utexas.edu/~pstone/）。