• —软件人才免语言低担保 赴美带薪读研！—

* soft nofile 65535
* hard nofile 65535

编辑文件/etc/sysctl.conf，添加以下参数：

vm.overcommit_memory = 1

如果服务器装有Redis，这个参数一定要加，不然Redis有很大的可能无法同步数据到磁盘。

把所有带backlog的参数的值调大，如：

net.ipv4.tcp_max_syn_backlog = 65535

由原来的1024改成10240，队列容纳的最大半连接数。

net.core.netdev_max_backlog = 65535

net.core.somaxconn = 65535

net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1

随着 大量默认选项的改进, MySQL 5.6比以前版本需要调优的选项大为减少. 在本文中我将讲述需要优化的配置项.

• innodb_buffer_pool_size  —— 默认值为 128M. 这是最主要的优化选项,因为它指定 InnoDB 使用多少内存来加载数据和索引(data+indexes). 针对专用MySQL服务器,建议指定为物理内存的 50-80%这个范围. 例如,拥有64GB物理内存的机器,缓存池应该设置为50GB左右. 
  如果将该值设置得更大可能会存在风险,比如没有足够的空闲内存留给操作系统和依赖文件系统缓存的某些MySQL子系统(subsystem),包括二进制日志(binary logs),InnoDB事务日志(transaction logs)等.
• innodb_log_file_size —— 默认值为 48M. 有很高写入吞吐量的系统需要增加该值以允许后台检查点活动在更长的时间周期内平滑写入,得以改进性能. 将此值设置为4G以下是很安全的. 过去的实践表明,日志文件太大的缺点是增加了崩溃时所需的修复时间,但这在5.5和5.6中已得到重大改进.
• innodb_flush_method  —— 默认值为 fdatasync. 如果使用 硬件RAID磁盘控制器, 可能需要设置为 O_DIRECT. 这在读取InnoDB缓冲池时可防止“双缓冲(double buffering)”效应,否则会在文件系统缓存与InnoDB缓存间形成2个副本(copy). 
  如果不使用硬件RAID控制器,或者使用SAN存储时, O_DIRECT 可能会导致性能下降. MySQL用户手册 和  Bug #54306  详细地说明了这一点.
• innodb_flush_neighbors—— 默认值为 1. 在SSD存储上应设置为0(禁用) ,因为使用顺序IO没有任何性能收益. 在使用RAID的某些硬件上也应该禁用此设置,因为逻辑上连续的块在物理磁盘上并不能保证也是连续的.
• innodb_io_capacity and  innodb_io_capacity_max—— 这些设置会影响InnoDB每秒在后台执行多少操作. 在 以前的一篇文章里我描述了大多数写IO(除了写InnoDB日志)是后台操作的. 如果你深度了解硬件性能(如每秒可以执行多少次IO操作),则使用这些功能是很可取的,而不是让它闲着.

• innodb_lru_scan_depth - 默认值为 1024. 这是mysql 5.6中引入的一个新选项. Mark Callaghan   提供了 一些配置建议. 简单来说,如果增大了 innodb_io_capacity 值, 应该同时增加 innodb_lru_scan_depth.

• log-bin—— 启用二进制日志. 默认情况下二进制日志不是事故安全的(not crash safe),但如同我 以前的文章所说, 我建议大多数用户应该以稳定性为目标. 在这种情况下,你还需要启用: sync_binlog=1,  sync_relay_log=1,  relay-log-info-repository=TABLE and  master-info-repository=TABLE.

• expire-logs-days—— 默认旧日志会一直保留. 我推荐设置为 1-10 天. 保存更长的时间并没有太多用处,因为从备份中恢复会快得多.
• server-id—— 在一个主从复制体系(replication topology )中的所有服务器都必须设置唯一的 server-id.
• binlog_format=ROW —— 修改为基于行的复制. 我最近写的另一篇 基于行的复制 ,里面叙述了我真的很喜欢它的原因,因为它可以通过减少资源锁定提高性能. 此外还需要启用两个附加设置:   transaction-isolation=READ-COMMITTED and   innodb_autoinc_lock_mode = 2.

• timezone=GMT 将时区设置为格林尼治时间. 越来越多的系统管理员建议将所有服务器都设置为 格林尼治时间(GMT). 我个人非常喜欢这点,因为现在几乎所有的业务都是全球化的. 设置为你本地的时区似乎是有点武断的.
• character-set-server=utf8mb4 and  collation-server=utf8mb4_general_ci  如之前的 文章所讲述的 ,utf8 编码对新应用来说是更好的默认选项. 您还可以设置 skip-character-set-client-handshake 以忽略应用程序想要设置的其他字符集(character-set).
• sql-mode—— MySQL默认对不规范的数据很宽容,并且会静默地截断数据. 在我 之前的一篇文章中, 我提到新应用程序最好设置为： STRICT_TRANS_TABLES,ERROR_FOR_DIVISION_BY_ZERO,

• skip-name-resolve—— 禁用反向域名解析. DNS解析在某些系统上可能有点慢/不稳定,所以如果不需要基于主机名的授权,我建议避免这种解析.
• max_connect_errors—— Todd Farmer 写道 :“[这个功能]提供了没有实际意义的暴力访问攻击保护”. 事实上当设置skip-name-resolve 时, max_connect_errors 甚至不起作用(见上一段所述).

• max-connections——默认值是151. 我看到很多用户将他设置得比较大,大多在 300 ~ 1000之间.

从5.5开始的另一种解决方案(在MySQL社区版和企业版之间有一些差异) 是使用  线程池插件.

• 64GB物理内存
• 硬件RAID控制器(假设每秒IO可达 2000 IOPS)
• 需要主从复制(Replication)
• 新的应用(eg. 非遗留系统)
• 有防火墙保护
• 不需要基于域名(hostnames,主机名)的授权
• 全球化应用,并不想固定在某一时区.
• 想要程序 可靠稳定(durable).

则配置可能如下所示:

# InnoDB settings
innodb_buffer_pool_size=50G
innodb_log_file_size=2G
innodb_flush_method=O_DIRECT
innodb_io_capacity=2000
innodb_io_capacity_max=6000
innodb_lru_scan_depth=2000

# Binary log/replication
log-bin
sync_binlog=1
sync_relay_log=1
relay-log-info-repository=TABLE
master-info-repository=TABLE
expire_logs_days=10
binlog_format=ROW
transaction-isolation=READ-COMMITTED
innodb_autoinc_lock_mode = 2

# Other
timezone=GMT
character-set-server=utf8
collation-server=utf8_general_ci
sql-mode="STRICT_TRANS_TABLES,
 ERROR_FOR_DIVISION_BY_ZERO,
 NO_AUTO_CREATE_USER,
 NO_AUTO_VALUE_ON_ZERO,
 NO_ENGINE_SUBSTITUTION,
 NO_ZERO_DATE,
 NO_ZERO_IN_DATE,
 ONLY_FULL_GROUP_BY"
skip-name_resolve
max-connect-errors=100000
max-connections=500

# Unique to this machine
server-id=123

希望本文说清了主要的问题. 如果有其他建议,请联系原作者.

信息专家分析了成千上万条可怕又令人心碎的分手数据后，发现人们其实可以预测到恋人的关系可能会以什么方式来结束。

先来看则好消息：每天约有300万情侣开始首次约会，这是300万次让各位将萍水相逢变为人生乐事的机会，是300万次火花的迸发，是300万次人与人沟通的良缘。同时，在美国这个总人口中5.4%的人到死都没结过婚的国度里，这个数字又表明有300万人将认识生命中可能不会与之共度余生的那个人。

比起恋爱来说，婚姻中的迷茫更为常见。相爱到婚姻是幸福，那么反面就是相爱然后分手。

信息专家大卫·麦克坎德莱斯（David McCandless）和李·拜伦（Lee Byron）在分析了成千上万条可怕又令人心碎的分手数据后，发现人们其实可以预测到恋人的关系可能会以什么方式来结束。

他们的数据来源于美国人口普查局、Facebook上的投票、Twitter、杜蕾斯全球性调查，以及雅虎问答（YahooAnswers）。

1、婚恋宏观面

在全世界范围，每天约有300万对情侣开始首次约会。以美国为例，每年250万人宣誓结婚，同时超过100万对夫妇离婚，还有，5.4%的美国人一辈子到死都没结过婚。

2、全年分手高峰与低谷
出乎意料的是，情人节和春节期间并非情意融融的季节，而是处于攀升分手高峰的趋势中。

3月：全年最容易分手的高峰时期。

春天不是读书天，也不是郎情妾意的好时光。或许因为情人节、春节等节日密集期间容易产生情侣矛盾，导致分手“牛市”在接下来的3月份一触即发。所以，情侣们要在春天要多冷静、多包容。

11月与12月交界：圣诞假期之前，是全年分手另一个高峰。因此，重要假期前后都是情侣们内分泌、肾上腺素等紊乱的期间。所以，假期出没，请注意。

分手频率高的其他时期：愚人节、暑假，以及4、5月间的每个周一。

3、怎么分手

1975年前出生的人：74％是直接说的，当面了结；只有16％人选择通电话“把爱变成往事”。

1984年后出生的人：只有47％面对面说分手，30％的人选择了“电话割爱”，14％的人选择了QQ等即时通讯工具“说拜拜”。另外，5％通过Facebook结束恋情，4％发email来一刀两断。

4、不能说的秘密

全世界47％男性和40％女性曾经有过一夜情。36％的成年人承认曾因对方的容貌而分手——外貌协会的力量真不容小觑。56％的成年人表示性生活不和谐。

5、忠诚的真相

全世界22％的婚恋中人曾经出轨。

