本文是一个DIY小夜灯的简易文档，由于笔者水平有限，无法保证没有错误和疏漏，为了避免“碰瓷”，做出如下声明。

在实际操作中，依据此文而产生的任何问题(包括但不局限于财产损失，人身伤亡等)与笔者无关，笔者既不赔偿，也不负法律责任。

如果您已经阅读了本文的一部分或全部内容，则表明您同意了上面的这个声明。

-------------------------下面正文--------------------------

微小功率的LED用的最多的就是阻容降压，然后限流点亮串联的LED。由于简单的阻容降压先天低效，只好串联LED提升工作电压来尽可能的提高效率，但由于LED的分散性，质量不好的先坏，串联起来的寿命远远低于单个LED的平均寿命。元器件简单降低成本，寿命还不会太长，两点都符合厂家经营之道，因此，这种先天缺陷的设计就成了市场主流。

下图是某个品牌3W LED灯泡的电路，该电路负载部分是一个560欧电阻和5个LED串联，供电部分是阻容降压后桥式整流，电解电容滤波后得到大约18V的直流电， 220V侧通过大约57毫安的工作电流。算下来功率220 * 57 / 1000 = 12.54VA，灯泡标称3W，好到计量插座测得只有1W，功率因数只有可怜的0.08，这种垃圾货却符合某大国一级能耗标准[习惯就好，砖家们订立的脑残标准多了去了]。

市面上几乎所有的小功率LED灯泡全是按照这种阻容降压整流再点亮LED的原理制作的，当然，全是绿色节能的“典范”，符合某国一级能耗标准。市面上大部分小功率5V充电头的功率因数接近0.5，远超普通的小功率LED节能灯，用来DIY小功率LED灯再好不过，借着一堆认证的优势，轻松把那些品牌小功率LED灯全部踩在脚下。

考虑到长期通电，设计上需要尽可能降低损耗，测试过几个闲置的5V电源的损耗作为候选。这些电源每个上面都有一堆几乎相同的认证标识，但实测结果嘛就是另外一回事了... 值得一提的是这里计算损耗用伏安VA，而非业界流行的瓦W。其实小功率开关电源即使满负荷，功率因数也极少超过0.5，空载更是惨不忍住，很多国货不足0.1(甚至低到0.01)，不用瓦W计算怎么去遮丑低效的电路呢？商人都懂质量好未必收益好，无底线的虚假广告+软文宣传是赚钱的法宝，其实何止LED光源，这是时代的商业文化，起码这片土上如此。

适配器实拍[旁边是一个5毫米草帽LED焊了一个1K欧电阻和USB口连线]

5V适配器损耗实测，容易看出基本分两档，有些电源可真不敢恭维，功率低[没准还虚标]损耗还大。

理论上能耗等级越高越好，个别厂家乱标的当然也有，这里就不说是谁家了，没有标注等级的一般低于III级。

最终选用了淘汰的微软手机充电头5V供电[实际大于3V就行]，实测总输入功率0.056VA，即使功率因数1.0[实际远远达不到]，算下来1年消耗不足0.5度电。LED发光亮度跟月光接近，对我而言刚刚好。如果觉得光线还不够柔和，LED可以用保鲜膜包一下(或半透明热缩管封一下等措施)。5V电源负载率很低，LED耗电占总功率的15%左右，电源自身损耗占了大约85%。如果觉得光线太暗，可以适当减小电阻增加电流从而增加亮度，例如1K欧姆电阻改为680或470或330或220欧姆等。

原理就这么简单，如下图。

对于所有编程学习者，尤其是零基础的同学们，在学习的初期，一定要给自己做一个思想上的转变。在我的编程学习理论中，这个思想的转变至关重要，什么时候你把这个思维转换过来了，你就是真正上道的那一天。

这个思维转换就是：不要把自己当学生，而是要把自己当开发者。

不同的身份认同感，最后会导致不同的行为模式，而这行为模式，会对你的编程学习造成非常大的影响。

区别一：记笔记 VS 写技术文章

学生有一个特点，就是他们喜欢记笔记，但是开发者不怎么记笔记，而是会把自己学会的东西写成技术文章、教程的形式发表在技术博客或者知乎等网站上。

一个很有名的学习法叫做费曼学习法，这个学习方法简单地说，就是在学完一个东西之后，去给别人讲明白，注意，是讲给别人听，当你写成文章发表在网上的时候，你自然会去用更通俗的语言，更清晰的逻辑去讲述这个事物背后的逻辑，这个过程，是对自己学习的一个检验，也是加深映像，整理思路的重要过程。

