博客园_还有多少青春可以挥霍

Javascript小技巧,去掉小数位并且不会四舍五入

2012-01-30T09:53:00Z

   1:  var n3 = 52.3685;

   2:  document.writeln(n3 >> 0);// 52

   3:  可以去掉小数。

如上代码,就是这么简单

右移位操作导致小数部分丢失,为何会这样呢?左移位可以吗?移位操作是否都有如此功能呢?

带着疑问又写了一段代码用来测试以上想法,继续上代码

   1:  {

   2:      n = 52.123456;

   3:      //alert(typeof n);

   4:      alert(n);

   5:  }

   6:  //有符号右移

   7:  {

   8:      n = 52.123456;

   9:      var n2 = n >> 0;

  10:      //alert(typeof n2);

  11:      alert(n2);

  12:  }

  13:  //无符号右移

  14:  {

  15:      n = 52.123456;

  16:      var n3 = n >>> 0;

  17:      //alert(typeof n3);

  18:      alert(n3);

  19:  }

  20:  //左移0位

  21:  {

  22:      n = 52.123456;

  23:      var n4 = n << 0;

  24:      //alert(typeof n4);

  25:      alert(n4);

  26:  }

  27:  //按位或or

  28:  {

  29:      n = 52.123456;

  30:      var n5 = n | 0;

  31:      //alert(typeof n5);

  32:      alert(n5);

  33:  }

  34:  //按位异或xor

  35:  {

  36:      n = 52.123456;

  37:      var n6 = n ^ 0;

  38:      //alert(typeof n6);

  39:      alert(n6);

  40:  }

那,这里不卖关子,直接给出测试结果来:以上五种方法均可以去掉小数点;然而为什么会这样呢?
翻翻EAMCScript规范吧,或许里边会有答案,见http://bclary.com/2004/11/07/#a-9.5

先来看看位操作都做了什么,下边是位操作的实现步骤,重点在第五,第六步

11.7.1 The Left Shift Operator (<< )

Performs a bitwise left shift operation on the left operand by the amount specified by the right operand.

The production ShiftExpression : ShiftExpression << AdditiveExpression is evaluated as follows:

1. Evaluate ShiftExpression.

2.Call GetValue(Result(1)).

3.Evaluate AdditiveExpression.

4. Call GetValue(Result(3)).

5.Call ToInt32(Result(2)).

6.Call ToUint32(Result(4)).

7.Mask out all but the least significant 5 bits of Result(6), that is, compute Result(6) & 0x1F.

8.Left shift Result(5) by Result(7) bits. The result is a signed 32 bit integer.

9.Return Result(8).|

再来看看那锅ToInt32干了什么,重点在第三步
9.5 ToInt32: (Signed 32 Bit Integer)

The operator ToInt32 converts its argument to one of 2³² integer values in the range -2³¹ through 2³¹-1, inclusive. This operator functions as follows:

1. Call ToNumber on the input argument.

2. If Result(1) is NaN, +0, -0, +∞, or -∞, return +0.

3. Compute sign(Result(1)) * floor(abs(Result(1))).

4. Compute Result(3) modulo 2³² ; that is, a finite integer value k of Number type with positive sign and less than 2³² in magnitude such the mathematical difference of Result(3) and k is mathematically an integer multiple of 2³² .

5. If Result(4) is greater than or equal to 2³¹ , return Result(4)-2³² , otherwise return Result(4).

最后来看那个floor是什么意思,这里重点看第三步的后半拉,就是那个floor是干什么滴

floor(x) = x-(x modulo 1)

看见没,就在这一步把小数干掉了

Floor(x) 等于x减去x模上1

即

N= 52.123456 – 52.123456%1

=52.123456-0.1234559999999

=52

搜代斯呐,春节快乐~

本文链接

javascript中的封装多态和继承

2012-01-06T08:48:00Z

封装Encapsulation

如下代码,这就算是封装了

(function (windows, undefined) {

var i = 0;//相对外部环境来说,这里的i就算是封装了

})(window, undefined);

继承Inheritance