对婚恋最为不忠的是土耳其人，高达58％的情侣发生过出轨“事故”。接下来是冰岛，这个只有33.2万人口的北欧国家，却有39％的人背叛过对方；第三名是奔放的意大利人——“劈腿”比例为26％；17％的浪漫美国人有外遇史；而被认为保守的英国人，也有14％的不忠率。

在这个“出轨榜单”上，位列第五的是中国香港，11％的香港人曾经是“花心萝卜”。排名第六的是以色列，该指标为7％。

6、TA们为什么分手

出轨：22％的离婚原因是出现了第三者；“小三”也让18％的恋人“走不下去”。

不感兴趣了：28％的情侣因为厌倦而放弃了对方，而26％的夫妇出于“七年之痒”而埋葬了婚姻。

距离：16％的夫妇因为两地分居而“有缘无份”，21％的“异地恋”无疾而终。3.5％的分手原因是“父母或朋友不赞同”。宁拆十座庙，不毁一桩婚。前辈们可以对别人的婚姻作些“指点”，但不要“指指点点”吧。

via： 199it.com 摘自： 快公司

您可能也喜欢：
数据挖掘-百度	营销真相 微信小店赚钱秘诀	数据分析-百度	数据可视化	为何大数据不是必然的好数据
无觅

The post 大数据说出爱情的残酷真相 appeared first on 神刀安全网.

   今天回家之后，学习的是Jquery的选择器。选择器作为Jquery的优势之一，确实让我感觉到了它的强大。Jquery选择器分为基本选择器、层次选择器、过滤选择器和表单选择器，下面我一一介绍这四种选择器。

   一、基本选择器

   看了书中关于选择器的介绍，我才知道，自己平日里用的大部分都是基本选择器。基本选择器中包含id选择器、class选择器、标签选择器、复合选择器和“*”选择器。

   $("#id") 选取所有属性id等于“id”的元素。

   $(".class_1") 选取所有属性class为“class_1”的元素。

   $("p") 选取所有的<p>元素。

   $("div,span,p.myClass") 选取所有<div>、<span>和属性class为“myClass”的<p>标签的一组元素。

   $("*") 选取所有元素。

   二、层次选择器

   如果想根据个元素之间的层次关系来获取特定的元素，可以选择使用层次选择器。

   $("div p") 选取<div>里所有的<p>元素。这个选择器获取的是所有后代元素，而不是下一层次的元素（即子元素）。

   $("div>p") 选取<div>里所有标签为<p>子元素。

   $(".class_1+div") 选取属性class为“class_1”的下一个<div>同辈元素。

   $(".class_1").next("div") 效果同上。

   $(".class_1~div") 选取属性class为“class_1”的元素后面的所有<div>同辈元素。

   $(".class_1").nextAll("div") 效果同上。

   $(".class_1").siblings("div") 与上面两个选择器不同的是：这个选择器没有前后之分，它选取所有同辈的<div>元素。

   三、过滤选择器

   过滤选择器都是以冒号(:)开头，过滤选择器可以分为基本过滤、内容过滤、可见性过滤、属性过滤、子元素过滤和表单对象属性过滤选择器。

   1、基本过滤选择器

   $("div:first") 选取所有<div>元素中第一个<div>元素。

   $("div:last") 选取所有<div>元素中最后一个<div>元素。

   $("input:not(.class_1)") 选取属性class不是“class_1”的<input>元素。

   $("input:even") 选取索引是偶数的<input>元素。

   $("input:odd") 选取索引是奇数的<input>元素。

   $("input:eq(1)") 选取索引等于1的<input>元素。

   $("input:gt(1)") 选取索引大于1的<input>元素。（注：大于1，而不包括1）

   $("input:lt(1)") 选取索引小于1的<input>元素。（注：小于1，而不包括1）

   $(":header") 选取网页中所有的<h1>，<h2>，<h3>...。

   $("div:animated") 选取正在执行动画的<div>元素。

   $(":focus") 选取当前获取焦点的元素。

   2、内容过滤选择器

   $("div:contains('我')") 选取含有文本“我”的<div>元素。

   $("div:empty") 选取不包含子元素（包括文本元素）的<div>空元素。

   $("div:has(p)") 选取含有<p>元素的<div>元素。

   $("div:parent") 选取拥有子元素（包括文本元素）的<div>元素。

   3、可见性过滤选择器

   $(":hidden") 选取所有不可见元素，$("input:hidden") 选取所有不可见的<input>元素。

   $("div:visible") 选取所有可见的<div>元素。

   4、属性过滤选择器

   $("div[id]") 选取拥有属性id的<div>元素。

   $("div[title=text]") 选取属性title为“text”的<div>元素。

   $("div[title!=text]") 选取属性title不等于“text”的<div>元素。（注：没有属性title的<div>元素也会被选取）

   $("div[title^=text]") 选取属性title是以“text”开头的<div>元素。

   $("div[title$=text]") 选取属性title是以“text”结束的<div>元素。

   $("div[title*=text]") 选取属性title中含有“text”的<div>元素。

   $('div[title|="text"]') 选取属性title等于“text”或以“text”为前缀的<div>元素。（注：为前缀指该字符串后跟一个‘-’）。

   $('div[title~="text"]') 选取属性title以空格分隔的值中包含字符“text”的元素。

   $("div[id][title$='text']") 选取拥有属性id，并且属性title以“text”结束的<div>元素。

   5、子元素过滤选择器

   $("div.one:nth-child(2)") 选取属性class为“one”的<div>父元素下的第二个子元素。

   $("div.one:first-child(2)") 选取属性class为“one”的<div>父元素下的第一个子元素。

   $("div.one:last-child(2)") 选取属性class为“one”的<div>父元素下的最后一个子元素。

   $("div.one:first-child(2)") 如果属性class为“one”的<div>父元素下只有一个子元素，则选取这个子元素。

   6、表单对象属性过滤选择器

   $("#form1 input:enabled") 选取表单内可用的<input>元素。

   $("#form1 input:disabled") 选取表单内不可用的<input>元素。

   $("input:checked") 选取被选中的多选框。

   $("select:selected") 选取下拉框中被选中的项。

   （注：在元素中设置属性disabled为“disabled”可使此元素不可用）

   四、表单选择器

   $(":input") 选取所有<input>、<textarea>、<select>和<button>元素。

   $(":text") 选取所有的单行文本框。

   $(":password") 选取所有的密码框。

   $(":radio") 选取所有的单选框。

   $(":checkbox") 选取所有的复选框。

   $(":image") 选取所有的图像按钮。

   $(":reset") 选取所有的重置按钮。

   $(":button") 选取所有的按钮。

   $(":file") 选取所有的上传控件。

   $(":hidden") 选取所有的不可见元素。

   五、选择器中的一些注意事项

   1、一些属性值中含有特殊字符

   如：<div id="id[1]">aa</div>,获取此元素的方法是：$("#id\\[1\\]")。

   2、选择器中含有空格

   $('.class_1 :hidden')与$('.class_1:hidden')的对比。

   $('.class_1 :hidden') 获取到的是属性class为class_1的元素里边包含的隐藏元素。

   $('.class_1:hidden') 获取到的是属性class为class_1的元素。

   总算把Jquery的选择器的知识点大致的总结了一下了，这些知识点基本都是照书上的写的，只不过是浓缩了一下，让各位大神见笑了。明天根据今天总结的知识点做一个示例，当然示例也是书中的示例，那些和我一样的菜鸟们期待吧！

本文链接： Jquery：强大的选择器<一>，转载请注明。

近日花了点时间对几个分支版本进行对比测试，包括了：MySQL 5.6.17、Percona5.6.16、MariaDB 10.0.11、OneSQL 5.6.16。

tpcc-mysql测试脚本可以参见我以前的一个分享： 分享：服务器基准测试 或者  MySQL压力测试经验（放在slideshare上，需要翻）

下面是测试结果：

MySQL 5.6.17/Percona5.6.16/MariaDB 10.0.11/OneSQL 5.6.16 TpmC测试

针对上面测试结果的说明：

• —软件人才免语言低担保 赴美带薪读研！—

【最费脑力的14部电影】《盗梦空间》、《记忆裂痕》、《生死停留》、《死亡幻觉》、《禁闭岛》、《穆赫兰道》、《蝴蝶效应》、《恐怖游轮》、《伤城》、《盗走达芬奇》、《88分钟》、《万能钥匙》、《决胜21点》、《沉默的羔羊》

【感动无数人的电影】《恋空》《婚纱》《比悲伤更悲伤的故事》《我脑中的橡皮擦》《属于你的我的初恋》《夏天协奏曲》《天使之恋》《分手信》《近在咫尺的爱恋》感动你的是哪部 ?

【15部让你哭的昏天暗地的电影】：《假如爱有天意》《我脑海中的橡皮擦》《情书》《恋空》《等待，只为与你相遇》《我们的幸福时光》《请别相信她》《触不到的恋人》《菊花香》《剪刀手爱德华》《海上钢琴师》《恋恋笔记本》《美丽心灵的永恒阳光》《泰坦尼克号》

【18部经典天才电影】《美丽心灵》、《雨人》、《波拉克》、《暗物质》、《想飞的钢琴少年》、《嫌疑人X的献身》、《天才瑞普利》、《猫鼠游戏》、《香水》、《一级恐惧》、《心灵捕手》、《莫扎特传》、《证据》、《海上钢琴师》、《电锯惊魂》、《沉默的羔羊》、《非常嫌疑犯》、《寻找弗罗斯特》