那么如果你是去记笔记的话，很有可能，你不会去试图讲清楚这个东西，而是倾向于去照抄，或是不完全照抄，以“提纲”或是“知识点”的形式抄在本子上，说句实话，照抄的笔记，真的没用，因为现在搜索引擎的能力已经可以让你把大多数东西快速找到，你为什么还要照抄到笔记本上呢？

从功利的角度考虑，技术文章的写作，别人可以直接访问，也可以逐渐累积你的影响力，一个好的个人技术博客，会给你的简历加分很多，而一个厚厚的笔记本，没有人会管你记了什么。

区别二：以学会XX为目标 VS 以做出XX为目标

你会发现，学生思维里面有一个重要的特点，就是他们总是特别关注自己“学会了什么”，不仅如此，他给自己定的目标，定的计划，永远都是”学会XX书第XX章内容“。

学生永远在准备, 而开发者早已动手。

如果你还在上学，学生思维是“这个学期我要学会XX课程”，而开发者思维是“这个学期我要做出XX”。

如果学Python，学生思维会拿起一本教材，开始从头到尾看，我不知道你们发现没有，几乎所有那种编程语言教材，长得都差不多，上来先是基本的语法，基本的整型变量，浮点型变量之类的，然后伴随着几个小的教学例子。

开发者学Python，他第一步绝对不是去书店买教材，而是先去了解，Python适合做什么，然后他了解到，Python适合做爬虫，数据分析，AI，还能很轻松地搭建Web后端，之后他逛了一下午Github，看了看那些Python高星项目都是做啥的，于是他给自己定下了这个目标：半年时间内，我要用Python和Python周边的库搭建出一个网站，这个网站服务端运用爬虫技术爬取一些数据，可以提供知乎粉丝性别比例分析功能。

学生继续看书，一个个的知识点去记忆，拿着他的小本本去总结知识点，而开发者上官网简单的看了下Reference Doc的简单交互式语法教程后，便马上开始了边做边学的过程，有了一个实际的项目目标，朝着这个目标走，不断地发现自己不会这，不会那，然后有目的性的去补足知识，他了解到了beautiful soup作为爬虫主库，flask作为后端web服务主库，然后会去看一些简单的教程，在这个过程中，基础语法得到了熟练，也训练了工程能力。

学生的成就感来源于学会了什么，开发者的成就感来源于做出来什么。

开发者很功利，他们深知他们学会的所有东西都是为了开发出伟大的产品而服务的，所以他们绝对不会出现“在学一个东西，但是也不知道学这个用来干嘛”的窘境。

区别三：厌恶不确定性 VS 接受不确定性

学生们总是对“确定性”有一种几乎疯狂的追求，他们总问，“C语言学到什么程度就一定能被大厂录取？”，“掌握XX要几个月？”，“上课认真听讲，认真做笔记，考试是否一定能上80分？”

这种对确定性的追求，直接导致学生有一种下意识的举动：

干什么都等准备好了再去做，但是却“永远在准备”。

因为他们害怕那种不太会还要硬上带来的各种不确定性，他们渴求一种内功的修炼，寄希望于”把基础夯实了，就能顺畅的开发，所以还是先夯实基础吧！”

开发者选择接受这种不确定性，他们愿意”边学变做“，因为他们知道，最初学习敲键盘的时候，他们就是这么做的，边看某个按键在哪，边打字，做和学交叉进行，他们始终抱有疑问，他们又始终试图通过学习的延伸拓展去解决疑问，他们仿佛就像是拿着烛火在迷宫中行走的侠客，在游戏的一开始，对迷宫的结构一无所知，通过不断地摸索和碰壁，逐渐建立起对整个地图的认知.

区别四: 线性学习 VS 递归学习

学生喜欢线性的学习，因为线性的学习（拿本教材从头到尾慢慢看）正是符合了他们对确定性的追求，可惜这违背了学习的本来面目

开发者知道，人脑最不擅长的就是线性枚举，即便我们认识几千个汉字，但是我们无法去线性地去将所有认识的汉字枚举出来，我们的大脑，本就不是用来进行线性思考的，而复杂度上了一定程度的知识，线性的掌握，基本不可能。

有难度的知识，往往是这样的：为了搞懂A，而去学B，为了学会B，而去学C，这叫递归学习，递归虽深，但有回溯，它最终会回溯到我们的起点。

所以开发者的学习更偏向于递归式的学习，而且可能会以一个知识点为起点，去完成树状知识外围的遍历。（有点像搜索引擎去爬虫）

知识是树状结构, 或者网状结构.