(function (windows, undefined) {

//父类

function Person() { }

Person.prototype.name = "name in Person";

//子类

function Student() { }

Student.prototype = new Person();           //修复原型

Student.prototype.constructor = Student;    //构造函数

Student.prototype.supr = Person.prototype;  //父类

//创建子类实例

var stu = new Student();

Student.prototype.age = 28;

Student.prototype.supr.name = "name in Student instance";

//打印子类成员及父类成员

alert(stu.name); //name in Student instance

alert(stu.supr.name); //name in Person

alert(stu.age); //28

})(window, undefined);

多态Polymorphism

有了继承,多态就好办了

//这就是继承了

(function (windows, undefined) {

//父类

function Person() { }

Person.prototype.name = "name in Person";

Person.prototype.learning = function () {

alert("learning in Person")

//子类

function Student() { }

Student.prototype = new Person();           //修复原型

Student.prototype.constructor = Student;    //构造函数

Student.prototype.supr = Person.prototype;  //父类

Student.prototype.learning = function () {

alert("learning in Student");

//工人

function Worker() { }

Worker.prototype = new Person();           //修复原型

Worker.prototype.constructor = Worker;    //构造函数

Worker.prototype.supr = Person.prototype;  //父类

Worker.prototype.learning = function () {

alert("learning in Worker");

//工厂

var personFactory = function (type) {

switch (type) {

case "Worker":

return new Worker();

break;

case "Student":

return new Student();

break;

return new Person();

//客户端

var person = personFactory("Student");

person.learning(); //learning in Student

person = personFactory("Worker");

person.learning(); //learning in Worker

})(window, undefined);

本文链接

[转载]我想和你一起吃晚餐

2011-12-15T05:16:00Z

父亲下班回家已经很晚了，身体疲倦、心情也不太好。这时，他发现5岁的儿子正靠在门边等他。

“我可以问你一个问题吗？”儿子问。

“什么问题？”父亲有些不耐烦。

“爸，你1小时能挣多少钱？”

“这与你无关。为什么要问这样的问题？”父亲生气地说。

“我只是想知道。”儿子望着父亲，恳求道：“请告诉我，你1小时挣多少钱？”

“假如你一定要知道的话，那我就告诉你吧。我1小时挣20美元。”父亲有点按捺不住了。

“喔。”儿子沮丧地低下头。过了一会儿，他又抬起头，犹犹豫豫地说：“爸——，可以借给我10美元吗？”

父亲终于发怒了：“如果问这种问题就是想要向我借钱去买毫无意义的玩具，那你还是回房间去，躺到床上好好想想为什么你会那么自私。我每天长时间辛苦工作，现在需要休息，没时间和你玩小孩子的游戏。”

儿子一声不吭地走回自己的房间，轻轻关上了门。

儿子走后，父亲还在生气。过了一阵儿，他渐渐平静下来。想到自己刚才有些粗暴，他走进孩子的房间，轻声问：“你睡了吗？”

“爸，还没呢。我还醒着。”儿子回答道。

“爸爸今天心情不太好，所以刚才可能对你太凶了，”父亲说，“——这是你要的10美元。”“爸，谢谢你。”儿子欣喜地接过钱，然后又从枕头下拿出一些皱皱的钞票，仔细地数起来。

“你已经有钱了为什么还要？”父亲又开始生气了。

“因为只有那些还不够，不过现在足够了。”儿子回答道。然后他将数好的钱全部放在父亲手里，认真地说：“爸，我现在有20美元了，我可以向你买一个小时的时间吗？明天请早一点回家，我想和你一起吃晚餐。”

A man came home from work late tired and irritated to find his5-year-old son waiting for him at the door.

Daddy, may I ask you a question?

Yes, sure, what is it? Replied the man.

Daddy, how much do you make an hour?

That’s none of you business, why do you ask such a thing? The man said angrily.

I just want to know, please tell me. How much do you make an hour? Pleeaded The little boy.

If you must know, I make 20 dollars an hour.

“Oh”, the little boy replied with head down. Looking up he said: daddy, may I please borrow 10 dollars.

The father was furious. If you only reason you asked that so you can borrow some money to buy a silly toy or some other nonsense, then you march yourself straight to your room and go to bed. Think about why you being so selfish. I work hard every day for such childish behavior.

The little boy quitely went to his room and shut the door.

The man sat down and started to even angrier about the little boy’s questions. How dare you ask such a question only to get some money. After about an hour or so, the man has calmed down and started to think. Maybe there’s something he really needed to buy with that 10 dollars, and he really didn’t ask for money very often.

The man went to the door the little boy’s room and opened the door.

Are you sleep, son? He asked.

No, daddy, I’m awake. Replied the boy.

I have been thinking may be I was too hard on you earlier. Say the man. It’s been a long day, and I took out my aggravation on you, here is the 10 dollars you asked for.

The little boy sat straight up, smiling.

Oh, thank you, daddy. He yelled. Then reaching under his pillow, he pulled out some crumble up bills. The man seeing the boy already had money, started to get angry again.

The little boy slowly counts about his money then look up at his father.

Why do you want more money if you already had some. The father grumbled.

Because I didn’t have enough, but now I do. For little boy reply.

Daddy, I have 20 dollars now, can I borrow an hour your time, please come home early tomorrow. I would like to have dinner with you.

直接转载自 http://sjzflps.jjtang.com/blog/blog-htm-do-read-uid-681206-tid-628328.html

本文链接

经典排序算法 - 图书馆排序(Library Sort)

2011-12-05T02:01:00Z

经典排序算法 - 图书馆排序(Library Sort)

思路简介,大概意思是说,排列图书时,如果在每本书之间留一定的空隙,那么在进行插入时就有可能会少移动一些书,说白了就是在插入排序的基础上,给书与书之间留一定的空隙,这个空隙越大,需要移动的书就越少,这是它的思路,用空间换时间

看红线标的那句话知道,这个空隙留多大,你自己定

图书馆排序的关键是分配空间,分配完空间后直接使用插入排序即可

进行空间分配的过程

这个我实在是找不到相关的资料,没准就是平均分配嘞

进行插入排序的过程

举例待排数组[ 0 0 6 0 0 2 0 0 4 0 0 1 0 0 5 0 0 9 ],直接对它进行插入排序

第一次移动,直接把2放6前边

[ 0 2 6 0 0 0 0 0 4 0 0 1 0 0 5 0 0 9 ]

第二次移动,先把6往后挪,然后把4放在刚才6的位置,移动了一个位置

[ 0 2 4 6 0 0 0 0 0 0 0 1 0 0 5 0 0 9 ]

第三次移动,直接把1放2前边

[ 1 2 4 6 0 0 0 0 0 0 0 0 0 0 5 0 0 9 ]

第四次移动,再把6往后挪一位,把5放在刚才6的位置

[ 1 2 4 5 6 0 0 0 0 0 0 0 0 0 0 0 0 9 ]

第五次移动后,把9放6后边,排序结束

[ 1 2 4 5 6 9 0 0 0 0 0 0 0 0 0 0 0 0 ]

返回主目录 [经典排序算法][集锦]

reference

http://www.cs.sunysb.edu/~bender/newpub/BenderFaMo06-librarysort.pdf

http://zhangyu8374.iteye.com/blog/86317

http://www.cnblogs.com/richselian/archive/2011/09/16/2179152.html

http://algorithm.l918.net/forum.php?mod=viewthread&tid=19

http://www.softpanorama.org/Algorithms/Sorting/insertion_sort.shtml

本文链接

经典排序算法 - 圈排序Cycle Sort

2011-11-28T09:50:00Z

经典排序算法 - Cycle Sort

Cycle sort的思想与计数排序太像了,理解了基数排序再看这个会有很大的帮助,

圈排序与计数排序的区别在于圈排序只给那些需要计数的数字计数,先看完文章吧,看完再回来理解这一句话

所谓的圈的定义,我只能想到用例子来说明,实在不好描述

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第一部分

第一步,我们现在来观察待排数组和排完后的结果,以及待排数组的索引,可以发现

排完序后的6应该出现在索引4的位置上,而它现在却在位置0上,

记住这个位置啊,一直找到某个数应该待在位置0上我们的任务就完成了

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第二步,而待排数组索引4位置上的5应该出现在索引3的位置上

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第三步,同样的,待排数组索引3的位置是1,1应该出现在位置0上,注意注意,找到这么一个数了:1,它应该待在位置0上

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第四步,而索引0处却放着6,而6应该出现在索引4的位置,至此可以发现,回到原点了,问题回到第一步了,

所以这里并不存在所谓的第四步,前三步就已经转完一圈了

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

这就是所谓的一圈!真不好描述,不知道您看明白没...汗.

前三步转完一圈,得到的数据分别是[ 6 5 1 ]

第二部分

第一步,圈排序并不是一圈排序,而一圈或多圈排序,所以,还得继续找,这一步从第二个数字2处开始转圈

待排中的2位于索引1处,排序完毕仍然处于位置1位置,所以这一圈完毕,得到圈数据[ 2 ]

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第三部分

第一步,同上,4也出现了它应该待的位置,结束这一圈,得到第三个圈:[ 4 ]

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第四部分

第一步,由于1和5出现在第一圈里,这是什么意思呢,说明这两个数已经有自己的圈子了,不用再找了,

即是找,最后还是得到第一圈的数据[ 6 5 1 ],所以,1和5跳过,这一部分实际应该找的是9,来看看9的圈子

9应该出现在索引5的位置,实际上它就在索引5的位置,与第二部分的第一步的情况一样,所以这一圈的数据也出来了:[ 9 ]

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

一共找到四个圈子,分别是

[ 6 5 1 ] , [ 2 ] ,[ 4 ] , [ 9 ]

如果一个圈只有一个数字,那么它是不需要转圈的,即不需要排序,那么只有第一个圈排序即可

你可能要问了,前边的那些圈子都是基于已知排序结果才能得到,我都已知结果还排个毛啊

以上内容都是为了说明什么是圈,知道什么是圈后才能很好的理解圈排序

现在来分解排序的细节

第一步,将6取出来,计算出有4个数字比6小,将6放入索引4,同时原索引4位置的数字5出列

排序之前[ 0 2 4 1 5 9 ] 6

排序之后[ 0 2 4 1 6 9 ] 5

索引位置[ 0 1 2 3 4 5 ]

第二步,当前数字5,计算出有3个数字比5小,将5放入索引3,同时原索引3位置的数字

排序之前[ 0 2 4 1 6 9 ] 5

排序之后[ 0 2 4 5 6 9 ] 1

索引位置[ 0 1 2 3 4 5 ]

第三步,当前数字1,计算出有0个数字比1小,将1放入索引0,索引0处为空,这圈完毕

排序之前[ 0 2 4 5 6 9 ] 1

排序之后[ 1 2 4 5 6 9 ]

索引位置[ 0 1 2 3 4 5 ]

第一个圈[ 6 5 1 ]完毕

第四步,取出下一个数字2,计算出有1个数字比2小,将2放入索引1处,发现它本来就在索引1处

第五步,取出下一个数字4,计算出有2个数字比4小,将4放入索引2处,发现它本来就在索引2处

第六步,取出下一个数字5,5在第一个圈内,不必排序

第七步,取出下一个数字6,6在第一个圈内,不必排序

第八步,取出下一个数字9,计算出有5个数字比9小,将9放入索引5处,发现它本来就在索引5处

全部排序完毕

返回主目录 [经典排序算法][集锦]

本文链接

经典排序算法 - Strand Sort

2011-11-24T05:32:00Z

经典排序算法 - Strand Sort

Strand sort是思路是这样的,它首先需要一个空的数组用来存放最终的输出结果,给它取个名字叫"有序数组"

然后每次遍历待排数组,得到一个"子有序数组",然后将"子有序数组"与"有序数组"合并排序

重复上述操作直到待排数组为空结束

看例子吧

待排数组[ 6 2 4 1 5 9 ]

第一趟遍历得到"子有序数组"[ 6 9],并将其归并排序到有序数组里

待排数组[ 2 4 1 5]

有序数组[ 6 9 ]

第二趟遍历再次得到"子有序数组"[2 4 5],将其归并排序到有序数组里

待排数组[ 1 ]

有序数组[ 2 4 5 6 9 ]

第三趟遍历再次得到"子有序数组"[ 1 ],将其归并排序到有序数组里

待排数组[ ... ]

有序数组[ 1 2 4 5 6 9 ]

待排数组为空,排序结束

返回主目录 [经典排序算法][集锦]

本文链接

经典排序算法 - Flash Sort

2011-11-24T05:14:00Z

经典排序算法 - Flash Sort

FlashSort依然类似桶排,主要改进了对要使用的桶的预测,或者说,减少了无用桶的数量从而节省了空间,例如

待排数字[ 6 2 4 1 5 9 100 ]桶排需要100个桶,而flash sort则由于可以预测桶则只需要7个桶

即待排数组长度个桶,如何预测将要使用的桶有这么一个公式

该排序有前置条件,需要知道待排数组的区间和待排数组的长度,

例如已知待排数组[ 6 2 4 1 5 9 ]的长度为6,最大值9,最小值1,这三个是已知条件,如果无法知道这三个则无法应用该排序

预测的思想

如果有这样一个待排数组,其最大值是100,最小值是1,数组长度为100,那么50在排完序后极有可能出现在正中间,flash sort就是基于这个思路

预测桶号细节

待排数组[ 6 2 4 1 5 9 ]

具体看6可能出现的桶号

Ai - Amin 是 6 - 1 = 5

Amax - Amin 是9 - 1 = 8

m - 1 是数组长度6 - 1 = 5

则(m - 1) * (Ai - Amin) / (Amax - Amin) = 5 * 5 / 8 =25/8 = 3.125

最后加上1等于 4.125

6预测的桶号为4.125

2预测的桶号为1.625

4预测的桶号为2.875

1预测的桶号为1

5预测的桶号为3.5

9预测的桶号为5

去掉小数位后,每个数字都拥有自己预测的桶号,对应如下所示

待排数组[ 6 2 4 1 5 9 ]

预测桶号[ 4 1 2 1 3 5 ]

入桶规则

1号桶 2,1

2号桶 4

3号桶 5

4号桶 6

5号桶 9

1号桶内两个数字使用任意排序算法使之有序,其它桶如果此种情况同样需要在桶内排序,使用什么排序算法不重要,重要的是排成从小到大即可

最后顺序从桶里取出来即可

[1 2 4 5 6 9]

参考http://en.wikipedia.org/wiki/Flashsort

返回主目录 [经典排序算法][集锦]

本文链接

经典排序算法 - Proxmap Sort

2011-11-24T02:02:00Z

经典排序算法 - Proxmap Sort

这个排序是桶排序和基数排序的改进,理解了前两者,这个排序很容易理解

先回忆下桶排序是怎么回事,它与桶的区别在于入桶规则,桶排序里是1入1号桶,2入2号桶

这个排序把数字分区了,然后给出一个所谓的键,例如它规定0-9都入0号桶

10-19都入1号桶,这样桶覆盖的范围将增大10倍,这在某种情况下是很有用的

有了桶排的基础后,再看下边两张图就什么都明白了,不再分解过程了

图1

图2

返回主目录 [经典排序算法][集锦]

本文链接

[经典排序算法][集锦]

2011-11-23T06:46:00Z

经典排序算法

经典排序算法,以下文章参考了大量网上的资料,大部分都给出了出处

这一系列重点在理解,所以例子什么的都是最简单的情况,难免失误之处,多指教

大多数排序算法都给出了每一步的状态,以方便初学者更容易理解,通俗易懂,部分难以理解的排序算法则给出了大量的图示,也算是一个特色吧

经典排序算法 - 快速排序Quick sort

经典排序算法 - 桶排序Bucket sort

经典排序算法 - 插入排序Insertion sort

经典排序算法 - 基数排序Radix sort

经典排序算法 - 鸽巢排序Pigeonhole sort

经典排序算法 - 归并排序Merge sort

经典排序算法 - 冒泡排序Bubble sort

经典排序算法 - 选择排序Selection sort

经典排序算法 - 鸡尾酒排序Cocktail sort

经典排序算法 - 希尔排序Shell sort

经典排序算法 - 堆排序Heap sort序

经典排序算法 - 地精排序Gnome Sort

经典排序算法 - 奇偶排序Odd-even sort

经典排序算法 - 梳排序Comb sort

经典排序算法 - 耐心排序Patience Sorting

经典排序算法 - 珠排序Bead Sort

经典排序算法 - 计数排序Counting sort

新增

经典排序算法 - Proxmap Sort

经典排序算法 - Flash Sort

经典排序算法 - Strand Sort

经典排序算法 - 圈排序Cycle Sort

经典排序算法 - 图书馆排序(Library Sort)

[持续更新]

出个小题目

已知数组长度为100,且基本有序,里面有仅有两个数字位置不对,但具体是那两个数字不知道,数字不重复

例如[1 99 2 3 4 5 6 7 8 9 10 11 …… 88 89 90 91 92 93 94 95 96 97 98 2 100 ]

要求从小到大排序

本文链接

经典排序算法 - 计数排序Counting sort

2011-11-23T06:40:00Z

经典排序算法 - 计数排序Counting sort

注意与基数排序区分,这是两个不同的排序

计数排序的过程类似小学选班干部的过程,如某某人10票,作者9票,那某某人是班长,作者是副班长

大体分两部分,第一部分是拉选票和投票,第二部分是根据你的票数入桶

看下具体的过程,一共需要三个数组,分别是待排数组,票箱数组,和桶数组

var unsorted = new int[] { 6, 2, 4, 1, 5, 9 }; //待排数组

var ballot = new int[unsorted.Length]; //票箱数组

var bucket = new int[unsorted.Length]; //桶数组

最后再看桶数组,先看待排数组和票箱数组

初始状态,迭代变量i = 0时,待排数组[i] = 6,票箱数组[i] = 0,这样通过迭代变量建立了数字与其桶号(即票数)的联系

待排数组[ 6 2 4 1 5 9 ] i = 0时,可以从待排数组中取出6

票箱数组[ 0 0 0 0 0 0 ] 同时可以从票箱数组里取出6的票数0,即桶号

拉选票的过程

首先6出列开始拉选票,6的票箱是0号,6对其它所有数字说,谁比我小或与我相等,就给我投票,不然揍你

于是,2 4 1 5 分别给6投票,放入0号票箱,6得四票

待排数组[ 6 2 4 1 5 9 ]

票箱数组[ 4 0 0 0 0 0 ]

接下来2开始拉选票,对其它人说,谁比我小,谁投我票,不然弄你!于是1投了一票,其他人比2大不搭理,心想你可真二

于是2从1那得到一票

待排数组[ 6 2 4 1 5 9 ]

票箱数组[ 4 1 0 0 0 0 ]

再然后是,

4得到2和1的投票,共计两票

1得到0票,没人投他

5得到2,4,1投的三张票

9是最大,得到所有人(自己除外)的投票,共计5票(数组长度-1票)

投票完毕时的状态是这样

待排数组[ 6 2 4 1 5 9 ]

票箱数组[ 4 1 2 0 3 5 ]

入桶的过程

投票过程结束,每人都拥有自己的票数,桶数组说,看好你自己的票数,进入与你票数相等的桶,GO

6共计5票,进入5号桶

2得1票,进入1号桶,有几票就进几号桶

4两票,进2号桶,5三票进3号桶,9有5票,进5号桶

待排数组[ 6 2 4 1 5 9 ]

票箱数组[ 4 1 2 0 3 5 ]

-----------------------

入桶前 [ 0 1 2 3 4 5 ] //里边的数字表示桶编号

入桶后 [ 1 2 4 5 6 9 ] //1有0票,进的0号桶

排序完毕,顺序输出即可[ 1 2 4 5 6 9]

可以看到,数字越大票数越多,9得到除自己外的所有人的票,5票,票数最多所以9最大,

每个人最多拥有[数组长度减去自己]张票

1票数最少,所以1是最小的数,

计数排序同时兼有桶排的高效和快排的霸道,

完成代码如下

var unsorted = new int[] { 6, 2, 4, 1, 5, 9 }; //待排数组

var ballot = new int[unsorted.Length]; //票箱数组

var bucket = new int[unsorted.Length]; //桶数组

for (int i = 0; i < bucket.Length; i++)

{

//unsorted[i] = 6

//ballot[i]是6的票箱,里边有4张票

//bucket[ballot[i]] = unsorted[i];

//bucket[4张票] = 6;

bucket[ballot[i]] = unsorted[i];

}

for (int i = 0; i < bucket.Length; i++)

{

Console.WriteLine(bucket[i]);

}

返回主目录 [经典排序算法][集锦]

本文链接