【能够影响一生的十部电影】1.《阿甘正传》:执着；2.《东方不败》:才华；3.《美国往事》:人生；4.《罗马假日》:爱情；5.《勇敢的心》:勇气；6.《辛德勒的名单》:责任；7.《肖申克的救赎》:信念；8.《Ｅ.Ｔ》:童心；9.《现代启示录》:痛苦；10.《第七封印》:哲思。

【人生必看的10部电影】爱情→《罗马假日》；执着→《阿甘正传》；哲理→《第七封印》；才华→《莫扎特传》；人生→《美国往事》；童心→《ET》；痛苦→《现代启示录》；信念→《肖申克的救赎》；责任→《辛德勒的名单》；勇气→《勇敢的心》

【十部适合一个人静静看的电影】1。阿甘正传。2肖申克的救赎。3。触不到的恋人。4。海上钢琴师。5。千与千寻。6。雏菊。7。花样年华。8。幸福来敲门。9。蓝莓之夜。10。放牛班的春天

【10部震撼狙击手电影】①《狙击电话亭》；②《最后的莫希干人》；③《敌人的荣誉》；④《兵临城下》；⑤《全金属外壳》、⑥《快枪手 》；⑦《双狙人》；⑧《杀手悲歌》；⑨《一号通缉令》；⑩《最后刺客》。

【亚洲十大恐怖电影】：1.《咒怨》；2.鬼娃娃花子；3.《午夜凶铃》；4.《鬼来电》；5.《笔仙》；6.《解剖学教室》；7.《邪降》；8.《四人餐桌》；9.《人形师》；10.《凶相》.

【12部让你笑喷的电影】《神探飞机头》《我盛大的同志婚礼》《幸运库克》《校园卧底》《我的野蛮老师》《美女也烦恼》《疯狂的石头》《谋杀快乐》《XXXX》《我为玛丽狂》《美国派》《偷天情缘》。

【最酷的狗】：《101真狗》、最可爱的狗：《狗狗心事》、最红的狗：《史努比》、最搞怪的狗：《家有贱狗》、最苦命的狗：《龙龙与忠狗》、最懂孙子兵法的狗：《猫狗大战》、最大无畏的狗：《酷狗正传》、最会装傻的狗：《酷狗宝贝》、最忠心的狗：《导盲犬小Q》最早狗明星：《灵犬莱西》

【哈佛商学院要求学生必看的10部经典电影】《华尔街》《大亨游戏》《颠倒乾坤》《抢钱大作战》《硅谷传奇》《可口可乐小子》《发达之路》《大公司小老板》《巴塞罗那》《社交网络》

【最美的10部电影】1.《公民凯恩》、 2.《猎人之夜》、 3.《游戏规则》、 4.《日出》、 5.《亚特兰大号》、 6.《M就是凶手》、 7.《雨中曲》、 8.《迷魂记》、 9.《天堂的孩子》、 10.《搜索者》

【国内10部经典同性恋电影】1.《蓝宇》；2. 《霸王别姬》；3. 《美少年之恋》；4. 《心动》；5. 《自梳》；6. 《喜宴》；7. 《春光乍泄》；8. 《夜奔》；9. 《今年夏天》；10. 《东宫西宫》；

【15部治愈系温暖电影】《入殓师》、《大鱼》、《阳光小美女》、《放牛班的春天》、《天使爱美丽》、《菊次郎的夏天》、《天堂电影院》、《蝴蝶》、《蓝色大门》、《曾经》、《诺丁山》、《真爱至上》、《幸福终点站》、《西雅图夜未眠》、《当幸福来敲门》。

【15部变态连环杀手的电影】《十二宫》，《七宗罪》，《沉默的羔羊》，《电锯惊魂》，《美国精神病人》，《看见恶魔》，《神秘拼图》，《可爱的骨头》，《天生杀人狂》，《机动杀人》，《香水》，《八面埋伏》，《十五号星期五系列》，《老无所依》，《女魔头》。

【唯美如画的日本纯爱系电影】》《花水木》《恋空》《现在只想爱你》《秒速5厘米》《情书》《花与爱丽丝》《泪光闪闪》《四月物语》《春之雪》《虹之女神》《燕尾蝶》《在世界心的中呼唤爱》《等待只为与你相遇》《属于你的我的初恋》《大约在雨季》《五年后的情书》《好想告诉你》

【15部催泪电影】《假如爱有天意》,《我脑海中的橡皮擦》,《情书》,《恋空》,《等待，只为与你相遇》,《我们的幸福时光》,《请别相信她》,《触不到的恋人》,《菊花香》,《剪刀手爱德华》,《海上钢琴师》,《恋恋笔记本》,《美丽心灵的永恒阳光》,《泰坦尼克号》,《天使之恋》。

【10部关于初恋的电影】：1.《情书》；2. 《初恋50次》；3. 《牯岭街少年杀人事件》；4. 《这个杀手不太冷》；5. 《罗马假日》；6. 《蓝色大门》；7. 《心动》；8. 《教室别恋》；9. 《初恋这件小事》；10. 《初恋红豆冰》

【美国好看的校园电影盘点】《牛仔裤的夏天》，《贱女孩》，《美国派》，《歌舞青春》，《朱诺》，《邻家女孩》，《回到17岁》，《暮光之城》，《足球尤物》，《平民天后》，《灰姑娘的玻璃手机》，《辣妈辣妹》，《公主日记》，《发胶》

【当你失落时，不妨看看这10部电影，能带给你无尽勇气！】《听见天堂》《追梦女孩》《阳光小美女》《闻香识女人》《放牛班的春天》《百万宝贝》《跳出我天地》《永不妥协》《心灵捕手》《侧耳倾听》

【全球十大魔幻电影榜】一、指环王系列；二、哈利波特系列；三、纳尼亚传奇系列；四、加勒比海盗系列；五、印第安纳琼斯(夺宝奇兵)三部曲；六、范海辛；七、狼族盟约；八、爱丽斯梦游仙境；九、暮光之城；十、画皮

【最让人欲罢不能的15部美剧】《生活大爆炸》、《绯闻女孩》、《迷失》、《２４小时》、《老友记》、《越狱》、《豪斯医生》、《X档案》、《Lie to me》、《欲望都市》、《邪恶力量》、《吸血鬼日记》、《CSI》、《欢乐合唱团》、《ROME》

【12星座推荐电影】金牛座《童梦失魂夜》狮子座《梦》天蝎座《我在伊朗长大》水瓶座《黑店狂想曲》白羊座《镜子面具》巨蟹座《科学睡眠》天秤座《Gil Alkabetz》摩羯座《漫长的婚约》双子座《人生七部曲》处女座《黑暗中的舞者》射手座《被嫌弃的松子的一生》双鱼座《The double life of Veronique》

【五大悬疑电影推荐】NO.5万能钥匙：悬念迭起度:★★☆；NO.4恐怖油轮：悬念迭起度:★★★☆；NO.3灵异第六感：悬念迭起度:★★★★；NO.2空中危机：悬念迭起度:★★★★；NO.1致命ID：悬念迭起度:★★★★☆

【让这些电影治愈你】1、缺乏学习动力：《幸福终点站》、《风雨哈佛路》；2、对爱失望：《偷天情缘》、《初恋50次 》；3、自卑失落：《阿甘正传》、《肖申克的救赎》；4、失败或绝望：《铁权男人》、《迫在眉梢》、《伊丽莎白镇》；5、厌倦生活：《在世界转角遇见爱》、《搏击俱乐部》

【僵尸爱好者必看电影——真人大战僵尸】《生化危机》《惊变28天》《惊变28周》《活死人的黎明》《活死人之地》《僵尸肖恩》《我是传奇》《致命拜访》《隔山有眼》《毁灭战士》《丧尸出笼》《生化寿司》《群尸玩过界》《死亡航班》《厄夜三十》《活死人归来》

【近期火爆的泰国青春浪漫电影】《yes or no》《初恋这件小事》《悲恋三人行》《初三大四我爱你》《亲爱的伽利略》《爱在暹罗》《爱久弥新》《季节变幻》《下一站，说爱你》《荷尔蒙》《让爱发光》《你好，陌生人》 《泰国派》《友谊我和你》

【十四部塑造独立女性的电影】《走出非洲》《人在纽约》《阿黛尔·雨果的故事》《清洁》《时时刻刻》《乱世佳人》《征婚启事》《饮食男女》《蒙娜丽莎的微 笑》《革命之路》《朗读者》《成为简·奥斯汀》《朱莉与朱莉娅》《希尔维亚》

【电影名导3部曲】多纳托雷时空3部曲：《西西里的美丽传说》、《天堂电影院》、《海上钢琴师》；瑟吉欧·莱昂美国3部曲：《西部往事》、《革命往事》、《美国往事》；库布里克未来3部曲：《奇爱博士》、《发条橙》、《2001太空漫游》；阿加多隔阂3部曲：《爱情是狗娘》、《21克》、《通天塔》。

【因为名字烂而被错过的好电影】《三傻大闹宝莱坞》《刺激1995》《搏击俱乐部》《机器人总动员》《杀死比尔》 《低俗小说》《落水狗》《午夜牛郎》《洋葱电影》《蝴蝶效应》《诺丁山》《两杆大烟枪》《摇滚黑帮》《十诫》《黑道当家》《一酷到底》《热带惊雷》《叫我第一名》《记忆碎片》《摇滚校园》

【12星座的恐怖片】摩羯《鬼影》；水瓶《女高怪谈》；双鱼《孤儿》；白羊座《鬼怨》；金牛《死神的十字路口》；双子《怪谈新耳袋》；巨蟹《恐怖油轮》；狮子《孤堡惊情》；处女《死寂》；天秤《厉鬼将映》；天蝎《咒怨》；射手《死亡录像》