当我们试图遍历一个树的时候, 最简单直接的方式就是递归, 如果你非要去"线性"的学, 那就你是把编程学习当成了链表, 还是“单向”的，这种算法怎么可能用来遍历树呢？

区别五：拿会XX定义自己 VS 拿XX项目作者定义自己

linus 从来不说自己精通 c 语言, 与其说他不需要, 不如说他不关心, 因为他是 linux 和 git 的作者.

linus 这个程序员之神就是一个典型的开发者思维的人.

我希望所有计算机专业的同学们, 等你们毕业了之后, 你的github应该是绿油油的, 而不是贫瘠的一片白.

我希望你们用你们的简历里写的是"用c语言实现了一个XX引擎, github链接”http://github.com/xxxxxx”而不是"精通c".

我希望学生们明白, 任何一个像样子的项目, 制作周期至少是按月计, 你的大学有四年时间, 哪怕一个项目做一年, 你也能拿出两三个好项目, 不一定有多少star, 但是要完整, 文档, 测试, 一应俱全.

我希望学生们知道, 做项目和写课后习题不一样, 课后习题一个小时, 而项目是长期不断努力, 不断学习突破的过程, 需要你每天都搞, 善始善终, 最终拿出成果来.

我希望学生们明白, 这个世界衡量一个人的成就, 从来都是"他做了什么", 而不是"他学会了什么", 不要总用修炼内功去感动自己, 必要时, 也请你为开源世界贡献一点自己的力量.

我希望学生们明白, 考上985, 拿奖学金, 这都不叫成就, 因为和别人没关系, 只有真正影响到别人的东西, 让这个世界变得更好的东西, 才是值得去"秀"的.

最后送给学生们一句话: 愿你早日忘记学生的身份, 以开发者的姿态, 面对这个世界。

2007年初，刚刚卸任的联合国秘书长安南，在德克萨斯州的一个庄园里举行了一场慈善晚宴，旨在为非洲贫困儿童募捐。应邀参加晚宴的都是富商和社会名流。在晚宴将要开始的时候，一位老妇人领着一个小女孩来到了庄园的入口处，小女孩手里捧着一个看上去很精致的瓷罐。

 守在庄园入口处的保安安东尼拦住了这一老一小。“欢迎你们，请出示请柬，谢谢。”。

“请柬，对不起，我们没有接到邀请，是她要来，我陪她来的。”老妇人抚摸着小女孩的头。

 “很抱歉，除了工作人员，没有请柬的人不能进去。”安东尼说。

“为什么？这里不是举行慈善晚宴吗？我们是来表示我们的心意的，难道不可以吗？”老妇人的表情很严肃，“可爱的小露西，从电视上知道了这里要为非洲的孩子们举行慈善活动，她很想为那些可怜的孩子做点事，决定把自己储钱罐里所有的钱都拿出来，我可以不进去，真的不能让她进去吗？”

“是的，这里将要举行一场慈善晚宴，应邀参加的都是很重要的人士，他们将为非洲的孩子慷慨解囊。很高兴你们带着爱心来到这里，但是，我想这场合不适合你们进去。”安东尼解释说。

“叔叔，慈善的不是钱，是心，对吗？”一直没有说话的小女孩问安东尼，她的话让安东尼愣住了。“我知道收到邀请的人有很多钱，他们会拿出很多钱，我没有那么多，但这是我所有的钱啊，如果我真的不能进去，请帮我把这个带进去吧！”小女孩露西说完，将手中的储钱罐递给安东尼。

安东尼不知道是接还是不接，正在他不知所措的时候，突然有人说：“不用了，孩子，你说得对，慈善的不是钱，是心，你可以进去，所有有爱心的人都可以进去。”说话的是一位老头，他面带微笑，站在小露西身旁。他躬身和小露西交谈了几句，然后直身起来，拿出一份请柬递给安东尼：“我可以带她进去吗？”

安东尼接过请柬，打开一看，忙向老头敬了个礼：“当然可以了，沃伦·巴菲特先生。”

当天慈善晚宴的主角不是倡议者的安南，不是捐出300万美元的巴菲特，也不是捐出800万美元的比尔·盖茨，而是仅仅捐出30美元零25美分的小露西，她赢得了最多最热烈的掌声。而晚宴的主题标语也变成了这样一句话“慈善的不是钱，是心。”第二天，美国各大媒体纷纷以这句话作为标题，报道了这次慈善晚宴。看到报道后，许多普普通通的美国人纷纷表示要为非洲那些贫穷的孩子捐赠。

二分插入排序

