备机，请问RT-N13U和WL-500g Premium拆哪一个# Hardware - 计算机硬件
d*e
1 楼
一个list的节点有 next 和 random 两个指针，如何copy这个list
同学今天的ms面试题
同学今天的ms面试题
s*k
2 楼
刘翔的感情一直是备受网友粉丝关注，自从和葛天离婚后，刘翔开始和吴莎谈起了恋爱
。但是，一个是前任，一个是现任，可谓是仇人相见，分外眼红啊！这不，两个女人就
开始隔空开始撕B了，火药味道太浓了！
某网友在留言中暗讽吴莎称：输给公交车，正常，喜欢公交车的，跟你也不是
一路，撇了干净！随即，刘翔的前妻葛天回复这位网友说：看来是知情人嘛！
葛天的这句话明显是在说刘翔的现任女友吴莎，信息量相当大啊！话里的意思就是说你
吴莎是公交车！也就是因为这个话，惹怒了吴莎！葛天微博下面的评论，有抨击葛天的
，居然也有不少是支持葛天的，哈哈哈！粉丝吵得热火朝天！
10月31日晚，吴莎也在微博上做出回应：一而再再而三暗讽没意思!我今天就在这里说
明白!我吴莎没整过容、没抽过脂、没被人包养过、也没包养过人、没处心积虑骗婚、
也没想方设法骗钱、就算我哪天婚姻不幸，也不会对我前夫说“等你跟我复婚我双倍还
给你”这种屁话!以上全部，我吴莎过去不会做，将来也不会，谁做谁明白。
吴莎的这一段话也是信息量极大，愚公愚乐给大家划几个重点：第一，我吴莎
没有做过整容抽脂等；第二、自己没被人包养过，也没有包养过人，没骗婚；第三、暗
讽葛天骗婚、骗刘翔的钱。
不过，愚公愚乐在看吴莎微博评论时，被惊呆了，网友纷纷评论说：说了这么多，你究
竟是不是公交车？貌似也不是什么善茬子啊！葛天不也没说什么，你这才是暗讽！
吴莎回应后，葛天再次发微博说：实在忍无可忍，我要摸着良心对天对地的说
清楚！假孕骗婚我已重申无数次，没有！绝对没有！说做过哪怕就是有过这种想法，谁
不得好死！同样，谁制造了这个谣言也不得好死！
因为同一个男人，葛天和吴莎隔空撕B大战让不少网友见识到了女人之间战争的厉害，
谁也不让谁，寸步不让，你暗讽我，我也要对你猛击一下。到现在为止，到底有没有骗
婚，谁在骗婚，诸多绯闻想必当事人刘翔自己都搞不清楚了，更别说我们这些吃瓜群众
了。
愚公愚乐对待感情，始终是这么一个态度，分手了就分手了，别再纠缠过去了，没意思
！只会让自己更加郁闷，与其整日抑郁寡欢，还不如向前看！就算你葛天撕赢了，或者
吴莎撕赢了，又有什么意思呢？口水战，泼妇骂街，只会更加让网友对你们不屑！
。但是，一个是前任，一个是现任，可谓是仇人相见，分外眼红啊！这不，两个女人就
开始隔空开始撕B了，火药味道太浓了！
某网友在留言中暗讽吴莎称：输给公交车，正常，喜欢公交车的，跟你也不是
一路，撇了干净！随即，刘翔的前妻葛天回复这位网友说：看来是知情人嘛！
葛天的这句话明显是在说刘翔的现任女友吴莎，信息量相当大啊！话里的意思就是说你
吴莎是公交车！也就是因为这个话，惹怒了吴莎！葛天微博下面的评论，有抨击葛天的
，居然也有不少是支持葛天的，哈哈哈！粉丝吵得热火朝天！
10月31日晚，吴莎也在微博上做出回应：一而再再而三暗讽没意思!我今天就在这里说
明白!我吴莎没整过容、没抽过脂、没被人包养过、也没包养过人、没处心积虑骗婚、
也没想方设法骗钱、就算我哪天婚姻不幸，也不会对我前夫说“等你跟我复婚我双倍还
给你”这种屁话!以上全部，我吴莎过去不会做，将来也不会，谁做谁明白。
吴莎的这一段话也是信息量极大，愚公愚乐给大家划几个重点：第一，我吴莎
没有做过整容抽脂等；第二、自己没被人包养过，也没有包养过人，没骗婚；第三、暗
讽葛天骗婚、骗刘翔的钱。
不过，愚公愚乐在看吴莎微博评论时，被惊呆了，网友纷纷评论说：说了这么多，你究
竟是不是公交车？貌似也不是什么善茬子啊！葛天不也没说什么，你这才是暗讽！
吴莎回应后，葛天再次发微博说：实在忍无可忍，我要摸着良心对天对地的说
清楚！假孕骗婚我已重申无数次，没有！绝对没有！说做过哪怕就是有过这种想法，谁
不得好死！同样，谁制造了这个谣言也不得好死！
因为同一个男人，葛天和吴莎隔空撕B大战让不少网友见识到了女人之间战争的厉害，
谁也不让谁，寸步不让，你暗讽我，我也要对你猛击一下。到现在为止，到底有没有骗
婚，谁在骗婚，诸多绯闻想必当事人刘翔自己都搞不清楚了，更别说我们这些吃瓜群众
了。
愚公愚乐对待感情，始终是这么一个态度，分手了就分手了，别再纠缠过去了，没意思
！只会让自己更加郁闷，与其整日抑郁寡欢，还不如向前看！就算你葛天撕赢了，或者
吴莎撕赢了，又有什么意思呢？口水战，泼妇骂街，只会更加让网友对你们不屑！
d*g
3 楼
主机RT-N16，以前备机WL-520gU卖掉了。现有RT-N13U和WL-500g Premium
用过这两款的人能不能说说哪一个更好折腾还有性能更好？
RT-N13U应该是最老那一款（32MB/4MB），n。500gP是V2的（32MB/8MB），g
主要用来蹭无线网提供给主机当WAN2
用过这两款的人能不能说说哪一个更好折腾还有性能更好？
RT-N13U应该是最老那一款（32MB/4MB），n。500gP是V2的（32MB/8MB），g
主要用来蹭无线网提供给主机当WAN2
S*A
4 楼
1. insert a duplicated node after each node in original list
2. copy the random ptr (make it point to the next node of original
position)
3. break the list into 2 lists
【在 d**e 的大作中提到】
: 一个list的节点有 next 和 random 两个指针，如何copy这个list
: 同学今天的ms面试题
2. copy the random ptr (make it point to the next node of original
position)
3. break the list into 2 lists
【在 d**e 的大作中提到】
: 一个list的节点有 next 和 random 两个指针，如何copy这个list
: 同学今天的ms面试题
r*d
5 楼
喜欢折腾得话留500GP。8Mflash能多装不少东西如VPN，SAMBA等等.
【在 d********g 的大作中提到】
: 主机RT-N16，以前备机WL-520gU卖掉了。现有RT-N13U和WL-500g Premium
: 用过这两款的人能不能说说哪一个更好折腾还有性能更好？
: RT-N13U应该是最老那一款（32MB/4MB），n。500gP是V2的（32MB/8MB），g
: 主要用来蹭无线网提供给主机当WAN2
【在 d********g 的大作中提到】
: 主机RT-N16，以前备机WL-520gU卖掉了。现有RT-N13U和WL-500g Premium
: 用过这两款的人能不能说说哪一个更好折腾还有性能更好？
: RT-N13U应该是最老那一款（32MB/4MB），n。500gP是V2的（32MB/8MB），g
: 主要用来蹭无线网提供给主机当WAN2
h*6
6 楼
如果一棵二叉树每个节点有left, right, random三个指针，该怎么样复制呢？
y*w
7 楼
how do you have it done if the original link list is readonly? limited space
can be allocated.
【在 S******A 的大作中提到】
: 1. insert a duplicated node after each node in original list
: 2. copy the random ptr (make it point to the next node of original
: position)
: 3. break the list into 2 lists
can be allocated.
【在 S******A 的大作中提到】
: 1. insert a duplicated node after each node in original list
: 2. copy the random ptr (make it point to the next node of original
: position)
: 3. break the list into 2 lists
d*e
8 楼
yes...
当时我同学想不出来，然后面试官就提示他先不要想那么复杂忽略random指针，考虑最
简单只有next的list，先copy出来……
我跟他说了答案后，他大骂被错误引导
呵呵
【在 S******A 的大作中提到】
: 1. insert a duplicated node after each node in original list
: 2. copy the random ptr (make it point to the next node of original
: position)
: 3. break the list into 2 lists
当时我同学想不出来，然后面试官就提示他先不要想那么复杂忽略random指针，考虑最
简单只有next的list，先copy出来……
我跟他说了答案后，他大骂被错误引导
呵呵
【在 S******A 的大作中提到】
: 1. insert a duplicated node after each node in original list
: 2. copy the random ptr (make it point to the next node of original
: position)
: 3. break the list into 2 lists
S*A
9 楼
use an array to record the random index
space
【在 y****w 的大作中提到】
: how do you have it done if the original link list is readonly? limited space
: can be allocated.
space
【在 y****w 的大作中提到】
: how do you have it done if the original link list is readonly? limited space
: can be allocated.
d*e
10 楼
问得好，这个要回去想一下。
看来每题都要想一下变种的情况
【在 h**6 的大作中提到】
: 如果一棵二叉树每个节点有left, right, random三个指针，该怎么样复制呢？
看来每题都要想一下变种的情况
【在 h**6 的大作中提到】
: 如果一棵二叉树每个节点有left, right, random三个指针，该怎么样复制呢？
y*w
11 楼
same as I can. no o(1) space solution.
【在 S******A 的大作中提到】
: use an array to record the random index
:
: space
【在 S******A 的大作中提到】
: use an array to record the random index
:
: space
y*w
12 楼
也许是在引导他去搞个使用o(n)space的平凡解。
【在 d**e 的大作中提到】
: yes...
: 当时我同学想不出来，然后面试官就提示他先不要想那么复杂忽略random指针，考虑最
: 简单只有next的list，先copy出来……
: 我跟他说了答案后，他大骂被错误引导
: 呵呵
【在 d**e 的大作中提到】
: yes...
: 当时我同学想不出来，然后面试官就提示他先不要想那么复杂忽略random指针，考虑最
: 简单只有next的list，先copy出来……
: 我跟他说了答案后，他大骂被错误引导
: 呵呵
d*e
13 楼
或者是吧
他然后就算random指向的index，写完code，被说写错了，然后问了几个behavior的问
题，就完了
【在 y****w 的大作中提到】
: 也许是在引导他去搞个使用o(n)space的平凡解。
他然后就算random指向的index，写完code，被说写错了，然后问了几个behavior的问
题，就完了
【在 y****w 的大作中提到】
: 也许是在引导他去搞个使用o(n)space的平凡解。
s*a
14 楼
这个random是说 随便指这个link list里的某个node吗？
【在 d**e 的大作中提到】
: 一个list的节点有 next 和 random 两个指针，如何copy这个list
: 同学今天的ms面试题
【在 d**e 的大作中提到】
: 一个list的节点有 next 和 random 两个指针，如何copy这个list
: 同学今天的ms面试题
d*e
15 楼
这里说的index是说要你上面说的平凡解那样?比如:
p = head
while(!p)
{
p1 = head;
index = 0;
while(p->random != p1)
{ p1 = p1->next;
index++;
}
p = p->next
}
【在 y****w 的大作中提到】
: same as I can. no o(1) space solution.
p = head
while(!p)
{
p1 = head;
index = 0;
while(p->random != p1)
{ p1 = p1->next;
index++;
}
p = p->next
}
【在 y****w 的大作中提到】
: same as I can. no o(1) space solution.
d*e
16 楼
是
【在 s********a 的大作中提到】
: 这个random是说 随便指这个link list里的某个node吗？
【在 s********a 的大作中提到】
: 这个random是说 随便指这个link list里的某个node吗？
c*u
17 楼
网上找到的答案：
I would do this as a two-pass process. The first step would be to create the
complete linked list using the next pointers. At the time you are doing tha
t you'll want to construct a vector of pairs to pointers - the first pointer
being the original node in A and the second pointer being its equivalent no
de in B. The second pass of the algorithm will be to map the random pointers
in B from the original A-node pointer to their equivalent B-node pointers u
sing the map created in the firs
【在 d**e 的大作中提到】
: 一个list的节点有 next 和 random 两个指针，如何copy这个list
: 同学今天的ms面试题
I would do this as a two-pass process. The first step would be to create the
complete linked list using the next pointers. At the time you are doing tha
t you'll want to construct a vector of pairs to pointers - the first pointer
being the original node in A and the second pointer being its equivalent no
de in B. The second pass of the algorithm will be to map the random pointers
in B from the original A-node pointer to their equivalent B-node pointers u
sing the map created in the firs
【在 d**e 的大作中提到】
: 一个list的节点有 next 和 random 两个指针，如何copy这个list
: 同学今天的ms面试题
y*i
18 楼
有几点不是很明白
the
tha
pointer
第一次循环的时候并不知道vector应该开多大，总不能动态增加吧？那不是还需要一次
循环？
还有这个vector应该顺序存储pointer pairs么？那么第二次循环的时候寻找random
pointer的时候难道要再遍历寻找这个指针在vector里的位置？除非用hash table存储
pointer pairs？那空间应该需求很大了
no
pointers
u
secon
【在 c*********u 的大作中提到】
: 网上找到的答案：
: I would do this as a two-pass process. The first step would be to create the
: complete linked list using the next pointers. At the time you are doing tha
: t you'll want to construct a vector of pairs to pointers - the first pointer
: being the original node in A and the second pointer being its equivalent no
: de in B. The second pass of the algorithm will be to map the random pointers
: in B from the original A-node pointer to their equivalent B-node pointers u
: sing the map created in the firs
the
tha
pointer
第一次循环的时候并不知道vector应该开多大，总不能动态增加吧？那不是还需要一次
循环？
还有这个vector应该顺序存储pointer pairs么？那么第二次循环的时候寻找random
pointer的时候难道要再遍历寻找这个指针在vector里的位置？除非用hash table存储
pointer pairs？那空间应该需求很大了
no
pointers
u
secon
【在 c*********u 的大作中提到】
: 网上找到的答案：
: I would do this as a two-pass process. The first step would be to create the
: complete linked list using the next pointers. At the time you are doing tha
: t you'll want to construct a vector of pairs to pointers - the first pointer
: being the original node in A and the second pointer being its equivalent no
: de in B. The second pass of the algorithm will be to map the random pointers
: in B from the original A-node pointer to their equivalent B-node pointers u
: sing the map created in the firs
s*t
19 楼
vector不用事先指定大小吧？
存的是指针，和链表顺序是一一对应的，直接
for (i = 0; i < n; i++){
*node->random = arr[i];
*node = *node->next;
}
【在 y**i 的大作中提到】
: 有几点不是很明白
:
: the
: tha
: pointer
: 第一次循环的时候并不知道vector应该开多大，总不能动态增加吧？那不是还需要一次
: 循环？
: 还有这个vector应该顺序存储pointer pairs么？那么第二次循环的时候寻找random
: pointer的时候难道要再遍历寻找这个指针在vector里的位置？除非用hash table存储
: pointer pairs？那空间应该需求很大了
存的是指针，和链表顺序是一一对应的，直接
for (i = 0; i < n; i++){
*node->random = arr[i];
*node = *node->next;
}
【在 y**i 的大作中提到】
: 有几点不是很明白
:
: the
: tha
: pointer
: 第一次循环的时候并不知道vector应该开多大，总不能动态增加吧？那不是还需要一次
: 循环？
: 还有这个vector应该顺序存储pointer pairs么？那么第二次循环的时候寻找random
: pointer的时候难道要再遍历寻找这个指针在vector里的位置？除非用hash table存储
: pointer pairs？那空间应该需求很大了
y*i
20 楼
vector不事先指定大小在resize的时候效率会有影响吧？假定链表很长的情况下
这也不是大问题，大不了第一次循环可以确定链表大小，再做一次循环就可以了，也可
以在O(n)内完成。
之前的帖子里vector里说是存original list的指针对(pairs)，我还以为是对应node的
指针呢，从你的代码里看应该是对应node的random的指针，那就没有问题
不过感觉这个方法还是不如最前面的那个把copy的node放在原来node的后面然后分离的
那个方法简洁啊，那个方法不需要额外内存
【在 s*********t 的大作中提到】
: vector不用事先指定大小吧？
: 存的是指针，和链表顺序是一一对应的，直接
: for (i = 0; i < n; i++){
: *node->random = arr[i];
: *node = *node->next;
: }
这也不是大问题，大不了第一次循环可以确定链表大小，再做一次循环就可以了，也可
以在O(n)内完成。
之前的帖子里vector里说是存original list的指针对(pairs)，我还以为是对应node的
指针呢，从你的代码里看应该是对应node的random的指针，那就没有问题
不过感觉这个方法还是不如最前面的那个把copy的node放在原来node的后面然后分离的
那个方法简洁啊，那个方法不需要额外内存
【在 s*********t 的大作中提到】
: vector不用事先指定大小吧？
: 存的是指针，和链表顺序是一一对应的，直接
: for (i = 0; i < n; i++){
: *node->random = arr[i];
: *node = *node->next;
: }
j*l
21 楼
三江口内，风浪不息，铁索连舟，如履平地。
这是小尾羊同学Google最终面的一道经典题目
核心思想就是，先合后分。
先平凡复制整个链表，不考虑random指针。
充分利用random指针和next指针，把原始链表和复制的链表这两个链表关联起来。传说
中有两种连接法：一种是串成长度为2倍的新链表(类似一串珍珠)，另一种是两个平行
但竖直方向对应节点相连的链表（类似横着的梯子)
不管哪种连法，都可以方便的给random指针赋值了。
然后不要忘记把两个链表的关联断开，成为两个一样的独立链表。
这是小尾羊同学Google最终面的一道经典题目
核心思想就是，先合后分。
先平凡复制整个链表，不考虑random指针。
充分利用random指针和next指针，把原始链表和复制的链表这两个链表关联起来。传说
中有两种连接法：一种是串成长度为2倍的新链表(类似一串珍珠)，另一种是两个平行
但竖直方向对应节点相连的链表（类似横着的梯子)
不管哪种连法，都可以方便的给random指针赋值了。
然后不要忘记把两个链表的关联断开，成为两个一样的独立链表。
y*i
22 楼
等等，你的这个node是原链表的还是copy的新链表的，arr里存的应该是原链表的吧
【在 s*********t 的大作中提到】
: vector不用事先指定大小吧？
: 存的是指针，和链表顺序是一一对应的，直接
: for (i = 0; i < n; i++){
: *node->random = arr[i];
: *node = *node->next;
: }
【在 s*********t 的大作中提到】
: vector不用事先指定大小吧？
: 存的是指针，和链表顺序是一一对应的，直接
: for (i = 0; i < n; i++){
: *node->random = arr[i];
: *node = *node->next;
: }
j*l
23 楼
关于random指针是那样的，可以为NULL什么也不指，指向自身节点，指向其它节点。允
许多个random指针指向同一个节点。允许一个节点没有random指针指向它。
如果只复制链表是容易的。难点在于如何把random指针的拓扑关系也一并复制到新链表
。也就是，在原始链表和新链表中，random指针的拓扑关系是同构的。
许多个random指针指向同一个节点。允许一个节点没有random指针指向它。
如果只复制链表是容易的。难点在于如何把random指针的拓扑关系也一并复制到新链表
。也就是，在原始链表和新链表中，random指针的拓扑关系是同构的。
y*i
24 楼
第二种那个该怎么实现？
【在 j**l 的大作中提到】
: 三江口内，风浪不息，铁索连舟，如履平地。
: 这是小尾羊同学Google最终面的一道经典题目
: 核心思想就是，先合后分。
: 先平凡复制整个链表，不考虑random指针。
: 充分利用random指针和next指针，把原始链表和复制的链表这两个链表关联起来。传说
: 中有两种连接法：一种是串成长度为2倍的新链表(类似一串珍珠)，另一种是两个平行
: 但竖直方向对应节点相连的链表（类似横着的梯子)
: 不管哪种连法，都可以方便的给random指针赋值了。
: 然后不要忘记把两个链表的关联断开，成为两个一样的独立链表。
【在 j**l 的大作中提到】
: 三江口内，风浪不息，铁索连舟，如履平地。
: 这是小尾羊同学Google最终面的一道经典题目
: 核心思想就是，先合后分。
: 先平凡复制整个链表，不考虑random指针。
: 充分利用random指针和next指针，把原始链表和复制的链表这两个链表关联起来。传说
: 中有两种连接法：一种是串成长度为2倍的新链表(类似一串珍珠)，另一种是两个平行
: 但竖直方向对应节点相连的链表（类似横着的梯子)
: 不管哪种连法，都可以方便的给random指针赋值了。
: 然后不要忘记把两个链表的关联断开，成为两个一样的独立链表。
j*l
25 楼
具体细节忘记了，但是梯子的辐条是单向的。
也就是，原始链表的next指针保留，原始链表的random指针改为单向辐条指向对应的复制链表的节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某个原始链表的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以需要间接通过复制链表的next指针保留原始链表的random指针的指向信息)。接下来，先把复制链表的闲置random指指针改造到正确位置。然后考虑断开：相互辅助，有次序的从表头开始逐个恢复原始链表的random指针和复制链表的next指针。
这是一个老印想到的解法。老中发表在网上的解法，以串成两倍长度的珍珠为多，原始链表和复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题，所有人都会体会到先合后分这种思想的巧妙。
【在 y**i 的大作中提到】
: 第二种那个该怎么实现？
也就是，原始链表的next指针保留，原始链表的random指针改为单向辐条指向对应的复制链表的节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某个原始链表的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以需要间接通过复制链表的next指针保留原始链表的random指针的指向信息)。接下来，先把复制链表的闲置random指指针改造到正确位置。然后考虑断开：相互辅助，有次序的从表头开始逐个恢复原始链表的random指针和复制链表的next指针。
这是一个老印想到的解法。老中发表在网上的解法，以串成两倍长度的珍珠为多，原始链表和复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题，所有人都会体会到先合后分这种思想的巧妙。
【在 y**i 的大作中提到】
: 第二种那个该怎么实现？
h*6
26 楼
我把二叉树版本写出来了，大家研究一下：
void duplicate(BSTNode* A)
{
if(A == NULL)
return;
BSTNode* temp = new BSTNode;
temp->left = A->left;
temp->right = A->right;
A->left = temp;
A->right = NULL;
duplicate(temp->left);
duplicate(temp->right);
}
void copy(BSTNode* A)
{
if(A == NULL)
return;
BSTNode* temp = A->left;
if(A->random == NULL)
temp->random = NULL;
else
temp->random = A->random->left;
copy(temp->left);
copy(temp->righ
void duplicate(BSTNode* A)
{
if(A == NULL)
return;
BSTNode* temp = new BSTNode;
temp->left = A->left;
temp->right = A->right;
A->left = temp;
A->right = NULL;
duplicate(temp->left);
duplicate(temp->right);
}
void copy(BSTNode* A)
{
if(A == NULL)
return;
BSTNode* temp = A->left;
if(A->random == NULL)
temp->random = NULL;
else
temp->random = A->random->left;
copy(temp->left);
copy(temp->righ
d*e
27 楼
看不懂最后两句
original: A ->B-> C-> D->...
| | | |
copy: A'->B'->C'->D'->...
复制链表的random是怎么指到原始链表那里？
【在 j**l 的大作中提到】
: 具体细节忘记了，但是梯子的辐条是单向的。
: 也就是，原始链表的next指针保留，原始链表的random指针改为单向辐条指向对应的复制链表的节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某个原始链表的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以需要间接通过复制链表的next指针保留原始链表的random指针的指向信息)。接下来，先把复制链表的闲置random指指针改造到正确位置。然后考虑断开：相互辅助，有次序的从表头开始逐个恢复原始链表的random指针和复制链表的next指针。
: 这是一个老印想到的解法。老中发表在网上的解法，以串成两倍长度的珍珠为多，原始链表和复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题，所有人都会体会到先合后分这种思想的巧妙。
y*i
28 楼
是不是这样：
第一次复制的时候，让复制链表的每个结点的random指针=原始链表的相应结点的
random指针，然后让原始链表的相应结点的random指针=复制链表的那个结点的指针，
第二次遍历的时候就可以通过复制链表的random指针找到原始链表的random，再通过原
始的random找到复制的random应该指向的结点，但这个时候不能修改random的值啊，一
修改后面的结点就不能通过这个方法找了（如果后面的结点random指向前面的结点的话
），看来就需要临时把random的值存在数组里了？第三次遍历的时候再修改random，也
同时break了两个链表的关系。
那个两倍长的方法倒是比较好实现。
个老印想到的解法。老中发表在网上的解法，以串成两倍长度的珍珠为多，原始链表和
复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题，所有人
都会体会到先合后分这种思想的巧妙。
【在 j**l 的大作中提到】
: 具体细节忘记了，但是梯子的辐条是单向的。
: 也就是，原始链表的next指针保留，原始链表的random指针改为单向辐条指向对应的复制链表的节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某个原始链表的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以需要间接通过复制链表的next指针保留原始链表的random指针的指向信息)。接下来，先把复制链表的闲置random指指针改造到正确位置。然后考虑断开：相互辅助，有次序的从表头开始逐个恢复原始链表的random指针和复制链表的next指针。
: 这是一个老印想到的解法。老中发表在网上的解法，以串成两倍长度的珍珠为多，原始链表和复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题，所有人都会体会到先合后分这种思想的巧妙。
第一次复制的时候，让复制链表的每个结点的random指针=原始链表的相应结点的
random指针，然后让原始链表的相应结点的random指针=复制链表的那个结点的指针，
第二次遍历的时候就可以通过复制链表的random指针找到原始链表的random，再通过原
始的random找到复制的random应该指向的结点，但这个时候不能修改random的值啊，一
修改后面的结点就不能通过这个方法找了（如果后面的结点random指向前面的结点的话
），看来就需要临时把random的值存在数组里了？第三次遍历的时候再修改random，也
同时break了两个链表的关系。
那个两倍长的方法倒是比较好实现。
个老印想到的解法。老中发表在网上的解法，以串成两倍长度的珍珠为多，原始链表和
复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题，所有人
都会体会到先合后分这种思想的巧妙。
【在 j**l 的大作中提到】
: 具体细节忘记了，但是梯子的辐条是单向的。
: 也就是，原始链表的next指针保留，原始链表的random指针改为单向辐条指向对应的复制链表的节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某个原始链表的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以需要间接通过复制链表的next指针保留原始链表的random指针的指向信息)。接下来，先把复制链表的闲置random指指针改造到正确位置。然后考虑断开：相互辅助，有次序的从表头开始逐个恢复原始链表的random指针和复制链表的next指针。
: 这是一个老印想到的解法。老中发表在网上的解法，以串成两倍长度的珍珠为多，原始链表和复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题，所有人都会体会到先合后分这种思想的巧妙。
y*i
29 楼
应该是先把原始链表的random转存到复制链表的random里
【在 d**e 的大作中提到】
:
: 看不懂最后两句
: original: A ->B-> C-> D->...
: | | | |
: copy: A'->B'->C'->D'->...
: 复制链表的random是怎么指到原始链表那里？
【在 d**e 的大作中提到】
:
: 看不懂最后两句
: original: A ->B-> C-> D->...
: | | | |
: copy: A'->B'->C'->D'->...
: 复制链表的random是怎么指到原始链表那里？
j*l
30 楼
我修改过了。复制链表的random指针不用，而next指针指向原始链表的某个节点（由原
是链表的最初random指针决定)
original:A -> B -> C -> D->...
| | | |
copy: A' B' C' D ...
假如B的最初random指针(现在指向B'了)指向D, 则B'的next指针指向D
换句话说，复制链表的next，用来保存原始链表中的最初（变为单向辐条前）的random
指针
【在 d**e 的大作中提到】
:
: 看不懂最后两句
: original: A ->B-> C-> D->...
: | | | |
: copy: A'->B'->C'->D'->...
: 复制链表的random是怎么指到原始链表那里？
是链表的最初random指针决定)
original:A -> B -> C -> D->...
| | | |
copy: A' B' C' D ...
假如B的最初random指针(现在指向B'了)指向D, 则B'的next指针指向D
换句话说，复制链表的next，用来保存原始链表中的最初（变为单向辐条前）的random
指针
【在 d**e 的大作中提到】
:
: 看不懂最后两句
: original: A ->B-> C-> D->...
: | | | |
: copy: A'->B'->C'->D'->...
: 复制链表的random是怎么指到原始链表那里？
j*l
31 楼
修改后的做法是
原始链表的next指针保留，原始链表的random指针改为单向辐条指向对应的复制链表的
节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某个原始链表
的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以需要间接通
过复制链表的next指针保留原始链表的random指针的指向信息)。接下来，先把复制链
表的闲置random指指针改造到正确位置。然后考虑断开：相互辅助，有次序的从表头开
始逐个恢复原始链表的random指针和复制链表的next指针。
【在 d**e 的大作中提到】
:
: 看不懂最后两句
: original: A ->B-> C-> D->...
: | | | |
: copy: A'->B'->C'->D'->...
: 复制链表的random是怎么指到原始链表那里？
原始链表的next指针保留，原始链表的random指针改为单向辐条指向对应的复制链表的
节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某个原始链表
的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以需要间接通
过复制链表的next指针保留原始链表的random指针的指向信息)。接下来，先把复制链
表的闲置random指指针改造到正确位置。然后考虑断开：相互辅助，有次序的从表头开
始逐个恢复原始链表的random指针和复制链表的next指针。
【在 d**e 的大作中提到】
:
: 看不懂最后两句
: original: A ->B-> C-> D->...
: | | | |
: copy: A'->B'->C'->D'->...
: 复制链表的random是怎么指到原始链表那里？
d*e
32 楼
明白了，谢谢
random
【在 j**l 的大作中提到】
: 我修改过了。复制链表的random指针不用，而next指针指向原始链表的某个节点（由原
: 是链表的最初random指针决定)
: original:A -> B -> C -> D->...
: | | | |
: copy: A' B' C' D ...
: 假如B的最初random指针(现在指向B'了)指向D, 则B'的next指针指向D
: 换句话说，复制链表的next，用来保存原始链表中的最初（变为单向辐条前）的random
: 指针
random
【在 j**l 的大作中提到】
: 我修改过了。复制链表的random指针不用，而next指针指向原始链表的某个节点（由原
: 是链表的最初random指针决定)
: original:A -> B -> C -> D->...
: | | | |
: copy: A' B' C' D ...
: 假如B的最初random指针(现在指向B'了)指向D, 则B'的next指针指向D
: 换句话说，复制链表的next，用来保存原始链表中的最初（变为单向辐条前）的random
: 指针
r*o
33 楼
能不能详细说说老中的二倍珍珠链解法啊？
老印的解法确实很巧妙。
复制链表的节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某
个原始链表的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以
需要间接通过复制链表的nex
始链表和复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题
，所有人都会体会到先合后分这种思想的巧妙。
【在 j**l 的大作中提到】
: 具体细节忘记了，但是梯子的辐条是单向的。
: 也就是，原始链表的next指针保留，原始链表的random指针改为单向辐条指向对应的复制链表的节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某个原始链表的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以需要间接通过复制链表的next指针保留原始链表的random指针的指向信息)。接下来，先把复制链表的闲置random指指针改造到正确位置。然后考虑断开：相互辅助，有次序的从表头开始逐个恢复原始链表的random指针和复制链表的next指针。
: 这是一个老印想到的解法。老中发表在网上的解法，以串成两倍长度的珍珠为多，原始链表和复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题，所有人都会体会到先合后分这种思想的巧妙。
老印的解法确实很巧妙。
复制链表的节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某
个原始链表的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以
需要间接通过复制链表的nex
始链表和复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题
，所有人都会体会到先合后分这种思想的巧妙。
【在 j**l 的大作中提到】
: 具体细节忘记了，但是梯子的辐条是单向的。
: 也就是，原始链表的next指针保留，原始链表的random指针改为单向辐条指向对应的复制链表的节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某个原始链表的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以需要间接通过复制链表的next指针保留原始链表的random指针的指向信息)。接下来，先把复制链表的闲置random指指针改造到正确位置。然后考虑断开：相互辅助，有次序的从表头开始逐个恢复原始链表的random指针和复制链表的next指针。
: 这是一个老印想到的解法。老中发表在网上的解法，以串成两倍长度的珍珠为多，原始链表和复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题，所有人都会体会到先合后分这种思想的巧妙。
y*i
34 楼
我尝试了两个解法的代码，测试过了：
// copy a linked list with random pointer
struct NodeR
{
int val;
NodeR* next;
NodeR* random;
};
NodeR* CopyList(NodeR* head)
{
const int method = 0;
if (method == 0)
{
NodeR* head2 = NULL, *p = head, *p2 = head2;
while (p)
{
p2 = new NodeR;
p2->val = p->val;
p2->next = p->random;
p->random = p2;
p = p->next;
}
head2 = head->random;
p = head;
【在 r****o 的大作中提到】
: 能不能详细说说老中的二倍珍珠链解法啊？
: 老印的解法确实很巧妙。
:
: 复制链表的节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某
: 个原始链表的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以
: 需要间接通过复制链表的nex
: 始链表和复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题
: ，所有人都会体会到先合后分这种思想的巧妙。
// copy a linked list with random pointer
struct NodeR
{
int val;
NodeR* next;
NodeR* random;
};
NodeR* CopyList(NodeR* head)
{
const int method = 0;
if (method == 0)
{
NodeR* head2 = NULL, *p = head, *p2 = head2;
while (p)
{
p2 = new NodeR;
p2->val = p->val;
p2->next = p->random;
p->random = p2;
p = p->next;
}
head2 = head->random;
p = head;
【在 r****o 的大作中提到】
: 能不能详细说说老中的二倍珍珠链解法啊？
: 老印的解法确实很巧妙。
:
: 复制链表的节点。复制链表的random指针暂时不用，而复制链表的next指针指向的是某
: 个原始链表的节点(因为原始链表的random指针被破坏了，改造成了单向的辐条，所以
: 需要间接通过复制链表的nex
: 始链表和复制链表的对应节点为珍珠串中相邻的一对珠。这道题在国内，也是招聘名题
: ，所有人都会体会到先合后分这种思想的巧妙。
r*o
35 楼
能不能讲讲两倍长的思路啊，呵呵。
【在 y**i 的大作中提到】
: 我尝试了两个解法的代码，测试过了：
: // copy a linked list with random pointer
: struct NodeR
: {
: int val;
: NodeR* next;
: NodeR* random;
: };
: NodeR* CopyList(NodeR* head)
: {
【在 y**i 的大作中提到】
: 我尝试了两个解法的代码，测试过了：
: // copy a linked list with random pointer
: struct NodeR
: {
: int val;
: NodeR* next;
: NodeR* random;
: };
: NodeR* CopyList(NodeR* head)
: {
j*l
36 楼
老中的二倍珍珠解法，用百度搜索中文都可找到的，而且有图。
个人觉得还是老印的解法巧妙，下面具体用例子说说。
假如链表为A->B->C->D->E
A的random指向E, B的random指向D, C的random指向自身C, D和E的random都为NULL。
第一步，平凡复制原始链表，不考虑random指针（全部设为NULL)
这样得到A'->B'->C'->D'->E'，所有random都为NULL
第二步，建立连接
让A的random指向A', B的random指向B', ..., E的random指向E', 成为梯子的单向辐条。
让A'的next指向E, B'的next指向D, C'的next指向C, D'和E'的next都为NULL， 也就是
用复制链表的next保存原始链表的原始random
A->B->C->D->E
| | | | |
A' B' C' D' E'
第三步，给A', B', C', D', E'的空random指针赋值
这样A'的random指向E', B'的random指向D', C'的random指向自身C', D'和E'的random
都
个人觉得还是老印的解法巧妙，下面具体用例子说说。
假如链表为A->B->C->D->E
A的random指向E, B的random指向D, C的random指向自身C, D和E的random都为NULL。
第一步，平凡复制原始链表，不考虑random指针（全部设为NULL)
这样得到A'->B'->C'->D'->E'，所有random都为NULL
第二步，建立连接
让A的random指向A', B的random指向B', ..., E的random指向E', 成为梯子的单向辐条。
让A'的next指向E, B'的next指向D, C'的next指向C, D'和E'的next都为NULL， 也就是
用复制链表的next保存原始链表的原始random
A->B->C->D->E
| | | | |
A' B' C' D' E'
第三步，给A', B', C', D', E'的空random指针赋值
这样A'的random指向E', B'的random指向D', C'的random指向自身C', D'和E'的random
都
r*o
37 楼
呵呵，能不能给个中文链接，
我百度不出来啊。
条。
【在 j**l 的大作中提到】
: 老中的二倍珍珠解法，用百度搜索中文都可找到的，而且有图。
: 个人觉得还是老印的解法巧妙，下面具体用例子说说。
: 假如链表为A->B->C->D->E
: A的random指向E, B的random指向D, C的random指向自身C, D和E的random都为NULL。
: 第一步，平凡复制原始链表，不考虑random指针（全部设为NULL)
: 这样得到A'->B'->C'->D'->E'，所有random都为NULL
: 第二步，建立连接
: 让A的random指向A', B的random指向B', ..., E的random指向E', 成为梯子的单向辐条。
: 让A'的next指向E, B'的next指向D, C'的next指向C, D'和E'的next都为NULL， 也就是
: 用复制链表的next保存原始链表的原始random
我百度不出来啊。
条。
【在 j**l 的大作中提到】
: 老中的二倍珍珠解法，用百度搜索中文都可找到的，而且有图。
: 个人觉得还是老印的解法巧妙，下面具体用例子说说。
: 假如链表为A->B->C->D->E
: A的random指向E, B的random指向D, C的random指向自身C, D和E的random都为NULL。
: 第一步，平凡复制原始链表，不考虑random指针（全部设为NULL)
: 这样得到A'->B'->C'->D'->E'，所有random都为NULL
: 第二步，建立连接
: 让A的random指向A', B的random指向B', ..., E的random指向E', 成为梯子的单向辐条。
: 让A'的next指向E, B'的next指向D, C'的next指向C, D'和E'的next都为NULL， 也就是
: 用复制链表的next保存原始链表的原始random
j*l
38 楼
http://blog.sina.com.cn/s/blog_57e5c1640100bai6.html
【在 r****o 的大作中提到】
: 呵呵，能不能给个中文链接，
: 我百度不出来啊。
:
: 条。
【在 r****o 的大作中提到】
: 呵呵，能不能给个中文链接，
: 我百度不出来啊。
:
: 条。
S*A
39 楼
这种方法其实比较罗嗦 不推荐
条。
【在 j**l 的大作中提到】
: 老中的二倍珍珠解法，用百度搜索中文都可找到的，而且有图。
: 个人觉得还是老印的解法巧妙，下面具体用例子说说。
: 假如链表为A->B->C->D->E
: A的random指向E, B的random指向D, C的random指向自身C, D和E的random都为NULL。
: 第一步，平凡复制原始链表，不考虑random指针（全部设为NULL)
: 这样得到A'->B'->C'->D'->E'，所有random都为NULL
: 第二步，建立连接
: 让A的random指向A', B的random指向B', ..., E的random指向E', 成为梯子的单向辐条。
: 让A'的next指向E, B'的next指向D, C'的next指向C, D'和E'的next都为NULL， 也就是
: 用复制链表的next保存原始链表的原始random
条。
【在 j**l 的大作中提到】
: 老中的二倍珍珠解法，用百度搜索中文都可找到的，而且有图。
: 个人觉得还是老印的解法巧妙，下面具体用例子说说。
: 假如链表为A->B->C->D->E
: A的random指向E, B的random指向D, C的random指向自身C, D和E的random都为NULL。
: 第一步，平凡复制原始链表，不考虑random指针（全部设为NULL)
: 这样得到A'->B'->C'->D'->E'，所有random都为NULL
: 第二步，建立连接
: 让A的random指向A', B的random指向B', ..., E的random指向E', 成为梯子的单向辐条。
: 让A'的next指向E, B'的next指向D, C'的next指向C, D'和E'的next都为NULL， 也就是
: 用复制链表的next保存原始链表的原始random
y*i
40 楼
我就是用的二楼的思想，三个步骤，第一步把每个复制的结点插到原始结点的后面，第
二步把复制结点的random指向原始结点的random的下一个结点，第三步断开两个链表
【在 r****o 的大作中提到】
: 能不能讲讲两倍长的思路啊，呵呵。
二步把复制结点的random指向原始结点的random的下一个结点，第三步断开两个链表
【在 r****o 的大作中提到】
: 能不能讲讲两倍长的思路啊，呵呵。
y*i
41 楼
我还以为第二种方法就是你说的那个呢
【在 S******A 的大作中提到】
: 这种方法其实比较罗嗦 不推荐
:
: 条。
【在 S******A 的大作中提到】
: 这种方法其实比较罗嗦 不推荐
:
: 条。
p*e
42 楼
复制节点插到原始节点前面吧。。。
a'->random = a'->next->random
如果插到后面，复制节点还要反向指原始节点？
【在 y**i 的大作中提到】
: 我就是用的二楼的思想，三个步骤，第一步把每个复制的结点插到原始结点的后面，第
: 二步把复制结点的random指向原始结点的random的下一个结点，第三步断开两个链表
a'->random = a'->next->random
如果插到后面，复制节点还要反向指原始节点？
【在 y**i 的大作中提到】
: 我就是用的二楼的思想，三个步骤，第一步把每个复制的结点插到原始结点的后面，第
: 二步把复制结点的random指向原始结点的random的下一个结点，第三步断开两个链表
d*e
43 楼
你这里错了吧
如果是插到前面，a'->random应该是a->random的前一个，但你不知前一个是什么，因
为没有prev指针
插到后面， a'->random = a->random->next
【在 p*****e 的大作中提到】
: 复制节点插到原始节点前面吧。。。
: a'->random = a'->next->random
: 如果插到后面，复制节点还要反向指原始节点？
如果是插到前面，a'->random应该是a->random的前一个，但你不知前一个是什么，因
为没有prev指针
插到后面， a'->random = a->random->next
【在 p*****e 的大作中提到】
: 复制节点插到原始节点前面吧。。。
: a'->random = a'->next->random
: 如果插到后面，复制节点还要反向指原始节点？
p*e
44 楼
想了想，插到前面后面是一样的
没有本质区别
【在 d**e 的大作中提到】
: 你这里错了吧
: 如果是插到前面，a'->random应该是a->random的前一个，但你不知前一个是什么，因
: 为没有prev指针
: 插到后面， a'->random = a->random->next
没有本质区别
【在 d**e 的大作中提到】
: 你这里错了吧
: 如果是插到前面，a'->random应该是a->random的前一个，但你不知前一个是什么，因
: 为没有prev指针
: 插到后面， a'->random = a->random->next
s*a
45 楼
This is the solution that the interviewer is looking for.
【在 S******A 的大作中提到】
: 1. insert a duplicated node after each node in original list
: 2. copy the random ptr (make it point to the next node of original
: position)
: 3. break the list into 2 lists
【在 S******A 的大作中提到】
: 1. insert a duplicated node after each node in original list
: 2. copy the random ptr (make it point to the next node of original
: position)
: 3. break the list into 2 lists
r*o
46 楼
你这是什么代码？
带random指针的二叉树复制？
能不能解释一下？
【在 h**6 的大作中提到】
: 我把二叉树版本写出来了，大家研究一下：
: void duplicate(BSTNode* A)
: {
: if(A == NULL)
: return;
: BSTNode* temp = new BSTNode;
: temp->left = A->left;
: temp->right = A->right;
: A->left = temp;
: A->right = NULL;
带random指针的二叉树复制？
能不能解释一下？
【在 h**6 的大作中提到】
: 我把二叉树版本写出来了，大家研究一下：
: void duplicate(BSTNode* A)
: {
: if(A == NULL)
: return;
: BSTNode* temp = new BSTNode;
: temp->left = A->left;
: temp->right = A->right;
: A->left = temp;
: A->right = NULL;
j*u
47 楼
O(n) 2 passes without touching original list, but needs O(n) space
use a hashtable
1 pass: create a new list, random pointer points to original list. In the
meantime build the hashtable
2 pass: iterate new list and update random pointer to point to the
corresponding item in new list, with the help of hashtable
【在 d**e 的大作中提到】
: 一个list的节点有 next 和 random 两个指针，如何copy这个list
: 同学今天的ms面试题
use a hashtable
1 pass: create a new list, random pointer points to original list. In the
meantime build the hashtable
2 pass: iterate new list and update random pointer to point to the
corresponding item in new list, with the help of hashtable
【在 d**e 的大作中提到】
: 一个list的节点有 next 和 random 两个指针，如何copy这个list
: 同学今天的ms面试题
l*o
48 楼
我在ms也被问这道题目。。。
n*h
49 楼
你的第二步里的前两句需要extra space，因为原始链表的random赋值需要复制链表的
next，而复制链表的next赋值需要原始原始链表的random。你恐怕要N个临时指针。
条。
【在 j**l 的大作中提到】
: 老中的二倍珍珠解法，用百度搜索中文都可找到的，而且有图。
: 个人觉得还是老印的解法巧妙，下面具体用例子说说。
: 假如链表为A->B->C->D->E
: A的random指向E, B的random指向D, C的random指向自身C, D和E的random都为NULL。
: 第一步，平凡复制原始链表，不考虑random指针（全部设为NULL)
: 这样得到A'->B'->C'->D'->E'，所有random都为NULL
: 第二步，建立连接
: 让A的random指向A', B的random指向B', ..., E的random指向E', 成为梯子的单向辐条。
: 让A'的next指向E, B'的next指向D, C'的next指向C, D'和E'的next都为NULL， 也就是
: 用复制链表的next保存原始链表的原始random
next，而复制链表的next赋值需要原始原始链表的random。你恐怕要N个临时指针。
条。
【在 j**l 的大作中提到】
: 老中的二倍珍珠解法，用百度搜索中文都可找到的，而且有图。
: 个人觉得还是老印的解法巧妙，下面具体用例子说说。
: 假如链表为A->B->C->D->E
: A的random指向E, B的random指向D, C的random指向自身C, D和E的random都为NULL。
: 第一步，平凡复制原始链表，不考虑random指针（全部设为NULL)
: 这样得到A'->B'->C'->D'->E'，所有random都为NULL
: 第二步，建立连接
: 让A的random指向A', B的random指向B', ..., E的random指向E', 成为梯子的单向辐条。
: 让A'的next指向E, B'的next指向D, C'的next指向C, D'和E'的next都为NULL， 也就是
: 用复制链表的next保存原始链表的原始random
相关阅读
最近机器经常崩溃Intel 530 240GB 149.99!Amazon PC DIY折扣3200x1800 分辨率，很多软件显示的很小求推荐个AIO的wireless printer路由问题请问没觉得ips屏幕用起来有什么区别Crucial M500这货的UPC label在哪？WD的移动硬盘显示 the disk you inserted was not readable by (转载)crucial m500 能装到ThinkPad 440s 里么？请高人推荐Laptop PC！现在还有Freedompop的deal吗请推荐一款集成了电视棒的WIFI TVlaptop推荐显卡到了，但是我可能要装新机了。7870 @ $130 AR显示器求推荐Newegg内存降价了，赶紧的ubuntu 13.10现在好些没有有点不理解lenovo