【十部能让女生看透自己的电影】1.情欲《情迷六月花》 2.梦幻《天使爱美丽》 3.母性《黑暗中的舞者》 4.纯真《花与爱丽丝》5.痴爱《绿光》 6.尊严《永不妥协》 7.孤独《迷失东京》 8.压抑《钢琴教师》 9.恐惧《恐惧吞噬灵魂》 10.女权《射杀安迪霍尔》。

【适合一个人看的电影】独自等待、天使之城、海上钢琴师、蓝色大门、触不到的恋人、假如爱有天意、蓝莓之夜、两小无猜、千与千寻、花样年华、放牛班的春天、当幸福来敲门、恋恋三季、雏菊、阿司匹林、四月物语。

【结局最意外的20部电影】《搏击俱乐部》、《迷雾》、《心理游戏》、《第六感》、《蝴蝶效应》、《 电锯惊魂》、《赛末点》、《 穆赫兰道》、《非常嫌疑犯》、《魔术师》、《小岛惊魂》、《万能钥匙》、《火柴人》、《七宗罪》、《魔鬼代言人》、《孤儿》、《八面埋伏 》、《香水》、《偷拐抢骗》

【十佳剧情电影】1、《肖申克的救赎》；2、《 教父1、2》；3、《美国往事》；4、《天堂电影院》；5、《无主之城》；6、《阿甘正传》；7、《勇敢的心》；8、《楚门的世界》；9、《音乐之声》；10、《辛德勒的名单》。

【值得收藏的韩国电影】1.杀人回忆2. 老男孩3. 薄荷糖4. 八月照相馆5. 母亲6. 春夏秋冬又一春7. 生活的发现8. 我的野蛮女友9. 共同警备区10. 绿洲11. 太极旗飘扬12. 国家代表13. 空房间14. 蔷花，红莲15. 汉江怪物16. 马拉松17. 触不到的恋人18. 亲切的金子19. 朋友20. 实尾岛

【15部让你哭的昏天暗地的电影】《假如爱有天意》,《我脑海中的橡皮擦》,《情书》,《恋空》,《等待，只为与你相遇》,《我们的幸福时光》,《请别相信她》,《触不到的恋人》,《菊花香》,《剪刀手爱德华》,《海上钢琴师》,《恋恋笔记本》,《美丽心灵的永恒阳光》,《泰坦尼克号》

【全球十大禁播电影】1.《索多玛120天》 2.《下水道人鱼》 3.《殘酷的浪漫》 4.《粉红色的火烈鸟》 5.《不可撤消》 6.《罗曼史》 7.《地狱解剖》 8.《罗马帝国艳情史》 9.《感官世界》 10.《九歌》

【10部影视原声极佳电影推荐】1.《音乐之声》2.《歌舞青春》3.《海上钢琴师》4.《八月迷情》5.《钢琴家》6.《星球大战》7.《芝加哥》8.《狮子王》9.《放牛班的春天》10.《加勒比海盗》

【英国电影推荐】：《猜火车》《贫民窟的百万富翁》《两杆大烟枪》《月球》《跳出我天地》《秘密与谎言》《英国病人》《雾都孤儿》《哈利布朗》《摇滚黑帮》《好事夜未眠》《僵尸肖恩》《两小无猜》《希望与荣耀》《红色之路》《惊变28天》《傲慢与偏见》《两小无猜》《国王的演讲》《偷拐抢骗》

【20部不可错过的经典系列电影】《加勒比海盗》《教父》《夺宝奇兵》《碟中谍》《虎胆龙威》《墨西哥往事》《大白鲨》《小鬼当家》《洛奇》《木乃伊》《终结者》《蝙蝠侠》《哈利波特》《指环王》《惊声尖叫》《星球大战》《侏罗纪公园》《异形》《第一滴血》《骇客帝国》

【重口味●通缉令】1、《雾》日本 2、《邪恶外星人》英国 3、《乱步地域》日本 4、《恶魔的艺术2》泰国 5、《神秘马戏团》日本 6、《梦魇疯人院》捷克 7、《兽餐》美国 8、《2001个疯子》美国 9、《色情狂》美国 10、《最后的晚餐》日本

【唯美爱情电影推荐】《假如爱有天意》《夏天协奏曲》《雏菊》《恋空》《海角七号》《情书》《触不到的恋人》《四月物语》《我脑海中的橡皮擦》《天使之恋》《比悲伤更悲伤的故事》《听说》《云中漫步》《七音符》《八月照相馆》《现在只想爱你》《恋爱小说》《向左爱向右爱》《二见钟情》

【推荐十部青少年成长电影】《牯岭街少年杀人事件》、《牛仔裤的夏天》、《菊次郎的夏天》、《毕业生》、《花与爱丽丝》、《情书》、《十七岁的单车》、《阳光灿烂的日子》、《西西里的美丽传说》、《留级之王》

【15部感人电影】《辛德勒的名单》、《恋空》、《假如爱有天意》、《情书》、《妈妈再爱我一次》、《我的兄弟姐妹》、《泰坦尼克号》、《忠犬八公》、《我是山姆》、《再见萤火虫》、《大鱼》、《这个杀手不太冷》、《比悲伤更悲伤故事》、《人鬼情未了》、《情书》

【韩国十大喜剧电影】1、《家族荣誉》 2、《我的野蛮女友》 3、《色即是空》 4、《僵尸刑警》 5、《谁和她睡觉了》 6、《朝鲜男人在韩国》 7 、《麻婆岛》 8、《一号街的奇迹》 9、《银妆刀》 10、《浪漫刺客》

【11部莱昂纳多经典电影】1.《罗密欧与朱丽叶之后现代激情篇》 2.《泰坦尼克号》 3.《铁面人》 4.《海滩》 5.《纽约黑帮》 6.《猫鼠游戏》 7.《飞行家》 8.《血钻》 9.《无间行者》 10.《革命之路》 11.《盗梦空间》

【学生电影推荐榜】 1、《阿甘正传》2、《天堂的颜色》3、《死亡诗社》4、《美国派》5、《英雄本色》6、《大话西游》7、《阳光灿烂的日子》8、《坏孩子的天空》9、《毕业生》10.《肖申克的救赎》11.《燃情岁月》

【《电影手册》评选出的世上最美的10部电影】1.《公民凯恩》、 2.《猎人之夜》、 3.《游戏规则》、 4.《日出》、 5.《亚特兰大号》、 6.《M就是凶手》、 7.《雨中曲》、 8.《迷魂记》、 9.《天堂的孩子》、 10.《搜索者》

【十大必看经典心理学电影】1、《钢琴教师》；2、《美丽心灵》；3、《死亡试验》；4、《海滩》；5.、《记忆碎片》；6、《搏击俱乐部》；7、《灵异第六感》；8、《圣女贞德》；9、《一树梨花压海棠》；10、《心灵捕手》

【可以给你“治病”的电影】1.《决战冰河》《洛奇》：治疗缺乏学习动力； 2.《穆里尔的婚礼》《心雨花露》：治疗缺乏信心； 3.《阿甘正传》《肖申克的救赎》：治疗自卑失落； 4.《远大前程》《功夫熊猫》《小鞋子》：治疗失败或绝望； 5.《天生爱情狂》《凡夫俗女》《心理游戏》：治疗厌倦生活

【10部能使女性受益的经典电影】 1.《牛仔裤的夏天》：友情 2《情书》：爱情 3.《天使爱美丽》：孤独 4.《隐形的翅膀》：坚强 5.《千与千寻》:成长 6.《穿普拉达的女王》：自我 7.《成为简奥斯汀》：尊严 8.《黑暗中的舞者》：母爱 9.《蓝》:自由 10.《律政俏佳人》:智慧

【十大争议电影】1.《索多玛120天》(1975) 2.《基督最后的诱惑》(1988) 3.《发条橘子》(1971) 4.《畸型人》(1932) 5.《雌雄大盗》(1967) 6.《巴黎最后的探戈》(1972) 7.《虎口巡航》(1980) 8.《耶稣受难记》(2004) 9.《沉默的羔羊》(1991) 10.《本能》(1992)

【十大经典儿童电影】1、《哈利•波特与魔法石》 2、《星球大战前传1：幽灵的威胁》 3、《怪物史瑞克》 4、《哈利•波特与火焰杯》 5、《外星人E.T.》 6、《海底总动员》 7、《小鬼当家》 8、《狮子王》 9、《绿野仙踪》 10、《小鬼当街/超能塞豆隆》

【十大女性暴力电影】御姐当道，挡我者死：《末路狂花》 1991 《霹雳娇娃》2000 《多米诺》2005 《贴身恐惧》2002 《古墓丽影》2001 《杀死比尔》2003 《水果硬糖》2005 《切肤之爱》1999 《本 能》1992 《死后就没人议论我们了》1995

【提高听力口语能力，最值得欣赏的英式发音电影】：《如果能再爱一次》《成长教育》《穿越时空爱上你》《生死朗读》《猜火车》《哈利波特》《女王》《真爱至上》《恋爱假期》《诺丁山》《真爱之吻》《傲慢与偏见》《莎翁情史》《成为简奥斯汀》《福尔摩斯》《雾都孤儿》《兵临城下》《英国病人》

【盘点六大青春电影：永远漂泊在路上】1.《艋舺》：青春残酷往事。2.《朋友》：回首时物是人非。3.《在世界中心呼唤爱》：青春的爱与死。4.《猜火车》：无处安放的青春。5.《朱尔与吉姆》：三人行的青春。6.《观音山》：在路上的青春。