直接插入排序时后面的元素从后向前逐个比较寻找插入位置，有时候没有必要这样做，因为此时需要寻找合适插入位置的当前这个元素前面的子序列已经有序，如果使用二分查找插入位置往往可以减少平均搜索长度。对于一个待排序的随机序列而言，用二分插入排序取代直接插入排序，尽管总的移动元素次数不可能减少，但是可能减少总的平均比较次数。二分插入排序的平均时间复杂度为O(n²)，最坏情况下的时间复杂度为(n²)，当待排序序列已经有序时，排序时间复杂度为O(nlogn)。空间复杂度为O(1)。二分插入排序是否稳定依赖于具体实现。

假设一个序列已经有序，此时我们需要向这个序列里插入一个新的值，那么我们如何找到合适的位置呢？

首先跟序列最中间的那个元素比较，如果比最中间的这个元素小，则插入位置在它的左边，否则在它的右边。以当前最中间位置为分割点，如果在左边，则当前最中间位置是待搜索子序列的终点，如果在右边，右边邻接的元素将是待搜索子序列的起点。按照这种原则，继续寻找下一个中间位置，并继续这种过程，直到找到合适的插入位置为止。

问题是何谓合适的插入位置？如果序列中有一个元素与当前待插入的元素值相等，那么插入位置应该选在该元素的前面还是后面呢？选在后面则二分插入排序稳定，选在前面则二分插入排序不稳定。如果序列中有多个元素与当前待插入的元素值相等，插入位置选在哪里呢？选在最后一个的后面则二分插入排序稳定，其它情况均不稳定。这里的“前面”位置和“后面”位置通常被称为上界和下界。

还有，对数组二分插入排序比较简单，那么能对链表进行二分插入排序吗？理论上没有什么问题，如果希望代码复用程度高的话，链表需要提供迭代器。问题关键不在于代码复用性怎么样，而是插入排序的速度太慢，一般不采纳。

使用二分插入排序对一个无序序列排序的场合极其罕见，因为太多的时候让一个静态序列有序则有更快的排序算法可以选用，当一个序列很短时，直接插入排序由于开销小比二分插入排序要快一点，当待排序序列较长时有很多排序算法(本文后面会介绍一些)均比二分插入排序快得多。

桶排序

当待排序的随机序列密集的分布于一个狭窄区间时，使用计数排序速度比较快，当待排序的随机序列比较均匀的分布于一个较宽区间时，可以考虑使用桶排序。桶排序的时间复杂度为O(n)，空间复杂度也为O(n)。

 既然一个待排序的随机序列比较均匀的分布于一个区间，就很容易散列到各个桶中，假设有 n 个元素比较均匀的散列到 m 个桶中，则每个桶中的元素数目约为 n/m，可以使用普通排序算法对每个桶中的元素排序，排序完毕后再把所有元素复制到最初序列的位置覆盖原始序列。实际应中n/m 通常很小，可以使用直接插入排序给每个桶中的元素排序，总的时间复杂度为O(n + m*(n/m)² + n) = O(n²/m + 2n)  = O(n)。如果每个桶的元素用链表存储，链表可以用归并排序，各桶排序完毕后把各个链表连接起来就可以了，省去一次复制元素的麻烦，这样操作的时间复杂度为O(n + m(n/m)log(n/m)) = O(n + nlogk) = O(n)。

以随机整数为例，桶排序过程如下表。

计数排序

如果给一个分布于区间[min, max)的随机序列排序，可以考虑使用计数排序，max-min 越小说明分布越集中，此时使用计数排序效果就越好，计数排序是一种稳定的排序算法。一般而言，计数排序的时间复杂度为O(n)，空间复杂度O(n)，从理论上来看，它比时间复杂度O(nlogn)的算法明显快一些。

 使用计数排序算法对一个正整数序列进行升序排序时，假设对于某个元素比它小的元素个数为 i(其中0≤i<max，获取该信息无需借助比较运算)，则排序后该元素就应该位于数组下标为i的位置。现在的问题是，如果对于等于某个值的正整数不止一个该如何确定各自位置呢？这个问题在实现中容易解决。

 为了能够正常排序，需要用max-min 个辅助空间记录不同正整数的个数，由于排序无法原地进行，还需要开辟等大的辅助空间容纳排序后的所有正整数，一般而言，max-min 不大于待排序的正整数个数或与之相当，可见空间复杂度为O(n + (max-min)) = O(n)。

以一个随机整数序列为例，计数排序过程如下。

二路归并

