d*e
2 楼
leedcode上的题目sort list
space要求O(1)
找了半天，都是recursive的方法
请哪个大牛能贴一个iterative的代码吧
谢谢
space要求O(1)
找了半天，都是recursive的方法
请哪个大牛能贴一个iterative的代码吧
谢谢
g8
3 楼
银监会2月20日讯 根据中央经济工作会议要求，为进一步严格执行放贷条件，规范和加
强信贷业务管理，保护金融消费者权益，促进贷款业务健康发展，确保银行业信贷资金
进入实体经济，以信贷结构优化促进经济结构调整，更好地支持经济平稳较快发展，近
日，中国银监会发布《流动资金贷款管理暂行办法》、《个人贷款管理暂行办法》。这
两个办法与之前已经施行的《固定资产贷款管理暂行办法》和《项目融资业务指引》（
并称“三个办法一个指引”,以下统称贷款新规），初步构建和完善了我国银行业金融
机构的贷款业务法规框架，将作为我国银行业贷款风险监管的长期制度安排，标志着我
国银行业信贷管理进入新的科学发展阶段。
银监会自2007年7月以来，按照科学发展观要求开始起草《固定资产贷款管理暂行办法
》、《流动资金贷款管理暂行办法》、《个人贷款管理暂行办法》和《项目融资业务指
引》。这“三个办法一个指引”在起草过程中，反复征求了社会各界的意见，充分借鉴
了国际通行做法，也认真考虑了我国的实际情况。其中，《固定资产贷款管理暂行办法
》和《项目融资业务指引》于2009年7月颁布，现已正式生效施行。《流动资金贷款管
理暂行办法》
强信贷业务管理，保护金融消费者权益，促进贷款业务健康发展，确保银行业信贷资金
进入实体经济，以信贷结构优化促进经济结构调整，更好地支持经济平稳较快发展，近
日，中国银监会发布《流动资金贷款管理暂行办法》、《个人贷款管理暂行办法》。这
两个办法与之前已经施行的《固定资产贷款管理暂行办法》和《项目融资业务指引》（
并称“三个办法一个指引”,以下统称贷款新规），初步构建和完善了我国银行业金融
机构的贷款业务法规框架，将作为我国银行业贷款风险监管的长期制度安排，标志着我
国银行业信贷管理进入新的科学发展阶段。
银监会自2007年7月以来，按照科学发展观要求开始起草《固定资产贷款管理暂行办法
》、《流动资金贷款管理暂行办法》、《个人贷款管理暂行办法》和《项目融资业务指
引》。这“三个办法一个指引”在起草过程中，反复征求了社会各界的意见，充分借鉴
了国际通行做法，也认真考虑了我国的实际情况。其中，《固定资产贷款管理暂行办法
》和《项目融资业务指引》于2009年7月颁布，现已正式生效施行。《流动资金贷款管
理暂行办法》
j*f
4 楼
这个不难吧？ 很多人都可以啊。
问题是怎样的3菜。鸡蛋西红柿，还是宫保鸡丁。
买好洗或者不需要洗的菜。鸡蛋都好弄。肉片可以周末切好然后放SANDWITCH BAG
里面冻上，解冻马上可以炒。甚至冻之前可以腌好酱油醋。
至少得有两个炒锅，1个汤锅。几个同时干。：）
如何高效率的做饭干家务。
【在 z*c 的大作中提到】
: 如何高效率的做饭干家务。
问题是怎样的3菜。鸡蛋西红柿，还是宫保鸡丁。
买好洗或者不需要洗的菜。鸡蛋都好弄。肉片可以周末切好然后放SANDWITCH BAG
里面冻上，解冻马上可以炒。甚至冻之前可以腌好酱油醋。
至少得有两个炒锅，1个汤锅。几个同时干。：）
如何高效率的做饭干家务。
【在 z*c 的大作中提到】
: 如何高效率的做饭干家务。
c*7
5 楼
/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode sortList(ListNode head) {
if(head == null) {
return null;
}
ListNode[] heads = new ListNode[100];
int[] counts = new int[100];
heads[0] = head;
counts[0] = 1;
ListNode next = head.next;
int index = 1;
while(next != null) {
ListNode temp = next.next;
next.next = null;
heads[index] = next;
counts[index] = 1;
for(int i=index; i>=1; i--) {
if(counts[i] == counts[i-1]) {
heads[i-1] = merge(heads[i-1], heads[i], counts[i-1],
counts[i]);
counts[i-1] *= 2;
index--;
}
else {
break;
}
}
index++;
next = temp;
}
for(int i=index-1; i>=1; i--) {
heads[i-1] = merge(heads[i-1], heads[i], counts[i-1], counts[i]);
counts[i-1] = counts[i-1] + counts[i];
}
return heads[0];
}
private ListNode merge(ListNode l, ListNode r, int leftLength, int
rightLength) {
ListNode head = null;
ListNode tail = null;
while(leftLength != 0 && rightLength != 0) {
if(l.val < r.val) {
if(head == null) {
head = l;
tail = head;
}
else {
tail.next = l;
tail = l;
}
l = l.next;
leftLength--;
}
else {
if(head == null) {
head = r;
tail = head;
}
else {
tail.next = r;
tail = r;
}
r = r.next;
rightLength--;
}
}
while(leftLength != 0) {
tail.next = l;
tail = l;
l = l.next;
leftLength--;
}
while(rightLength != 0) {
tail.next = r;
tail = r;
r = r.next;
rightLength--;
}
tail.next = null;
return head;
}
}
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode sortList(ListNode head) {
if(head == null) {
return null;
}
ListNode[] heads = new ListNode[100];
int[] counts = new int[100];
heads[0] = head;
counts[0] = 1;
ListNode next = head.next;
int index = 1;
while(next != null) {
ListNode temp = next.next;
next.next = null;
heads[index] = next;
counts[index] = 1;
for(int i=index; i>=1; i--) {
if(counts[i] == counts[i-1]) {
heads[i-1] = merge(heads[i-1], heads[i], counts[i-1],
counts[i]);
counts[i-1] *= 2;
index--;
}
else {
break;
}
}
index++;
next = temp;
}
for(int i=index-1; i>=1; i--) {
heads[i-1] = merge(heads[i-1], heads[i], counts[i-1], counts[i]);
counts[i-1] = counts[i-1] + counts[i];
}
return heads[0];
}
private ListNode merge(ListNode l, ListNode r, int leftLength, int
rightLength) {
ListNode head = null;
ListNode tail = null;
while(leftLength != 0 && rightLength != 0) {
if(l.val < r.val) {
if(head == null) {
head = l;
tail = head;
}
else {
tail.next = l;
tail = l;
}
l = l.next;
leftLength--;
}
else {
if(head == null) {
head = r;
tail = head;
}
else {
tail.next = r;
tail = r;
}
r = r.next;
rightLength--;
}
}
while(leftLength != 0) {
tail.next = l;
tail = l;
l = l.next;
leftLength--;
}
while(rightLength != 0) {
tail.next = r;
tail = r;
r = r.next;
rightLength--;
}
tail.next = null;
return head;
}
}
x*s
6 楼
要方便就做荤菜的汤，什么排骨汤，鸡汤，牛肉西红柿汤，有营养又好喝，还饱肚子，
然后快速炒2个素菜，肉片切好3天的量，油爆好备用，其实每天切点肉丝也挺快的，如
果从健康角度考虑的话，然后肉片可以搭很多菜，什么肉片花菜啊，麻婆豆腐啊，肉片
西蓝花啊，肉片土豆啊，
偷懒就去costco买点素菜色拉，每次拌点色拉也很方便。。。。
汤要提早最起码2小时做才好哦，不过放水里后就不用管了，方便
【在 z*c 的大作中提到】
: 如何高效率的做饭干家务。
然后快速炒2个素菜，肉片切好3天的量，油爆好备用，其实每天切点肉丝也挺快的，如
果从健康角度考虑的话，然后肉片可以搭很多菜，什么肉片花菜啊，麻婆豆腐啊，肉片
西蓝花啊，肉片土豆啊，
偷懒就去costco买点素菜色拉，每次拌点色拉也很方便。。。。
汤要提早最起码2小时做才好哦，不过放水里后就不用管了，方便
【在 z*c 的大作中提到】
: 如何高效率的做饭干家务。
c*7
7 楼
顺便请教一下recrusive怎么做？
c*d
8 楼
恩的，最关键还是第一步，买处理步骤尽可能简单的菜。因为菜一旦下锅开烧，就很容
易几个锅同步操作了；但是预处理步骤必须一样样来，时间省不了。所以我的大原则嘛
，蔬菜直接买色拉用的，肉类买切成小块或者丝或者片的，洋葱可以买洋葱丁，大蒜可
以买蒜蓉。其次就是时间上头的安排，烧得最久的东西最早下锅。
【在 j**f 的大作中提到】
: 这个不难吧？ 很多人都可以啊。
: 问题是怎样的3菜。鸡蛋西红柿，还是宫保鸡丁。
: 买好洗或者不需要洗的菜。鸡蛋都好弄。肉片可以周末切好然后放SANDWITCH BAG
: 里面冻上，解冻马上可以炒。甚至冻之前可以腌好酱油醋。
: 至少得有两个炒锅，1个汤锅。几个同时干。：）
:
: 如何高效率的做饭干家务。
易几个锅同步操作了；但是预处理步骤必须一样样来，时间省不了。所以我的大原则嘛
，蔬菜直接买色拉用的，肉类买切成小块或者丝或者片的，洋葱可以买洋葱丁，大蒜可
以买蒜蓉。其次就是时间上头的安排，烧得最久的东西最早下锅。
【在 j**f 的大作中提到】
: 这个不难吧？ 很多人都可以啊。
: 问题是怎样的3菜。鸡蛋西红柿，还是宫保鸡丁。
: 买好洗或者不需要洗的菜。鸡蛋都好弄。肉片可以周末切好然后放SANDWITCH BAG
: 里面冻上，解冻马上可以炒。甚至冻之前可以腌好酱油醋。
: 至少得有两个炒锅，1个汤锅。几个同时干。：）
:
: 如何高效率的做饭干家务。
d*e
9 楼
谢谢
recursive
不就是先找到中点
然后分别mergesort左边和右边
然后再合并？
【在 c*******7 的大作中提到】
: 顺便请教一下recrusive怎么做？
recursive
不就是先找到中点
然后分别mergesort左边和右边
然后再合并？
【在 c*******7 的大作中提到】
: 顺便请教一下recrusive怎么做？
m*n
10 楼
没用，有人天生就磨叽。
【在 z*c 的大作中提到】
: 如何高效率的做饭干家务。
【在 z*c 的大作中提到】
: 如何高效率的做饭干家务。
c*7
11 楼
那样应该需要O(n^3)了吧？用Bubble sort更快一些。
n*3
12 楼
我一般是准备4菜一汤 - 两荤两素。5：30 - 6：00备菜，6：30 - 7：00上锅作（中间
半小时小孩要吃奶，不能搞出动静）
今日菜谱：
卤肉 - 一次卤多块 - 一天切一块 - 这解决了一荤。
生爆盐煎肉 - 搞肉丝比较麻烦，所以我主要以肉片类为主
糖醋白菜
炒芦笋
酸菜番茄鱼片汤 - 一备菜时就把汤熬上（先不下鱼），到开始炒菜时下鱼两分钟就可
起锅。
我的心得是要并行，尽量作刀工简单的菜
半小时小孩要吃奶，不能搞出动静）
今日菜谱：
卤肉 - 一次卤多块 - 一天切一块 - 这解决了一荤。
生爆盐煎肉 - 搞肉丝比较麻烦，所以我主要以肉片类为主
糖醋白菜
炒芦笋
酸菜番茄鱼片汤 - 一备菜时就把汤熬上（先不下鱼），到开始炒菜时下鱼两分钟就可
起锅。
我的心得是要并行，尽量作刀工简单的菜
d*e
13 楼
ListNode *sortList(ListNode *head) {
// IMPORTANT: Please reset any member data you declared, as
// the same Solution instance will be reused for each test case.
if(head == NULL || head->next == NULL) {
return head;
}
ListNode* mid = head;
ListNode* end = head;
while(end->next){
end = end->next;
if (end->next == NULL)
break;
end = end->next;
mid = mid->next;
}
ListNode* right = mid->next;
mid->next = NULL;
mid = right;
ListNode* left = sortList(head);
right = sortList(mid);
ListNode* dummy = new ListNode(1);
ListNode* tail = dummy;
while(left && right){
if (left->val < right->val){
tail->next = left;
left = left->next;
}
else{
tail->next = right;
right = right->next;
}
tail = tail->next;
}
if (left)
tail->next = left;
if (right)
tail->next = right;
return dummy->next;
}
【在 c*******7 的大作中提到】
: 那样应该需要O(n^3)了吧？用Bubble sort更快一些。
// IMPORTANT: Please reset any member data you declared, as
// the same Solution instance will be reused for each test case.
if(head == NULL || head->next == NULL) {
return head;
}
ListNode* mid = head;
ListNode* end = head;
while(end->next){
end = end->next;
if (end->next == NULL)
break;
end = end->next;
mid = mid->next;
}
ListNode* right = mid->next;
mid->next = NULL;
mid = right;
ListNode* left = sortList(head);
right = sortList(mid);
ListNode* dummy = new ListNode(1);
ListNode* tail = dummy;
while(left && right){
if (left->val < right->val){
tail->next = left;
left = left->next;
}
else{
tail->next = right;
right = right->next;
}
tail = tail->next;
}
if (left)
tail->next = left;
if (right)
tail->next = right;
return dummy->next;
}
【在 c*******7 的大作中提到】
: 那样应该需要O(n^3)了吧？用Bubble sort更快一些。
f*r
14 楼
用好准备的材料就行了。
炖半只鸡。
准备大虾，芹菜，土豆，西红柿，鸡蛋，黄瓜，肉片。
做一个肉片炒土豆
大虾炒芹菜
鸡炖好后，做一个手撕鸡拌黄瓜丝，
用鸡汤加点水做一个西红柿鸡蛋汤。
还有，如果不想浪费时间，就做混搭的菜，就是一道菜里有多样菜和肉，这样既营养均衡用省事。
比如可以炖鸡后，在鸡汤里汆入猪肉丸子，加上木耳，白菜，豆腐或油豆腐，蘑菇。这样做好，又有
汤，又有菜。拌米饭吃很好。
还可以做乱炖什么的。也是一个道理。
炖半只鸡。
准备大虾，芹菜，土豆，西红柿，鸡蛋，黄瓜，肉片。
做一个肉片炒土豆
大虾炒芹菜
鸡炖好后，做一个手撕鸡拌黄瓜丝，
用鸡汤加点水做一个西红柿鸡蛋汤。
还有，如果不想浪费时间，就做混搭的菜，就是一道菜里有多样菜和肉，这样既营养均衡用省事。
比如可以炖鸡后，在鸡汤里汆入猪肉丸子，加上木耳，白菜，豆腐或油豆腐，蘑菇。这样做好，又有
汤，又有菜。拌米饭吃很好。
还可以做乱炖什么的。也是一个道理。
c*w
15 楼
是O(nlogn)
每一层recursion的总复杂度是O(n)
一共有O(logn)层
【在 c*******7 的大作中提到】
: 那样应该需要O(n^3)了吧？用Bubble sort更快一些。
每一层recursion的总复杂度是O(n)
一共有O(logn)层
【在 c*******7 的大作中提到】
: 那样应该需要O(n^3)了吧？用Bubble sort更快一些。
i*e
16 楼
4/5菜1汤，荤素搭配，20分钟搞定，诀窍是周末做煮煮炖炖费时费力的活儿，比如要煮
3小时的猪蹄，棒骨，牛腱肉等，弄出肉汤和熟肉，Freezer常准备些速冻食比如几磅去
过头和虾线的大虾，分类装好冰箱，平时下班回家光是洗切，快炒、凉拌，4、5个菜加
个汤，20分钟肯定搞定，炒菜前先把米饭放微波炉里，饭好了焖一会儿菜也就炒好了，
要是吃牛肉面速冻饺什么的还不用20分钟。哦，还有，平时去超市买菜的时候或者和父
母打电话的时候趁机熟悉各种菜的特性，了解怎么做又快又营养，实践多了买菜的时候
脑子几秒钟半分钟基本一周的菜谱就勾画出来了，就知道买什么了。偶开始也总扔菜，
现在一周过后除了一些后备粮基本冰箱就吃空了，很少再扔东西。
嗯，冰箱一定要干净整洁有秩序，不光是个好坏习惯问题，是个效率问题。
3小时的猪蹄，棒骨，牛腱肉等，弄出肉汤和熟肉，Freezer常准备些速冻食比如几磅去
过头和虾线的大虾，分类装好冰箱，平时下班回家光是洗切，快炒、凉拌，4、5个菜加
个汤，20分钟肯定搞定，炒菜前先把米饭放微波炉里，饭好了焖一会儿菜也就炒好了，
要是吃牛肉面速冻饺什么的还不用20分钟。哦，还有，平时去超市买菜的时候或者和父
母打电话的时候趁机熟悉各种菜的特性，了解怎么做又快又营养，实践多了买菜的时候
脑子几秒钟半分钟基本一周的菜谱就勾画出来了，就知道买什么了。偶开始也总扔菜，
现在一周过后除了一些后备粮基本冰箱就吃空了，很少再扔东西。
嗯，冰箱一定要干净整洁有秩序，不光是个好坏习惯问题，是个效率问题。
x*g
17 楼
http://yihuad.blogspot.com/2013/11/sort-list-leetcode.html
【在 c*******7 的大作中提到】
: 顺便请教一下recrusive怎么做？
【在 c*******7 的大作中提到】
: 顺便请教一下recrusive怎么做？
i*e
18 楼
还有，偶不主张提前切菜，营养流失是一个，味道也很不好，偶以前买过切好的的净菜
直接下锅那种，巨难吃，有些步骤还是不能省。
不一定每天都炒菜啊，馄饨又简单又好吃，如果俩人吃，十多分钟也搞定了，前提是肉
馅提前拿出来化冻，皮子是买现成的。回家先把一只小鸡加姜片料酒扔锅里煮汤，然后
办好肉馅包就是了，如果包多了，还可以把多余的冻起来下次吃。煮馄饨的同时就可以
准备碗，鸡丝紫菜虾皮榨菜末盐酱醋。。。
直接下锅那种，巨难吃，有些步骤还是不能省。
不一定每天都炒菜啊，馄饨又简单又好吃，如果俩人吃，十多分钟也搞定了，前提是肉
馅提前拿出来化冻，皮子是买现成的。回家先把一只小鸡加姜片料酒扔锅里煮汤，然后
办好肉馅包就是了，如果包多了，还可以把多余的冻起来下次吃。煮馄饨的同时就可以
准备碗，鸡丝紫菜虾皮榨菜末盐酱醋。。。
p*o
19 楼
def mergesort_topdown (aList):
""" Top-down merge sort.
A total of logn splits;
in each split we merge n items.
So the complexity is O(n logn).
"""
_splitmerge (aList, 0, len(aList))
def _splitmerge (aList, i, j):
""" Recursively split runs into two halves
until run size == 1 (considered sorted), then
merge two halves and return back up the call chain.
"""
if j - i > 1:
m = (i + j) // 2
_splitmerge (aList, i, m)
_splitmerge (aList, m, j)
_merge (aList, i, m, j)
def mergesort_bottomup (aList):
""" The bottom-up version of merge sort.
w = 1, 2, 4, 8, ...,
Pay attention to how the bounds are chosen.
"""
n = len(aList)
w = 1 # width
while w < n:
i = 0
while i < n:
k = min(n, i + w) # mid
j = min(n, i + w*2)
if j - i >= 2:
_merge (aList, i, k, j)
i += w * 2
w *= 2
def _merge (a, i, m, j):
b = [None] * (j-i)
ii, jj = i, m
for k in xrange(j-i):
if ii < m and (jj >= j or
a[ii] <= a[jj]):
b[k] = a[ii]
ii += 1
else:
b[k] = a[jj]
jj += 1
a[i:j] = b
if __name__ == '__main__':
a = [54,20,93,17,77,31,44,55,20]
mergesort_topdown (a)
print a
a = [54,20,93,17,77,31,44,55,20]
mergesort_bottomup (a)
print a
""" Top-down merge sort.
A total of logn splits;
in each split we merge n items.
So the complexity is O(n logn).
"""
_splitmerge (aList, 0, len(aList))
def _splitmerge (aList, i, j):
""" Recursively split runs into two halves
until run size == 1 (considered sorted), then
merge two halves and return back up the call chain.
"""
if j - i > 1:
m = (i + j) // 2
_splitmerge (aList, i, m)
_splitmerge (aList, m, j)
_merge (aList, i, m, j)
def mergesort_bottomup (aList):
""" The bottom-up version of merge sort.
w = 1, 2, 4, 8, ...,
Pay attention to how the bounds are chosen.
"""
n = len(aList)
w = 1 # width
while w < n:
i = 0
while i < n:
k = min(n, i + w) # mid
j = min(n, i + w*2)
if j - i >= 2:
_merge (aList, i, k, j)
i += w * 2
w *= 2
def _merge (a, i, m, j):
b = [None] * (j-i)
ii, jj = i, m
for k in xrange(j-i):
if ii < m and (jj >= j or
a[ii] <= a[jj]):
b[k] = a[ii]
ii += 1
else:
b[k] = a[jj]
jj += 1
a[i:j] = b
if __name__ == '__main__':
a = [54,20,93,17,77,31,44,55,20]
mergesort_topdown (a)
print a
a = [54,20,93,17,77,31,44,55,20]
mergesort_bottomup (a)
print a
p*o
20 楼
哦，是特指那道leetcode链表题啊。我以为是通用的排序算法，就直接copy/paste了。
相关阅读