【20部电影,让你足以胜任董事长、经理】《华尔街》《锅炉房》《硅谷传奇》《颠倒乾坤》《拜金一族》《可口可乐小子》《发达之路》《优势合作》《巴塞罗那》《甜心先生》《上班一条虫》《解构企业》《惊爆内幕》《影子大亨》《反垄断》《魔鬼营业员》《抢钱世界》《败露》《男人百分百》《门口的野蛮人》。

【经典爱情电影推荐】无奈纯情之恋《罗马假日》、爱情史诗《乱世佳人》、生离死别的爱恋《人鬼情未了》、直到你爱我《捆着我绑着我》、凄美爱恋《卡萨布兰卡》、生活的细腻写真《东京日和》、爱情拯救人生《新桥恋人》、《大话西游》、青春的纯情《情书》、都市爱情童话《7月7日晴》

【2010美国电影协会十佳电影】1，《黑天鹅》2，《斗士》3，《盗梦空间》4，《127小时》5，《社交网络》6，《城中大盗》7，《玩具总动员3》8，《大地惊雷》9，《冬天的骨头》10，《孩子们都很好》

【将来你一定会让你的孩子看的10部电影】：1. 皮克斯制作的任何作品 2、《七宝奇谋》3、《公主新娘》 4、《夜魔水晶》 5、《大魔域》 6、《魔幻迷宫》 7、《捣蛋鬼》 8、《幽灵公主》 9、《圣诞夜惊魂》10、《E.T.外星人》。

【女生成长必看九部电影】一，友情：《牛仔裤的夏天》、二，初恋：《情书》、三，孤独：《天使爱美丽》、四，成长：《千与千寻》、五，自信：《穿普拉达的女王》、六，尊严：《成为简奥斯汀》、七，母爱：《黑暗中的舞者》、八，自由：《蓝》、九，智慧：《律政俏佳人》

【好电影推荐-温情篇】：《入殓师》、《大鱼》、《阳光小美女》、《放牛班的春天》、《天使爱美丽》、《菊次郎的故事》、《天堂电影院》、《蝴蝶》、《蓝色大门》、《曾经》、《诺丁山》、《真爱至上》、《幸福终点站》、《西雅图夜未眠》、《当幸福来敲门》

【独立女性必看电影】《走出非洲》、《人在纽约》、《阿黛尔·雨果的故事》、《清洁》、《时时刻刻》、《乱世佳人》、《征婚启事》、《饮食男女》、《蒙娜丽莎的微笑》、《革命之路》、《朗读者》、《成为简·奥斯汀》、《朱莉与朱莉娅》、《希尔维亚》。

【让你憋着尿直到看完的十部电影】：1《七磅》；2《小情人》；3《返老还童》；4《一生的唯一》；5《无耻混蛋》；6《珍爱人生》；7《盗梦空间》；8《婚纱》；9《怒火攻心》；10《马利与我》。

【让这些电影给你“治病”】缺乏学习动力：《决战冰河》、《洛奇》；缺乏信心：《穆里尔的婚礼》、《心雨花露》；自卑失落：《阿甘正传》、《肖申克的救赎》；失败或绝望：《远大前程》、《功夫熊猫》、《小鞋子》；厌倦生活：《天生爱情狂》、《凡夫俗女》、《心理游戏》

public class JaroWinklerDistance implements StringDistance {

  private float threshold = 0.7f;

  private int[] matches(String s1, String s2) {
    String max, min;
    if (s1.length() > s2.length()) {
      max = s1;
      min = s2;
    } else {
      max = s2;
      min = s1;
    }
    // 两个分别来自s1和s2的字符如果相距不超过 floor(max(|s1|,|s2|) / 2) -1, 我们就认为这两个字符串是匹配的, 因此，查找时，
    // 超过此距离则停止
    int range = Math.max(max.length() / 2 - 1, 0);
    // 短的字符串, 与长字符串匹配的索引位
    int[] matchIndexes = new int[min.length()];
    Arrays.fill(matchIndexes, -1);
    // 长字符串匹配的标记
    boolean[] matchFlags = new boolean[max.length()];
    // 匹配的数目
    int matches = 0;
    // 外层循环，字符串最短的开始
    for (int mi = 0; mi < min.length(); mi++) {
      char c1 = min.charAt(mi);
      // 可能匹配的距离，包括从给定位置从前查找和从后查找
      for (int xi = Math.max(mi - range, 0), xn = Math.min(mi + range + 1, max
          .length()); xi < xn; xi++) {
    	// 排除被匹配过的字符，若找到匹配的字符，则停止
        if (!matchFlags[xi] && c1 == max.charAt(xi)) {
          matchIndexes[mi] = xi;
          matchFlags[xi] = true;
          matches++;
          break;
        }
      }
    }
    // 记录min字符串里匹配的字符串，保持顺序
    char[] ms1 = new char[matches];
    // 记录max字符串里匹配的字符串，保持顺序
    char[] ms2 = new char[matches];
    for (int i = 0, si = 0; i < min.length(); i++) {
      if (matchIndexes[i] != -1) {
        ms1[si] = min.charAt(i);
        si++;
      }
    }
    for (int i = 0, si = 0; i < max.length(); i++) {
      if (matchFlags[i]) {
        ms2[si] = max.charAt(i);
        si++;
      }
    }
    // 查找换位的数目
    int transpositions = 0;
    for (int mi = 0; mi < ms1.length; mi++) {
      if (ms1[mi] != ms2[mi]) {
        transpositions++;
      }
    }
    // 查找相同前缀的数目
    int prefix = 0;
    for (int mi = 0; mi < min.length(); mi++) {
      if (s1.charAt(mi) == s2.charAt(mi)) {
        prefix++;
      } else {
        break;
      }
    }
    // 返回匹配数目（m），换位的数目（t），相同的前缀的数目，字符串最长
    return new int[] { matches, transpositions / 2, prefix, max.length() };
  }

  public float getDistance(String s1, String s2) {
    int[] mtp = matches(s1, s2);
    //  返回匹配数目（m）
    float m = (float) mtp[0];
    if (m == 0) {
      return 0f;
    }
    
    // Jaro Distance
    float j = ((m / s1.length() + m / s2.length() + (m - mtp[1]) / m)) / 3;
    
    // 计算Jaro-Winkler Distance， 这里调整分数的因数=Math.min(0.1f, 1f / mtp[3])
    float jw = j < getThreshold() ? j : j + Math.min(0.1f, 1f / mtp[3]) * mtp[2]
        * (1 - j);
    return jw;
  }

  /**
   * Sets the threshold used to determine when Winkler bonus should be used.
   * Set to a negative value to get the Jaro distance.
   * @param threshold the new value of the threshold
   */
  public void setThreshold(float threshold) {
    this.threshold = threshold;
  }

  /**
   * Returns the current value of the threshold used for adding the Winkler bonus.
   * The default value is 0.7.
   * @return the current value of the threshold
   */
  public float getThreshold() {
    return threshold;
  }
}

• —软件人才免语言低担保 赴美带薪读研！—

最近在公司里基本处于打酱油的状态，工作正在交接中。没事又做起了算法题目。好久没怎么写算法题了，感觉手气还不错，经常能一次就写对（编译通过，得到想要的结果，没怎么测试），可能是因为这些题目之前看过或是写过，或许就是自己进步了一点。这15道大部分来自《剑指Offer》，作者的博客之前看过几次，感觉写得很好，但看这本书时却没有那个感觉了，可能是因为看过博客的原因吧，没有了之前的那种惊喜。自己就试着实现里面的一些算法题目，基本上是简单的思考一下，如果没什么思路，就看看作者是怎么想的，大概看一下他的思路或是代码，就开始自己实现。15道算法题如下： 源码下载。

1:合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素;

2:合并两个单链表;

3:倒序打印一个单链表;

4:给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点;

5:找到链表倒数第K个节点;

6:反转单链表;

7:通过两个栈实现一个队列;

8:二分查找;

9:快速排序;

10:获得一个int型的数中二进制中的个数;

11:输入一个数组，实现一个函数，让所有奇数都在偶数前面;

12:判断一个字符串是否是另一个字符串的子串;

13:把一个int型数组中的数字拼成一个串，这个串代表的数字最小;

14:输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）;

15:输入两个链表，找到它们第一个公共节点;

下面简单说说思路和代码实现。

//链表节点
struct NodeL 
{
    int value;
    NodeL* next;
    NodeL(int value_=0,NodeL* next_=NULL):value(value_),next(next_){}
}; 
//二叉树节点
struct NodeT
{
    int value;
    NodeT* left;
    NodeT* right;
    NodeT(int value_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){}
};

1:合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素;

合并排序一般的思路都是创建一个更大数组C，刚好容纳两个数组的元素，先是一个while循环比较，将其中一个数组A比较完成，将另一个数组B中所有的小于前一个数组A的数及A中所有的数按顺序存入C中，再将A中剩下的数存入C中，但这里是已经有一个数组能存下两个数组的全部元素，就不用在创建数组了，但只能从后往前面存，从前往后存，要移动元素很麻烦。

//合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素
void MergeArray(int a[],int alen,int b[],int blen)
{
    int len=alen+blen-1; 
    alen--;
    blen--;
    while (alen>=0 && blen>=0)
    {
        if (a[alen]>b[blen])
        {
            a[len--]=a[alen--];
        }else{
            a[len--]=b[blen--]; 
        }
    }

    while (alen>=0)
    {
        a[len--]=a[alen--];
    } 
    while (blen>=0)
    {
        a[len--]=b[blen--];
    } 
}

void MergeArrayTest()
{
    int a[]={2,4,6,8,10,0,0,0,0,0};
    int b[]={1,3,5,7,9};
    MergeArray(a,5,b,5);
    for (int i=0;i<sizeof(a)/sizeof(a[0]);i++)
    {
        cout<<a[i]<<" ";
    }
}