如果内存充足，可以考虑使用非原地的归并排序获得更快的速度。非原地的归并排序算法空间复杂度为O(n)，时间复杂度O(nlogn)。它的核心是归并，下面看看归并的基本实现过程。

待排序序列：

52, 50, 50, 74, 61, 46, 84, 85, 73, 23, 94, 53, 97, 98, 65, 87, 29, 13, 61, 58, 19

可以把上面的无序序列分成四段并对各段进行插入排序，得到四个有序子序列：

46, 50, 50, 52, 61, 74, 84, 23, 73, 85, 94, 13, 29, 53, 65, 87, 97, 98, 19, 58, 61

两两归并成一段，得到两个有序子序列：

23, 46, 50, 50, 52, 61, 73, 74, 84, 85, 94, 13, 19, 29, 53, 58, 61, 65, 87, 97, 98

归并成一个有序序列，排序完成。

13, 19, 23, 29, 46, 50, 50, 52, 53, 58, 61, 61, 65, 73, 74, 84, 85, 87, 94, 97, 98

原地归并排序的时间复杂度为O(nlog²n)，空间复杂度为O(logn)，相对于传统的非原地归并排序(时间复杂度O(nlogn)，空间复杂度O(n))而言，十分节约内存，但排序速度稍慢。在内存紧张且需要排序稳定的场合，原地稳定排序可以发挥其特长。

在介绍原地稳定排序的原理之前，需要先了解两个基本算法，旋转和二分查找。

a) 旋转

旋转又称循环移动，假设有这样一个序列：e₀, e₁, …, e_i-1, e_i, e_i+1, …, e_n-1, e_n。现在我们需要把它向左循环移动i个位置变成：e_i, e_i+1, …, e_n-1, e_n, e₀, e₁, …, e_i-1。为了尽可能的节约内存和保证较快的速度，我们可以在时间复杂度O(n)，空间复杂度O(1)的情况下达到目的。一种解决方案如下：

把原始序列看成两个子序列：e₀, e₁, …, e_i-1和e_i, e_i+1, …, e_n-1, e_n

把这两个子序列分别逆序得：e_i-1, …, e₁, e₀和e_n, e_n-1, …, e_i+1, e_i

也就是得到了这样一个序列：e_i-1, …, e₁, e₀, e_n, e_n-1, …, e_i+1, e_i

再把上面的序列整体逆序得：e_i, e_i+1, …, e_n-1, e_n, e₀, e₁, …, e_i-1

以上旋转过程的时间复杂度为O(n/2) + O(n/2) + O(n) = O(2n) = O(n)，逆序时仅需要一个元素的辅助空间，空间复杂度O(1)。

b) 二分查找

二分查找比较简单，在前面的二分插入排序算法里使用了二分查找获得上界(假设序列升序，序列中最后一个相同值的下一个位置或没有相同值时刚好比它大的那一个元素位置)。这里看看怎么使用二分查找获得下界(假设序列升序，序列中第一个相同值的位置或没有相同值时刚好比它小的那一个元素位置)。

下面以整数为例，看看怎么获得下界。

假设在一个有序序列10, 12, 12, 13, 13, 13 14, 14, 17, 17, 18, 19, 19中查找16。

该序列长度为13，找到中间值14，它比16小，查找的子序列长度降为6，在子序列[14, 19]中继续查找。找到中值18，它比16大，查找的子序列长度降为3，在子序列[14, 17]中继续查找。找到中值17，它比16大，查找的子序列长度降为1，在子序列[14, 14]中继续查找，找到14，它比16大，查找的子序列长度降为0，查找失败。返回14后面的元素位置，即第一个17的位置。

使用二分查找的前提条件是待查序列必须有序。无论查找上界还是下界，以及是否查找成功，二分查找的时间复杂度为O(logn)。或许有些读者在有的书上见过有的二分查找算法既不获得确定的上界也不获得确定的下界，可惜这样的二分查找算法除了考试以外似乎没有多大实用价值。

c) 原地稳定排序的原理

以整数为例，假设有一个需要稳定排序的无序序列：

52, 50, 50, 74, 61, 46, 84, 85, 73, 23, 94, 53, 97, 98, 65, 87, 29

首先需要把较长的序列使用插入排序分成多个有序的短序列。上面的序列可以分成两个子序列，然后分别进行插入排序，得到：

46, 50, 50, 52, 61, 74, 84, 85, 23, 29, 53, 65, 73, 87, 94, 97, 98

在前段[46, 85]查找后段[23, 98]的中值得73，返回74，这样后段[23, 98]的前部分[23, 65]中的任何元素比前段[46, 85]的后部分[74, 85]任何元素都小，旋转这两部分，得到：

