收到ＮＦＬ卡了 - 未名空间MITBBS历史存档

国际科技财经博客移民网络热点娱乐民生时事公众号

Redian新闻

>未名空间

>Money - 海外理财

收到ＮＦＬ卡了

收到ＮＦＬ卡了# Money - 海外理财

s*m2012-10-10 07:10

1 楼

【以下文字转载自 TVChinese 讨论区】
发信人: scidem (哈佛学渣), 信区: TVChinese
标题: 【合集】奥斯卡89部最佳影片荟萃(1928-2017) (转载)
发信站: BBS 未名空间站 (Thu Feb 16 21:36:26 2017, 美东)
发信人: scidem (哈佛学渣), 信区: Movie
标题: 【合集】奥斯卡89部最佳影片荟萃(1928-2017)
发信站: BBS 未名空间站 (Thu Feb 16 21:35:14 2017, 美东)

b*i2012-10-10 07:10

2 楼

想去店里订个生日蛋糕，icing有两种选择：whipped cream和buttercream。不知道那
种死甜死甜的是不是buttercream?是不是whipped cream就没那么甜？
谢谢！

m*g2012-10-10 07:10

3 楼

虽然worst－case quicksort是O(n^2), 但是on avarage, quicksort 为什么会比
heapsort 快呢？

d*l2012-10-10 07:10

4 楼

B*n2012-10-10 07:10

5 楼

甜不甜主要看那个店家，buttercream的好成型，方面运输和存放

c*72012-10-10 07:10

6 楼

移位少吧。

B*e2012-10-10 07:10

7 楼

没有自己喜欢的队

【在 d**l 的大作中提到】

b*i2012-10-10 07:10

8 楼

谢谢回复！我后来去问店家了，他们家的是whipped cream比较不甜。

【在 B********n 的大作中提到】

: 甜不甜主要看那个店家，buttercream的好成型，方面运输和存放

P*a2012-10-10 07:10

9 楼

实战中和cache结合得好

【在 m********g 的大作中提到】

: 虽然worst－case quicksort是O(n^2), 但是on avarage, quicksort 为什么会比
: heapsort 快呢？

z*l2012-10-10 07:10

10 楼

go Patriots go

【在 B*********e 的大作中提到】

: 没有自己喜欢的队

h*d2012-10-10 07:10

11 楼

因为inner loop效率高

y*i2012-10-10 07:10

12 楼

you can just choose NFL
you don't have to pick a particular team

【在 B*********e 的大作中提到】

: 没有自己喜欢的队

m*g2012-10-10 07:10

13 楼

指的是哪一个inner loop?

【在 h**********d 的大作中提到】

: 因为inner loop效率高

h*o2012-10-10 07:10

14 楼

Expected complexity是O(nlogn), partition很精简常数小， in-place, 每次逐个扫
数据
(cache miss少)

【在 m********g 的大作中提到】

: 虽然worst－case quicksort是O(n^2), 但是on avarage, quicksort 为什么会比
: heapsort 快呢？

s*x2012-10-10 07:10

15 楼

// MaxHeap: heapArray starts from index 0
public static void heapSort(int[] a){
// Trickling Down in Place: start at node n/2-1, the rightmost node
with children
// O(n/2*log(n))
for (int i=(a.length/2-1) ; i>=0 ; i--)
trickleDown(a,i, a.length);
// remove max from heap and insert it at the end
// O(n*log(n))
for (int i= a.length - 1; i> 0; i--){
int max = a[0];
a[0] = a[i];
trickleDown(a,0, i);
a[i] = max;
}

}
// the number of levels L in a binary tree equals log2(n+1), where n is the
number of nodes.
// trickleUp() takes time proportional to log2(n), and trickleDown()
takes
// somewhat more it needs two comparisons
private static void trickleUp(int[] heapArray, int i){
if (i>=heapArray.length)
System.err.println("index exceeding the size of the heap");
int parent = (i - 1)/2;
while( i > 0 && heapArray[parent]< heapArray[i]) {
swap(heapArray, parent, i);
i = parent;
parent = (parent - 1)/2;
}
}

private static void trickleDown(int[] a, int i, int size){
// size = a.length
// the last element is a[size-1] and its parent is a[size/2-1]
while( i < size/2 ){
int leftChild = 2*i + 1;
int rightChild = leftChild + 1;
int largerChild;
if (rightChild < size // rightChild exists?
&& a[leftChild]largerChild = rightChild;
else
largerChild = leftChild;
if (a[i]>=a[largerChild])
break;
swap(a, i, largerChild);
i = largerChild;
}
}

【在 m********g 的大作中提到】

: 指的是哪一个inner loop?

s*x2012-10-10 07:10

16 楼

heapSort is n/2*log(1.5n)+n*log(1.5n)
quickSort is nlog(n)

node

【在 s********x 的大作中提到】

: // MaxHeap: heapArray starts from index 0
: public static void heapSort(int[] a){
: // Trickling Down in Place: start at node n/2-1, the rightmost node
: with children
: // O(n/2*log(n))
: for (int i=(a.length/2-1) ; i>=0 ; i--)
: trickleDown(a,i, a.length);
: // remove max from heap and insert it at the end
: // O(n*log(n))
: for (int i= a.length - 1; i> 0; i--){