2:合并两个单链表;

合并链表和合并数组，我用了大致相同的代码，就不多少了，那本书用的是递归实现。

//链表节点
struct NodeL 
{
    int value;
    NodeL* next;
    NodeL(int value_=0,NodeL* next_=NULL):value(value_),next(next_){}
}; 

//合并两个单链表
NodeL* MergeList(NodeL* head1,NodeL* head2)
{
    if (head1==NULL)
        return head2;
    if (head2==NULL)
        return head1;

    NodeL* head=NULL; 
    if (head1->value<head2->value)
    {
        head=head1;
        head1=head1->next;
    }else{
        head=head2;
        head2=head2->next;
    }
    NodeL* tmpNode=head;
    while (head1 && head2)
    {
        if (head1->value<head2->value)
        {
            head->next=head1;
            head1=head1->next;
        }else{
            head->next=head2;
            head2=head2->next;
        }
        head=head->next;
    }
    if (head1)
    {
        head->next=head1;
    }
    if (head2)
    {
        head->next=head2;
    } 
    return tmpNode;
}

void MergeListTest()
{
    NodeL* head1=new NodeL(1);
    NodeL* cur=head1;
    for (int i=3;i<10;i+=2)
    {
        NodeL* tmpNode=new NodeL(i);
        cur->next=tmpNode;
        cur=tmpNode;
    }
    NodeL* head2=new NodeL(2);
    cur=head2;
    for (int i=4;i<10;i+=2)
    {
        NodeL* tmpNode=new NodeL(i);
        cur->next=tmpNode;
        cur=tmpNode;
    }
    NodeL* head=MergeList(head1,head2);
    while (head)
    {
        cout<<head->value<<" ";
        head=head->next;
    }
}

3:倒序打印一个单链表;

递归实现，先递归在打印就变成倒序打印了，如果先打印在调用自己就是顺序打印了。

//倒序打印一个单链表
void ReversePrintNode(NodeL* head)
{
    if (head)
    {
        ReversePrintNode(head->next);
        cout<<head->value<<endl;
    } 
} 
void ReversePrintNodeTest()
{
    NodeL* head=new NodeL();
    NodeL* cur=head;
    for (int i=1;i<10;i++)
    {
        NodeL* tmpNode=new NodeL(i);
        cur->next=tmpNode;
        cur=tmpNode;
    }
    ReversePrintNode(head);
}

4:给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点;

删除节点的核心还是将这个节点的下一个节点，代替当前节点。

//给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点
void DeleteNode(NodeL* head,NodeL* delNode)
{
    if (!head || !delNode)
    {
        return;
    }

    if (delNode->next!=NULL)//删除中间节点
    {
        NodeL* next=delNode->next;
        delNode->next=next->next;
        delNode->value=next->value;
        delete next;
        next=NULL;
    }else if (head==delNode)//删除头结点
    {
        delete delNode;
        delNode=NULL;
        *head=NULL;
    }else//删除尾节点，考虑到delNode不在head所在的链表上的情况
    {
        NodeL* tmpNode=head;
        while (tmpNode && tmpNode->next!=delNode)
        {
            tmpNode=tmpNode->next;
        }
        if (tmpNode!=NULL)
        {
            delete delNode;
            delNode=NULL;
            tmpNode->next=NULL;
        }
    }
}

void DeleteNodeTest()
{
    int nodeCount=10;
    for (int K=0;K<nodeCount;K++)
    {
        NodeL* head=NULL;
        NodeL* cur=NULL;
        NodeL* delNode=NULL;
        for (int i=0;i<nodeCount;i++)
        {
            NodeL* tmpNode=new NodeL(i);
            if (i==0)
            {
                cur=head=tmpNode;
            }else{
                cur->next=tmpNode;
                cur=tmpNode; 
            }
            if (i==K)
            {
                delNode=tmpNode;
            } 
        }
        DeleteNode(head,delNode) ;
    } 
}

5:找到链表倒数第K个节点;

通过两个指针，两个指针都指向链表的开始，一个指针先向前走K个节点，然后再以前向前走，当先走的那个节点到达末尾时，另一个节点就刚好与末尾节点相差K个节点。

//找到链表倒数第K个节点
NodeL* FindKthToTail(NodeL* head,unsigned int k)
{
    if(head==NULL || k==0)
        return NULL;
    NodeL* tmpNode=head;
    for (int i=0;i<k;i++)
    {
        if (tmpNode!=NULL)
        {
            tmpNode=tmpNode->next;
        }else{
            return NULL;
        } 
    }
    NodeL* kNode=head;
    while (tmpNode!=NULL)
    {
        kNode=kNode->next;
        tmpNode=tmpNode->next;
    }
    return kNode;
}

void FindKthToTailTest()
{
    int nodeCount=10;
    for (int K=0;K<nodeCount;K++)
    {
        NodeL* head=NULL;
        NodeL* cur=NULL; 
        for (int i=0;i<nodeCount;i++)
        {
            NodeL* tmpNode=new NodeL(i);
            if (i==0)
            {
                cur=head=tmpNode;
            }else{
                cur->next=tmpNode;
                cur=tmpNode;  
            }
        }
        NodeL* kNode=FindKthToTail(head,K+3) ;
        if (kNode)
        {
            cout<<"倒数第 "<<K+3<<" 个节点是："<<kNode->value<<endl;
        }else{
            cout<<"倒数第 "<<K+3<<" 个节点不在链表中" <<endl;
        }
    } 
}

6:反转单链表;

按顺序一个个的翻转就是了。

//反转单链表
NodeL* ReverseList(NodeL* head)
{
    if (head==NULL)
    {
        return NULL;
    }
    NodeL* reverseHead=NULL;
    NodeL* curNode=head;
    NodeL* preNode=NULL;
    while (curNode!=NULL)
    {
        NodeL* nextNode=curNode->next;
        if (nextNode==NULL)
            reverseHead=curNode;  

        curNode->next=preNode;
        preNode=curNode;
        curNode=nextNode;
    }
    return reverseHead;
}

void ReverseListTest()
{
    for (int K=0;K<=10;K++)
    {
        NodeL* head=NULL;
        NodeL* cur=NULL; 
        for (int i=0;i<K;i++)
        {
            NodeL* tmpNode=new NodeL(i);
            if (i==0)
            {
                cur=head=tmpNode;
            }else{
                cur->next=tmpNode;
                cur=tmpNode;  
            }
        }

        cur=ReverseList( head);
        while (cur)
        {
            cout<<cur->value<<" ";
            cur=cur->next;
        }
        cout<<endl;
    }
    cout<<endl;
}

7:通过两个栈实现一个队列;

直接上代码

//通过两个栈实现一个队列
template<typename T>
class CQueue
{
public:
    void push(const T& val)
    {
        while (s2.size()>0)
        {
            s1.push(s2.top());
            s2.pop();
        }
        s1.push(val);
    }
    void pop()
    { 
        while (s1.size()>0)
        {
            s2.push(s1.top());
            s1.pop();
        }
        s2.pop();
    }

    T& front()
    { 
        while (s1.size()>0)
        {
            s2.push(s1.top());
            s1.pop();
        }
        return s2.top();
    }
    int size()
    {
        return s1.size()+s2.size();
    }
private:
    stack<T> s1;
    stack<T> s2;
};

void CQueueTest()
{
    CQueue<int> q;
    for (int i=0;i<10;i++)
    {
        q.push(i);
    }
    while (q.size()>0)
    {
        cout<<q.front()<<" ";
        q.pop();
    }
}

8:二分查找;

二分查找记住几个要点就行了，代码也就那几行，反正我现在是可以背出来了，start=0，end=数组长度-1，while(start<=end)，注意溢出

//二分查找
int binarySearch(int a[],int len,int val)
{
    int start=0;
    int end=len-1;
    int index=-1;
    while (start<=end)
    {
        index=start+(end-start)/2;
        if (a[index]==val)
        {
            return index;
        }else if (a[index]<val)
        {
            start=index+1;
        }else
        {
            end=index-1;
        }
    }
    return -1;
}

9:快速排序;

来自百度百科，说不清楚

//快速排序
//之前有个面试叫我写快排，想都没想写了个冒泡,思路早忘了，这段代码来自百度百科
void Qsort(int a[],int low,int high)
{
    if(low>=high)
    {
        return;
    }
    int first=low;
    int last=high;
    int key=a[first];//用字表的第一个记录作为枢轴
    while(first<last)
    {
        while(first<last && a[last]>=key )--last;
        a[first]=a[last];//将比第一个小的移到低端
        while(first<last && a[first]<=key )++first;
        a[last]=a[first];//将比第一个大的移到高端
    }
    a[first]=key;//枢轴记录到位
    Qsort(a,low,first-1);
    Qsort(a,last+1,high);
}

void QsortTest()
{
    int a[]={1,3,5,7,9,2,4,6,8,0};
    int len=sizeof(a)/sizeof(a[0])-1;
    Qsort(a,0,len); 
    for(int i=0;i<=len;i++)
    {
        cout<<a[i]<<" ";
    } 
    cout<<endl;
}

10:获得一个int型的数中二进制中的个数;

核心实现就是while (num= num & (num-1))，通过这个数和比它小1的数的二进制进行&运算，将二进制中1慢慢的从后往前去掉，直到没有。

//获得一个int型的数中二进制中1的个数
int Find1Count(int num)
{
    if (num==0)
    {
        return 0;
    }
    int count=1;
    while (num= num & (num-1))
    {
        count++;
    }
    return count;
}