46, 50, 50, 52, 61, 23, 29, 53, 65, 74, 84, 85, 73, 87, 94, 97, 98

在[23, 85]中查找[46, 61]的中值50，返回53，旋转[50, 61]和[23, 29]，得到：

46, 50, 23, 29, 50, 52, 61, 53, 65, 74, 84, 85, 73, 87, 94, 97, 98

在[46, 50]之间查找29，返回46，旋转得到：

23, 46, 50, 29, 50, 52, 61, 53, 65, 74, 84, 85, 73, 87, 94, 97, 98

在[29, 29]之间查找50，返回50，旋转得到：

23, 29, 46, 50, 50, 52, 61, 53, 65, 74, 84, 85, 73, 87, 94, 97, 98

在[53, 65]之间查找52，返回53，旋转，得到：

23, 29, 46, 50, 50, 52, 53, 61, 65, 74, 84, 85, 73, 87, 94, 97, 98

在[74, 85]之间查找94，返回73，在[73, 87]之间查找84，返回87，旋转得到：

23, 29, 46, 50, 50, 52, 53, 61, 65, 74, 73, 84, 85, 87, 94, 97, 98

交换73 和74，最终排序完毕。

23, 29, 46, 50, 50, 52, 53, 61, 65, 73, 74, 84, 85, 87, 94, 97, 98

以上代码实现中用到了直接插入排序，该部分内容见本主页的快排介绍。

选择排序

假设一个待排序的序列中有 n 个元素，从这 n 个元素中选出一个最小(大)的元素放在第 0 个元素的位置，再从余下的 n-1 元素中选出一个次小(大)的元素放在第 1 个元素的位置，继续这个过程...，经过 n-1 次选择和交换，整个序列成为一个升(降)序序列，这就是选择排序的排序过程。无论最好还是最坏情况，选择排序的时间复杂度始终为O(n²)，空间复杂度为O(1)，选择排序并不稳定。

以一个随机整数序列为例，选择排序过程见下表。

冒泡排序

水底的气泡是逐渐上浮的，而不是一下子就到达水面。冒泡排序与之类似，当用冒泡排序算法对一个无序序列升序排序时，后面较小的元素与前面较大的元素逐个交换位置，直到无元素交换为止，则整个序列成为一个有序序列。

冒泡排序的时间复杂度为O(n²)，空间复杂度为O(1)，当原始序列已经有序，则冒泡排序的时间复杂度为O(n)。当待排序序列基本有序时，使用冒泡排序速度往往比较快。

以一个整数序列的为例，冒泡排序过程见下表。

基数排序有时也被称作卡片排序，也是一种时间复杂度为O(n)的排序。为了给一个序列排序，基数排序需要大约相当的辅助空间(通常使用队列)，可见空间复杂度为O(n)。 假设有一个无序序列含有n 个整数，整数的基数是k，最大有d 位(例如： 对于十进制整数而言， k = 10，可能的值是 0, 1, 2, ..., 8, 9，在 32 位系统上 d≤10，在64 位系统上 d≤20)，则基数排序的时间复杂度为O(d(n+k)) = O(n)。当对整数排序时，使用10进制虽然比较容易理解，但是速度慢(因为为了得到各位数字需要做除法和取模等操作)，为了尽可能的减小时间开销，通常使用2 的指数次幂进制(例如：2, 4, 8, ..., 2^r，r为2进制的幂)，这样可以借助位移运算减小耗费CPU 指令数，提升运行速度。对于b位(在PC机上， b通常为32或64)的整数而言， d = b/r， k = 2r，于是时间复杂度O(d(n+k)) = O(b/r(n+2r))，理论上，当b/r(n+2r)最小时，速度应该最快。

以一个随机整数序列为例，基数排序的过程见下表。

希尔排序，以其发明者Donald Shell的名字来命名，是最早突破时间复杂度屏障O(n²)的算法之一。希尔排序是直接插入排序的变种，它不是一种稳定的排序算法。希尔排序的原理是首先比较远距离的元素，然后递减比较距离，最终比较相邻元素。由于采用这种比较方式来排序，希尔排序有时候也被称为递减增量排序。