11:输入一个数组，实现一个函数，让所有奇数都在偶数前面;

两个指针，一个从前往后，一个从后往前，前面的指针遇到奇数就往后走，后面的指针遇到偶数就往前走，只要两个指针没有相遇，就奇偶交换。

//输入一个数组，实现一个函数，让所有奇数都在偶数前面
void RecordOddEven(int A[],int len)
{
    int i=0,j=len-1;
    while (i<j)
    {
        while (i<len && A[i]%2==1) 
            i++; 

        while (j>=0 && A[j]%2==0) 
            j--; 

        if (i<j)
        {
            A[i]^=A[j]^=A[i]^=A[j]; 
        }
    }
}

void RecordOddEvenTest()
{
    int A[]={1,2,3,4,5,6,7,8,9,0,11};
    int len=sizeof(A)/sizeof(A[0]);
    RecordOddEven( A , len);
    for (int i=0;i<len;i++)
    {
        cout<<A[i]<<" ";
    }
    cout<<endl;
    for (int i=0;i<len;i++)
    {
        A[i]=2;
    }
    RecordOddEven( A , len);
    for (int i=0;i<len;i++)
    {
        cout<<A[i]<<" ";
    }
    cout<<endl;
    for (int i=0;i<len;i++)
    {
        A[i]=1;
    }
    RecordOddEven( A , len);
    for (int i=0;i<len;i++)
    {
        cout<<A[i]<<" ";
    }
}

12:判断一个字符串是否是另一个字符串的子串;

我这里就是暴力的对比

//判断一个字符串是否是另一个字符串的子串
int substr(const char* source,const char* sub)
{
    if (source==NULL || sub==NULL)
    {
        return -1;
    }
    int souLen=strlen(source);
    int subLen=strlen(sub);
    if (souLen<subLen)
    {
        return -1;
    }

    int cmpCount=souLen-subLen;
    for (int i=0;i<=cmpCount;i++)
    {
        int j=0;
        for (;j<subLen;j++)
        {
            if (source[i+j]!=sub[j])
            {
                break;
            }
        }
        if (j==subLen)
        {
            return i ;
        }
    }
    return -1;
}

13:把一个int型数组中的数字拼成一个串，这个串代表的数字最小;

先将数字转换成字符串存在数组中，在通过qsort排序，在排序用到的比较函数中，将要比较的两个字符串进行组合，如要比较的两个字符串分别是A,B，那么组合成，A+B，和B+A，在比较A+B和B+A，返回strcmp(A+B, B+A)，经过qsort这么一排序,数组就变成从小到大的顺序了，组成的数自然是最小的。

//把一个int型数组中的数字拼成一个串，是这个串代表的数组最小
#define MaxLen 10 
int Compare(const void* str1,const void* str2)
{
    char cmp1[MaxLen*2+1];
    char cmp2[MaxLen*2+1];
    strcpy(cmp1,*(char**)str1);
    strcat(cmp1,*(char**)str2);

    strcpy(cmp2,*(char**)str2);
    strcat(cmp2,*(char**)str1);
    return strcmp(cmp1,cmp2);
}  
void GetLinkMin(int a[],int len)
{
    char** str=(char**)new int[len];
    for (int i=0;i<len;i++)
    {
        str[i]=new char[MaxLen+1];
        sprintf(str[i],"%d",a[i]); 
    }

    qsort(str,len,sizeof(char*),Compare);
    for (int i=0;i<len;i++)
    {
        cout<<str[i]<<" ";
        delete[] str[i] ;
    }
    delete[] str;
} 
void GetLinkMinTest()
{
    int arr[]={123,132,213,231,321,312};
    GetLinkMin(arr,sizeof(arr)/sizeof(int));
}

14:输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）;

递归实现，只要某个节点的两个子节点都不为空，就左右交换，让左子树交换，让右子树交换。

struct NodeT
{
    int value;
    NodeT* left;
    NodeT* right;
    NodeT(int value_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){}
};

//输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）
void TreeClass(NodeT* root)
{
    if( root==NULL || (root->left==NULL && root->right==NULL) ) 
        return; 
    NodeT* tmpNode=root->left;
    root->left=root->right;
    root->right=tmpNode;
    TreeClass(root->left);
    TreeClass(root->right); 
}

void PrintTree(NodeT* root)
{
    if(root)
    {
        cout<<root->value<<" ";
        PrintTree(root->left);
        PrintTree(root->right);
    } 
}

void TreeClassTest()
{
    NodeT* root=new NodeT(8);
    NodeT* n1=new NodeT(6);
    NodeT* n2=new NodeT(10);
    NodeT* n3=new NodeT(5);
    NodeT* n4=new NodeT(7);
    NodeT* n5=new NodeT(9);
    NodeT* n6=new NodeT(11);
    root->left=n1;
    root->right=n2;
    n1->left=n3;
    n1->right=n4;
    n2->left=n5;
    n2->right=n6;
    PrintTree(root);
    cout<<endl;
    TreeClass( root );
    PrintTree(root);
    cout<<endl;
}

15:输入两个链表，找到它们第一个公共节点;

如果两个链表有公共的节点，那么第一个公共的节点及往后的节点都是公共的。从后往前数N个节点（N=短链表的长度节点个数）,长链表先往前走K个节点（K=长链表的节点个数-N），这时两个链表都距离末尾N个节点，现在可以一一比较了，最多比较N次，如果有两个节点相同就是第一个公共节点，否则就没有公共节点。

//输入两个链表，找到它们第一个公共节点
int GetLinkLength(NodeL* head)
{ 
    int count=0;
    while (head)
    {
        head=head->next;
        count++;
    }
    return count;
}

NodeL* FindFirstEqualNode(NodeL* head1,NodeL* head2)
{
    if (head1==NULL || head2==NULL)
        return NULL;
    int len1=GetLinkLength(head1);
    int len2=GetLinkLength(head2);
    NodeL* longNode;
    NodeL* shortNode;
    int leftNodeCount;
    if (len1>len2)
    {
        longNode=head1;
        shortNode=head2;
        leftNodeCount=len1-len2;
    }else{
        longNode=head2;
        shortNode=head1;
        leftNodeCount=len2-len1;
    }
    for (int i=0;i<leftNodeCount;i++)
    {
        longNode=longNode->next;
    }
    while (longNode && shortNode && longNode!=shortNode)
    {
        longNode=longNode->next;
        shortNode=shortNode->next;
    }
    if (longNode)//如果有公共节点，必不为NULL
    {
        return longNode;
    }
    return NULL;  
}

void FindFirstEqualNodeTest()
{
    NodeL* head1=new NodeL(0);
    NodeL* head2=new NodeL(0);
    NodeL* node1=new NodeL(1);
    NodeL* node2=new NodeL(2);
    NodeL* node3=new NodeL(3);
    NodeL* node4=new NodeL(4);
    NodeL* node5=new NodeL(5);
    NodeL* node6=new NodeL(6);
    NodeL* node7=new NodeL(7);

    head1->next=node1;
    node1->next=node2;
    node2->next=node3;
    node3->next=node6;//两个链表相交于节点node6

    head2->next=node4;
    node4->next=node5;
    node5->next=node6;//两个链表相交于节点node6
    node6->next=node7;

    NodeL* node= FindFirstEqualNode(head1,head2);
    if (node)
    {
        cout<<node->value<<endl;
    }else{
        cout<<"没有共同节点"<<endl;
    }
}

15道简单算法题，首发于 博客 - 伯乐在线。

• —软件人才免语言低担保 赴美带薪读研！—

Intent最常见的用途是绑定应用程序组件，并在应用程序之间通信.Intent用来启动Activity,允许创建不同屏幕的一个工作流。

要创建并显示一个Activity，可以调用startActivity，并传递给它一个Intent,如：

startActiiy(myintent);

可以构造Intent来显示地指定要打开的Activity类，或者包含一个目标Activity必须执行的动作。在后面一种情况时，运行时将会使用一个成为"intent解析"的过程来动态选择activity.

如果想追逐来自子activity的反馈，可以使用startActivityForResult方法。

要显示地选择要启动的Activity类，可以创建一个新的Intent来指定当前activity的上下文以及要启动的Activity类，然后把这个Intent传递给startActivity.

Intent intent = new Intent(AActivity.this,MyOtherActivity.class);
startActivity(intent);

调用新Activity的finish或按下设备的返回键将关闭该activity,并把它从栈中移除。

隐式的intent和运行时迟绑定

隐式的Intent提供了一种机制，可以让匿名的应用程序组件响应动作请求。这意味着可以要求系统启动一个可执行给定动作的Activity,而不必知道需要启动哪个应用程序或activity.

例如可以使用一个隐式的intent来请求一个在电话号码(表示为一个URI)上执行动作(拨号)。

Intent intent = new Intent(Intent.ACTION_DIAL,Uri.parse("tel:13195338962"));
startActivity(intent);

当构建一个新的隐式的intent时，需要指定要执行的动作。另外，也可以提供执行那个动作需要的数据的URI。还可以通过向intent添加extra来向目标activity发送额外的数据。

当使用intent来启动一个activity时，android 将在运行时把它解析为最适合在指定的数据类型上执行所需动作的类。如果多个Activity都能够执行指定的动作，则会向用户呈现各种选项。

确定intent能否解析

在自己的应用程序中利用第三方应用程序的Activity和Service是十分方便的。但是，你无法保证用户设备上安装了特定的某个应用程序，或者设备上有能够处理你的请求的应用程序。因此，在调用startActivity之前，确定调用是否可以解析为一个Activity是一种很好的做法。

通过调用intent的resolveActivity方法，并向该方法传入包管理器，可以对包管理器进行查询，确定是否有Activity能够启动以响应intent.

PackageManager pm = getPackageManager();
if(intent.resolverActivity(pm) != null){
	startActivity(intent);
}

通过startActvity启动的Activity独立于其父activity，并且在关闭时不会提供任何反馈。

当需要反馈时，可以启动一个activity作为另一个activity的子activity，用它向父actvity传递结果。子activity只是以一种不同的方式启动的activity.因此，必须在mainfest文件中注册他们，就像其他的activity一样。

startActivityForResult(intent,1);

子activity通过设置setResult返回结果：参数为结果码和数据本身

setRsult(ACTIVITY.RESULT_OK,new Intent(Intent.ACTION_PICK,"ssss"););

父actvity通过OnaCTIVITYResult来处理子activity返回的结果。

@override
public void onActivityResult(int requestCode,int resultCode,Intent data){
super....
	switch(requestCode){
	case (1):
		if(rsultCode == Activity.RESULT_OK){
		String s = data.getData();
	}
}
}

Server SAN是现在一个全新的概念，现在给出的概念都太笼统。没有一个具体的定义。 按照老蒋的想法：Server San应该是一个利用软件将基于DAS存储（包含闪存卡，直连存储）的集合，做成一个能共享的SAN存储网络。

     SAN存储区域网，大家都很熟悉。普遍使用的就两种： FC SAN；ISCSI SAN。这两种结构都是通过FC网络或者IP网络将存储设备放到一个共享的环境中心，让分布式的服务HA，应用迁移，数据复制等都可以通过这套网络实现。但是大家注意了，这套SAN网络是很贵的，管理起来是很麻烦的。

在很多的环境下面，很多SAN环境中会有一部分直连存储我们根本没有用上：比如直连存储卡，本地硬盘等。 从实际的应用中，直连存储的效率是很高的：PCI-E直接到数据端，比经过FC协议的转换还要快。而且成本低。

Server SAN是一个最新的概念：将分布在各个服务器上的直连存储通过软件的方式整合成一个统一的SAN存储系统。有点类似谷歌在云计算上做的工作，将上万台服务器组成一个超级计算机。

现在Server San已经不是一个概念了，在谷歌和facebook的数据中心已经大量使用了。最经典的案例就是VMware中的vSAN 了。

VSAN利用一些在以太网中得到验证的技术，满足了光纤通道存储的性能和隔离要求，提供了一个业界最佳的解决方案。分区可以在边缘控制访问权限，因而在限制访问权限和交换阵列中不同设备间传输的流量方面非常有用。VSAN所提供的一项补充性的功能是，隔离交换阵列中提供的所有服务，并将它们“封装”到一个VSAN中，从而建立一个逻辑独立的交换阵列。
  
    VSAN创建的存储网络域不仅可以支持现有的安全机制，还可以在多个虚拟环境中隔离一台交换机。不同的VSAN之间可以提供完全的隔离，并确保某一个设备的故障或者交换阵列不稳定性的影响将会只限制于某一个VSAN中，而不是导致整个交换阵列的中断。所有这些都不需要部署那些要使用多个物理隔离的光纤通道交换机的解决方案。VSAN还可以通过最大限度地提高端口利用率和降低每个端口的成本，降低存储网络的TCO。这种部署非常有效，因为多个用户群体可以组织起来，从而让交换阵列基础设施可以用少得多的设备为这些用户提供服务。

6 月 8 日消息空气净化器品牌目前出现渠道、品牌、出货、价格、技术的四大扎堆现象，这是出自中怡康的一份调查报告结果。

渠道扎堆：天猫商城为线上渠道必争之地，商家入驻产品最多。据中怡康线上监测数据显示，线上市场空气净化器有 209 个品牌，1062 个型号，其中天猫商城涵盖 171 个品牌和 954 个型号。京东商城、国美在线分别涵盖 67 个品牌、323 个型号及 54 个品牌 、211 个型号。

品牌扎堆：线上市场竞争激烈，TOP3 品牌占比近 50%。线上空气净化器市场品牌较为集中，夏普、飞利浦、大金分别凭借 19%、17% 和 10% 的零售额份额包揽线上空气净化器前三名，三者累计份额超过 46%。而据另一家市场研究机构，奥维咨询(AVC)的报告显示，线下市场国外品牌也占绝对优势，飞利浦、夏普、松下前三甲占据超过 50% 的市场份额。

价格扎堆：线上产品集中在 1000-4000 元价格段，三大品牌主攻 2000-3000 元产品。从价格来看，线上空净产品价格主要集中在 1000-4000 元之间，该价格段的产品零售额占比累计达 71%，其中 1000-2000 元产品零售额占比 23.8%，2000-3000 元占比 26.3%，3000-4000 元占比 20.9%。

过滤技术和重数扎堆：目前，活性炭、HEPA、离子过滤为线上空净产品的主要过滤方式，其采用活性炭过滤技术的产品零售额份额为 67.8%，采用 HEPA 过滤技术的产品零售额份额为 67.0%，采用离子过滤技术的产品零售额份额为 63.9%。采用触媒技术和水洗技术的产品零售额份额分别为 25.8% 和 24.5%。据奥维咨询（AVC)监测数据显示，配备 HEPA、活性炭过滤和离子过滤系统的空气净化器占据八成左右的市场份额。

不同空气净化器品牌在过滤系统上的侧重点不同。夏普偏重于 HEPA 和离子过滤，飞利浦、松下偏重于活性炭过滤，美的、大金偏重于离子过滤，布鲁雅尔偏重于 HEPA 过滤，亚都偏重于活性炭和 HEPA 过滤。五重及以上过滤重数的空净产品占比最高，零售额份额达到 44.9%，除美的和飞利浦外，各大品牌都重视对五重及以上复合产品的布局。美的产品主要集中在四重过滤，飞利浦产品则分布在两重及四重过滤。

近两年，雾霾天气的多发成就了空气净化器行业，空气净化器在近段一直保持在搜索榜 TOP10 的前三位，并已进入全民需求时期。但现阶段我国空气净化器家庭保有量不足1%，渗透率远低于日韩和欧美发达国家。但随着越来越多的企业开始布局空气净化器市场，奥维咨询(AVC) 预计未来 3 年我国空气净化器销量将保持高速增长，2014 年空气净化器的市场规模将会突破 200 亿元。

报告显示已有越来越多的厂商进入市场，从 2013 年开始，空气净化器市场呈现爆发式增长，2012 年，空气净化器市场有 56 个品牌，2013 年有 77 个品牌，2014 达到 200 多家。

目前空气净化器主要采用碳吸附技术，技术门槛较低。而中国的空气净化器行业还处于高速增长期，整体利润都很高，空气净化器毛利率至少达到 100%。低技术门槛与超高利润让各类企业趋之若鹜，很多国际品牌、国内大品牌与中小企业纷纷进入，导致整个行业良莠不齐，空气净化器行业亟待规范。

本文链接

　　Google这些天被封了大量IP，导致现在访问Google服务越来越困难，使用Google搜索的用户也 大量下降，对于不想使用付费VPN的用户来说，修改hosts文件来访问Google仍然是一个免费简单的可行方案，今天我就介绍一下我通常用到的快速找到Google可用hosts的方法。

　　 寻找可用IP地址

　　通常Google的服务器有很多个，一般都会有访问加速功能，就是说对于不同国家会解析出访问速度最快的网址，因此通常中国访问的IP被封后，其他国家访问的IP还能用，因此只要使用一个Ping工具找出这个服务域名对应的多个ip地址，然后在Hosts文件里添加即可。

　　这个Ping工具实际是一个站长工具，主要用于测试一个网站在不同国家或地区的访问速度，很多网站都提供，一些cdn测试网站也有，百度或Google一下“ping检测”或“ping tools”就能找到很多。

　　 检测可用IP地址

　　现在，我们找到了一堆IP地址，到底那个是可用的IP地址呢，这里又分为两种情况：

　　1、HTTP的服务和网址

　　对于HTTP方式的网址，通常只是封了其80端口，检测方法一般是，“开始”-“运行”-“cmd”，然后输入 ping 目标IP地址，如果不返回“请求超时”的错误信息，通常就是可用的IP地址。

　　2、HTTPS的服务和网址

　　对于HTTPS方式的网址，不能用ping来检测，而要用telnet来检测，通过这个命令连接目标IP的443端口，能连接上的即为可用ip，具体方法是，“开始”-“运行”-“cmd”，然后输入 telnet 目标IP地址 443，如果没有返回“连接失败”提示，而是出现一个黑屏，则是可用IP地址，将其添加到hosts文件即可。

　　对于Windows7用户来说，需要现在“控制面板”-“程序”-“打开或关闭Windows功能”里选择打开“Telnet客户端”才能用Telnet。

　　 添加Hosts文件

　　找到可用IP后，就可以添加这个IP到Hosts文件里了，先关闭“电脑管家”、“360安全卫士”这类工具，然后编辑C:\Windows\System32\drivers\etc\hosts文件，在文件结尾添加一行“可用IP地址 目标域名”即可。

　　之后如果“电脑管家”、“360安全卫士”等工具检测hosts文件提供风险，只需信任这个文件并将其添加到白名单即可。

　　经过这些操作，就可以手动找出最新的Google可用IP地址。

　　现在，在中国正常地使用Google终于成为了一门技术。

评论《快速找到Google可用hosts的方法》的内容...

相关文章:

• Google在华广告业务遭遇冲击
• 谷歌在华遭遇大规模干扰
• Google https服务被屏蔽
• Google推出“灵鼻子”气味搜索
• 韩国媒体猜测谷歌重返中国

• —软件人才免语言低担保 赴美带薪读研！—