增量序列的不同将直接影响希尔排序的速度，因此，不方便给出希尔排序理论上的时间复杂度。 Hibbard采用的增量序列为：1, 3, 7, ..., 2k– 1，(k = 1, 2, ...)，最坏情况下的时间复杂度为O(n^3/2)，Sedgewick 建议了几种增量序列，最坏情况下的时间复杂度为O(n^4/3)，平均时间复杂度O(n^7/6)，Empirical研究发现它们的实际性能要比Hibbard的增量序列好一些，其中最好的是1, 5, 19, 41, 109, . . .，也就是说增量值要么为9*4ⁱ- 9 *2ⁱ + 1 要么为4ⁱ - 3 *2ⁱ + 1，(i = 0, 1, 2, ...)。希尔排序的空间复杂度依赖于具体实现。

以随机整数序列为例，采用Hibbard 增量序列的希尔排序过程如下表。

 1 template <typename RandomIterator, typename T, typename Compare>
 2 inline void shell_linear_insert(RandomIterator first, RandomIterator last,
 3                                 int incr, T value, Compare cmp)
 4 {
 5  for(; first > last; first -= incr)
 6    if(cmp(value, *(first - incr)))
 7      *first = *(first - incr);
 8  else
 9    break;
10  *first = value;
11 }
12 
13 // for Hibbard sequence： 1, 3, 7, 15, 31, 63, 127, 
14 // worst cast time complexity O(n^(3/2))
15 template <typename RandomIterator, typename Compare>
16 inline void shell_sort_H(RandomIterator first, RandomIterator last, Compare cmp)
17 {
18   if(last - first < 2)
19     return;
20   for(int incr = ((last - first) >> 1) - 1; incr > 1; incr = (incr >> 1) - 1)
21     for(RandomIterator i = first + (incr + 1); i < last; ++i)
22       shell_linear_insert(i, first + incr, incr, *i, cmp);
23   final_insertion_sort(first, last, cmp); // the last incremental value must be 1
24 }
25 
26 // for Sedgewick and Empirical sequence： 1, 5, 19, 41, 109, 209, 
27 // average time complexity O(n^(7/6)), worst case O(n^(4/3))
28 template <typename RandomIterator, typename Compare>
29 inline void shell_sort_S(RandomIterator first, RandomIterator last, Compare cmp)
30 {
31   long len = static_cast<int>(last - first);
32   if(len < 2)
33     return;
34 //  long arr[28];
35 //  for(long i = 0; i < 14; ++i)
36 //  {
37 //    arr[i*2] = 9*((1<<(2*i)) - (1<<i)) + 1;
38 //    arr[i*2 + 1] = ((1<<(2*(i+2))) - 3*(1<<(i+2))) + 1;
39 //  }
40   long arr[28] =
41   { 5, 19, 41, 109, 209, 505, 929, 2161, 3905, 8929, 16001, 36289, 64769,
42     146305, 260609, 587521, 1045505, 2354689, 4188161,  9427969, 16764929,
43     37730305, 67084289, 150958081, 268386305, 603906049, 1073643521 };
44 
45   for(long i = 27; 0 < i; --i)
46   {
47     if(len < arr[i])
48       continue;
49     for(RandomIterator it = first + (arr[i] + 1); it < last; ++it)
50       shell_linear_insert(it, first + arr[i], arr[i], *it, cmp);
51   }
52   final_insertion_sort(first, last, cmp); // the last incremental value must be 1
53 }

2006年的职场出奇的冷清，相比前几年，简历的数量和质量都大为不如，很难得找到三年工作经验以上的人，有一个 不是特别笨，就是特别怪。就是么，干得好谁没事换工作啊！Simon是一家外企软件公司的总经理，最近给这个问题愁坏了。项目一个接一个的接下来，人手越 来越紧张。虽然Simon是个极限编程的粉丝，但也不得不批准了一份又一份的加班申请。HR经理把这个问题归结到房价上，他的妙论是“怕失业了还不上房 款，不敢跳槽”。

这天，K项目组长Allen终于忍不住了，带了一个只有一年工作经验的小伙子要Simon面试，“很聪明！经验少了点。”

Simon皱了皱眉毛，说：“你不知道这个职位最低要求是三年工作经验吗？”

Allen说：“这已经是三个月里通过技术考试中最好的一个了，老大，试试吧。”Allen是Simon多年的哥们，比较随便。

抵到面子上来，Simon只好让Allen把小伙子带进来。

Simon的面试通常是三步曲：

问题一：你能说说毕业后的主要工作经历吗？

问题二：再说说你在公司的地位？

问题三：你的发展目标是什么？等回答后，比如说架构师，他就跟着问：想象一下你当架构师的一天，说给我听听？

小伙子回答第一问题很快很清楚，一年工作当然没什么东西。Simon觉得小伙子挺聪明。所以在小伙子回答了第二个问题后，问了一个发散性的问题：“你刚才说你在公司里处于中等水平，那比你差的人为什么会比你差呢？”

这个问题是个陷阱。

小伙子冒冒失失回答说：“我觉得他们每天工作是为工作而工作，工作没有责任感。”

Simon点点头说：“是吗？那真是糟糕的员工。那你刚好比糟糕的员工好一点了？”

小伙子的脸一下子红了，“我不是这个意思……”

“好了，那你说说比你好的人为什么比你强？”

“我觉得他非常努力，工作很多年了还在学习各种构架，水平很高。”于是Simon就问那最后一个问题。果然，小伙子回答的是要成为架构师。大概70％的人想成为架构师。但是架构师是什么呢？

Simon问道：“那你为什么要成为架构师呢？”

小伙子一愣，大概还没有人这么置疑过他。“年纪大了，不能老写程序吧。”这个回答，让Simon想起关于他对什么是老的定义：当你希望做年轻人做的事情时，你就还年轻；如果你希望做老年人做的事情，你就老了。这和你出生了多长时间是没有关系的。

Simon接着问：“好吧，那你说说你成为架构师以后，每天都会做什么？”

小伙子说：“我还没想过，不过，我想应该主要是需求分析，设计构架吧……”这大概是现在年轻人的通病，年轻人很容易追逐一些自己也不清楚的目标。

Simon问：“那设计构架具体都做些什么呢？”

小伙子这次的回答是：“比如，选择程序框架，决定用Spring或Struts等等。”

“哦，那我问你，你怎么说服别人是用Spring还是Struts呢？”

“如果我有经验，我会知道哪个更好……”

“是吗，但关于Spring或Struts的知识任谁都可以很容易得到。如果别人不同意你的建议，你怎么说服他？如果同意你的建议，那你不过是作出了和别人一样的认识，别人又凭什么认可你呢？”

小伙子没想过架构师日子里还有一个说服人的工作，说：“我是架构师，我应该有权力做决定吧？”

Simon想起权力的三种层次，第一层，任命；第二层，专业；第三层，品德。

Simon问：“如果在一个成熟的软件企业里没有你所想象的架构师呢？或者说，架构师这种职业已经死亡或消失了呢？你会怎么定位你的职业？”

小伙子显得很震惊。

Simon画了一个系统构架，然后又给小伙子看了一段代码。

“那一个更难懂？”Simon问。

小伙子指着代码说：“代码难懂。”

Simon的解释是：“这就是为什么实际上所谓的架构师不存在的原因。一个更简单的东西怎么会更有价值呢？每个人都能够画出这种构架图，但不是每个人都能写出好的代码。”

送走了小伙子，Simon有点难受。他有点喜欢这个小伙子，但是，这又是一个被愚蠢的教育和误人子弟的技术杂志污染的家伙。Simon在自己的笔记本中加了一句话：中国程序员最愚蠢的认识之三：我想当架构师。前面两个赫然是：

35岁后写不动程序了；

我只要做Java（C＋＋）；

测试配置

• 硬件: Intel Core i7 920@2.67Ghz(4 core, HyperThread), 12GB RAM
• 操作系统: Microsoft Windows 7 64-bit

渲染的解像度为256x256，每象素作100次采样。

结果及分析

下表中预设的相对时间以最快的单线程测试(IC++)作基准，用鼠标按列可改变基准。由于Ruby运行时间太长，只每象素作4次采样，把时间乘上25。另 外，因为各测试的渲染时间相差很远，所以用了两个棒形图去显示数据，分别显示时间少于4000秒和少于60秒的测试(Ruby是4000秒以外，不予显 示)。

C++/.Net/Java组别

静态语言和动态语言在此测试下的性能不在同一数量级。先比较静态语言。

C++和.Net的测试结果和上一篇博文相若，而C#和F#无显著区别。但是，C++/CLI虽然同样产生IL，于括管的.Net平台上执行，其渲染时间 却只是C#/F#的55%左右。为什么呢？使用ildasm去反汇编C++/CLI和C#的可执行文件后，可以发现，程序的热点函数 Sphere.Intersect()在两个版本中，C++/CLI版本的代码大小(code size)为201字节， C#则为125字节！ C++/CLI版本在编译时，已把函数内所有Vec类的方法调用全部内联，而C#版本则使用callvirt调用Vec的方法。估计JIT没有把这函数进 行内联，做成这个性能差异。另外，C++/CLI版本使用了值类型，并使用指针(代码中为引用)托管代码(C++/CLI)的渲染时间，仅为原生非括管代码(IC++)的1.91倍，个人觉得.Net的JIT已经非常不错。