词语排序范文

词语排序范文（精选6篇）

词语排序 第1篇

词语排序

时间顺序，事情发展顺序，范围由大到小，由小到大。1.小学语文书

书

语文书

教科书 2.男人

男孩子

二年级男生

人 3.全部

没有

少数

一半

多数 5.端午节

重阳节 中秋节 除夕 春节

7、冲向敌阵 调兵谴将 全歼顽敌 英勇出击

8、头部 身体 上身 牙齿 嘴；

9、出租车 轿车 汽车 车 交通工具

10、播种 发芽 含苞 开花 结果

11、蚕卵 蛾 蚕丝 蛹 幼蚕

12、准备活动 领奖品 冲刺 起跑；

13、审题 列提纲

草稿

修改 确定中心

誊写

14、春节 元宵 端午节 中秋节 重阳节

除夕

15、桃花 荷花 菊花 梅花

16、婴儿 少儿

儿童 少年 青年 中年 老年

17、爷爷 伯伯 爸爸 叔叔 哥哥

18．审题

立意

修改

写作

选材 19．双色圆珠笔 圆珠笔 文具 笔 20．苹果树 果树 植物 树

21、昆虫 动物 蚊子 生物

22、小钢刀 小刀 刀 张飞小钢刀

23、字典 工具书 《新华字典》 中文字典

26、中国 昆山实验小学 江苏省 昆山市 六（１）班

29、一季

一年

一月

一周一旬 30、置地

建造

打基

封顶

验收

31、出生

死亡

发育

衰老

成人

32、黎明

黄昏

清晨

拂晓

33、句子

文字

词语

段落

篇章

34、中学生

学生

女中学生

优秀女中学生

35．公共汽车 车 交通工具 汽车

43、国庆 儿童 劳动 建军 植树

44、东亚 福州市 中国 亚洲 福建省

45、林则徐 李白 朱元璋 陆游 秦始皇

16、一本正经 怒发冲冠 喜笑颜开 怒形于色

47、根 茎 枝 叶

48、审题 选材 列提纲 成文

49、桃花

荷花

迎春花

腊梅花

桂花 50、53、苍蝇 猴子 大象 鸽子

54、宇宙 太阳系 银河系 月亮 地球

55、过午 黄昏 日中 黎明 夜晚

56、寒冷 炎热 凉爽 酷热 温暖

57、冷水 冰 开水 热水 水蒸汽

60、儿童节 元旦 国庆节 劳动节 妇女节 教师节 63、早晨、夜晚、中午、黄昏

64、洗菜、炒菜、择莱、买菜

65、收获、播种、除草、耕地

66、做题、检查、思考、审题

69、父亲

儿子

曾祖父

孙子

祖父

70、一道红霞

晨曦初露

万道霞光

红日薄发 71、逗号

句号

分号

顿号

72、喜爱

喜欢

热爱

酷爱

73、家用电器

电器

21寸彩电

彩电

74、小肠吸收

食道

嘴

大肠

胃

76、.植物

苹果树

果树

树

红富士苹果树

84、上学

放学

上课

下课

回家

词语排序 第2篇

1.中秋节、端午节、重阳节元宵节、除夕 2.国庆节、教师节、劳动节、儿童节、妇女节 3.莺歌燕舞、冰天雪地、桂子飘香、赤日炎炎 答案：

（1）、元宵节、端午节、中秋节、重阳节、除夕（2）、妇女节、劳动节、儿童节、教师节、国庆节（3）、莺歌燕舞、赤日炎炎、桂子飘香、冰天雪地

4、电视机、电器、国产彩色电视机、家用电器、彩色电视机 答案：（4）、电器、家用电器、电视机、彩色电视机、国产彩色电视机

5、大发雷霆、一本正经、怒发冲冠、喜笑颜开、怒形于色

6、国庆节、儿童节、劳动节、建军节、植树节

7、东亚、福州、中国、亚洲、福建 答案：

（5）、喜笑颜开、一本正经、怒形于色、怒发冲冠、大发雷霆（6）、植树节、劳动节、儿童节、建军节、国庆节（7）、福州、福建、中国、东亚、东亚

8、国庆节、儿童节、劳动节、建军节、植树节

9、林则徐、李白、朱元璋、陆游、泰始皇

10、大发雷霆、一本正经、怒发冲冠、喜笑颜开、怒形于色

答案:(8)、植树节、劳动节、儿童节、建军节、国庆节（发生时间先后）

(9)、泰始皇、李白、陆游、朱元璋、林则徐（所在朝代的时间先后）

（10）、喜笑颜开、一本正经、怒形于色、大发雷霆、怒发冲冠（发展顺序）

11、晌午、黎明、午夜、黄昏

答案：

（11）从早到晚：黎明、晌午、黄昏、午夜 从夜到明：黄昏、午夜、黎明、晌午

12、中秋节、端午节、重阳节、除夕、元宵节

13、广东、亚洲、广州、中国、东亚

14、微波荡漾、水平如镜、波涛汹涌、波澜壮阔

15、桃花、梅花、荷花、菊花 答案：

（12）、元宵节、端午节、中秋节、重阳节、除夕（按先后顺序排列）（13）、亚洲、东亚、中国、广东、广州（从大到小）（14）、水平如镜、微波荡漾、波涛汹涌、波澜壮阔（程度由轻到重）（15）、桃花、荷花、菊花、梅花（按春夏秋冬排列）

16、手机、彩电、空调、冰箱、洗衣机、茶几、衣柜、钢笔、、毛笔、文具盒

答案：

（16）冰箱、彩电、茶几、钢笔、空调、毛笔、手机、文具盒、洗衣机、衣柜

17、小学语文课本、书籍、语文书、书。答案：

（17）书籍、书、语文书、小学语文课本

18、桃花、荷花、迎春花、蜡梅花、桂花

19、鲸、动物、齿鲸、哺乳动物

20、龚自珍、曹植、于谦（古代的）、王冕、杜甫、陆游 答案：

（18）、迎春花、桃花、荷花、桂花、腊梅（按开放时间）（19）、动物、哺乳动物、鲸、齿鲸（按类别从大类到具体）

（20）、曹植（三国）、杜甫（唐）、陆游、王冕（元）于谦（明）（按人的朝代）

21、包制、擀皮、和面、煮熟

22、传送、编码、译码、接受

23、荷花、桃花、菊花、水仙花

24、纺纱、织布、制衣、种棉花 答案：（21）、和面、擀皮、包制、煮熟（按事情发展先后顺序）（22）、编码、传送、接受、译码（按事情发展先后顺序）

（23）、桃花、荷花、菊花、水仙花（按花的季节先后顺序）（24）、种棉花、纺纱、织布、制衣（按生产的步骤顺序）

25、苹果树、植物、果树、树 答案：

（25）植物、树、果树、苹果树

26、国庆节、劳动节、教师节、妇女节、儿童节（由日历的先后顺序来排列）

27、端午、除夕、元宵、中秋（按节日的先后顺序来排列）

28、土家族民居、吊脚楼、建筑、民居（按从详到略的先后顺序来排列）答案：

（26）、妇女节、劳动节、儿童节、国庆节（27）、土家族民居、吊脚楼、民居、建筑（28）、除夕、元宵、端午、中秋

29、凉爽、寒冷、酷热、炎热、温暖

30、元宵节、除夕、重阳节、端午节、春节 31.植物、苹果树、果树、树、红富士苹果树 答案：

（29）、凉爽、寒冷、温暖、炎热、酷热

（30）、春节、元宵节、端午节、重阳节、除夕（31）、红富士苹果树、苹果树、果树、树、植物 或者：

（29）、酷热、炎热、温暖、寒冷、凉爽

（30）、春节、元宵节、端午节、重阳节、除夕（31）、植物、树、果树、苹果树、红富士苹果树

32、小学语文书、书、语文书、书籍

33、男人、男孩子、小学二年级男生、人

34、全部、没有、少数、一半、多数

35、录取、报名、考试、注册、查分

36、端午节、重阳节、中秋节、除夕、春节（写出这些节日的日期）答案：

（32）、书、书籍、语文书、小学语文书【包含关系】（33）、人、男人、男孩子、小学二年级男生【包含关系】（34）、没有、少数、一半、多数、全部【递进关系】（35）、注册、报名、考试、查分、录取【时间顺序】（36）、除夕：农历十二月三十 春节：农历正月初一 端午节：农历五月初五 中秋节：农历八月十五 重阳节：农历九月初九 【时间顺序】

37、清明、除夕、元宵、中秋、重阳

38、土家族民居、建筑、吊脚楼、民居

39、鲸、动物、哺乳动物 答案：

（37）.元宵、清明、重阳、中秋、除夕（时间顺序）（38）、建筑、民居、土家族民居、吊脚楼（包含）（39）.动物、哺乳动物、鲸（包含）

40、小肠、食道、嘴、大肠、胃

41、花布、纱、布、棉花、衣服

42、宇宙、太阳系、银河系、月亮、地球 答案：

（40）、嘴、食道、胃、小肠、大肠（41）、棉花、纱、布、花布、衣服

（42）、第一种:从大到小 宇宙、银河系、太阳系、地球、月亮 第二种：从小到大 月亮、地球、太阳系、银河系、宇宙

43、一道红霞、晨曦初露、万道霞光、红日薄发

44、冲向敌阵、调兵遣将、全歼顽敌、英勇出击

45、而立、花甲、耄耋、弱冠、古稀、知命、不惑、豆蔻 答案：

（43）、晨曦初露、一道红霞、红日薄光、万道霞光（44）、调兵遣将、英勇出击、冲向敌阵、全歼顽敌

（豆蔻：13弱冠：20而立：30不惑：40知命：50花甲：60古稀：70 耄耋：80-90期颐：100

46、纸、甲壳、计算机、竹简、纸 答案：按人类记事工具的发展排列

（46）甲壳、绳子、竹简、纸、计算机

47、左宗棠、范仲淹、诸葛亮、郑成功、黄道婆

48、语文课本、书籍、小学语文课本、教科书

49、打开网页、浏览内容、开机、关机、关闭网页 50、元宵节、重阳节、中秋节、端午节、清明节

答案：（47）、诸葛亮、范仲淹、黄道婆、郑成功、左宗棠（时间）（48）、书籍、教科书、语文课本、小学语文课本（范围）

（49）、开机、打开网页、浏览内容、关闭网页、关机（操作顺序）（50）、元宵节、清明节、端午节、中秋节、重阳节（时间）

51、①憎恨②埋怨③仇视④不满⑤怨恨 排列顺序：

理由：

52、①优秀②尚可③优良④较差⑤良好 排列顺序：

理由：

53、①酷爱②喜爱③喜欢④热爱⑤满意 排列顺序：

理由：

答案：（51）不满、埋怨、仇视、怨恨、憎恨（程度低到高）（52）较差、尚可、良好、优良、优秀（程度高到低）（53）酷爱、热爱、喜爱、喜欢、满意

54、镇、省、县、乡、市、村

55、小学语文课本、书、教科书、语文书

56、面包、主食、牛奶面包、食物

57、树、苹果树、植物、果树、生物 答案：

（54）、村、乡、镇、县、市、省

（55）、小学语文课本、语文书、教科书、书（56）、牛奶面包、面包、主食、食物（57）、苹果树、果树、树、植物、生物

58、海洋、山泉、江河、小溪

59、银河系、太阳系、月亮、宇宙、地球

60、劳动节、建军节、儿童节、教师节、党的生日 答案：

（58）、海洋、江河、小溪、山泉（按大小）。

（59）、宇宙、银河系、太阳系、地球、月亮（按大小）。

（60）、劳动节、儿童节、党的生日、建军节教师节（时间顺序）。61、①高速信息公路②电子管计算机③集成电路计算机④半导体计算机⑤大规模集合电路计算机 答案：

（61）排列顺序：4 5 3 1 2 排列理由：按照科技发展顺序排列

62、①目录卡片②阅览室③目录柜④图书馆⑤目录抽屉 答案：

（62）排列顺序：4 2 3 5 1 排列理由：从大到小

63、①中秋②元宵③重阳④端午⑤清明 答案：

（63）排列顺序：2 5 4 1 3 排列理由： 从先到后

64、争奇斗艳、枯枝败叶、落英缤纷、含苞欲放 答案：

（64）含苞待放、争奇斗艳、落英缤纷、枯枝败叶、（按花的时间顺序来排序 从花开到花败）。

65、山海关、长城、中国、世界、亚洲、答案：

（65）山海关、长城、中国、亚洲、世界

（山海关在长城上，长城属于中国，中国在亚洲，亚洲属于世界）

66、森林资源、自然资源、生物资源白桦树 67、拂晓、日中、过午、午夜、傍晚

妇女节、元旦、教师节、儿童节、建军节 69、除夕、元宵、中秋、重阳、清明、端午 答案：

（66）、从小至大：白桦树、森林资源、生物资源、自然资源（67）、一天内从早至晚：拂晓、日中、过午、傍晚、午夜（68）、先后顺序：元旦、妇女节、儿童节、建军节、教师节（69）、先后顺序：元宵、清明、端午、中秋、重阳、除夕

70、桃花、荷花、迎春花、腊梅花、桂花。71、没有、多数、少数、一半、全部。72、词、字、段、句、篇。73、元、唐、清、宋、明 答案：

（70）、迎春花、桃花、荷花、桂花、腊梅花（按照时间季节排序）（71）、没有、少数、一半、多数、全部（按照范围大小排序）（72）、字、词、句、段、篇（按照篇幅长短排序）（73）、唐、宋、元、明、清（按照时间先后排序）

74、水彩笔、足球、瓜子、钢笔、牛奶、脸盆、鞋子、篮球、手套、杯子、羽毛球、圆珠笔、话梅、象棋、花生、袜子、衬衫、铅笔、牙膏、筷子。答案：

例如：

1、水彩笔、钢笔、圆珠笔、铅笔、（文具）2、足球、篮球、羽毛球、象棋(课外运动)

3、瓜子、牛奶、话梅、花生(食品)

4、鞋子、手套、袜子、衬衫(衣着)

5、杯子、牙膏、筷子、脸盆(洗涤用品)

75、父亲、儿子、曾祖父、孙子、祖父 答案：

（75）曾祖父、祖父、父亲、儿子、孙子（按辈份的大小顺序）。

76．公共汽车、车、交通工具、汽车 77、双色圆珠笔、圆珠笔、文具、笔 78、苹果树、果树、植物、树 79、昆虫、动物、蚊子、生物

80、小钢刀、小刀、刀、旧小钢刀 81．字典、工具书、《新华字典》、中文字典 82、男人、男孩子、小学二年级男生、人 83、小学语文课本、书、语文书、书籍 答案：

（76）、交通工具、车、汽车、公共汽车；（77）、文具、笔、圆珠笔、双色圆珠笔；（78）、植物、树、果树、苹果树 ；（79）、生物、动物、昆虫、蚊子；

（80）、刀、小刀、小钢刀、旧小钢刀；

词语排序 第3篇

排序(Sorting),就是将杂乱无章的数据,通过一定的方法按特定顺序排列的过程。由于排序是计算机科学中一项复杂而重要的技术,无论在系统软件还是在应用软件中使用频率都很高,有资料表明,在一些商用计算机上,用在排序上的CPU 时间达到20%～60%。在日常生活中也经常需要对所收集到的各种数据信息进行处理,这些数据处理中经常用到的核心运算就是排序。例如图书管理员将书籍按照编号排序放置在书架上,方便读者查找; 计算机的资源管理器可以选择按名称、大小、类型等来排列图标。排序已被广泛应用在几乎所有的领域,具有非常重要的作用。

1算法描述与分析

对于一组无序数列而言,必有其最大和最小值,端点排序(假设按升序排列)是首先把序列中的最小值与最大值找出来,把最小值与数列第一个值交换,把最大值与数列最后一个值交换。然后把两端之间数列中的最小值与最大值找出,并分别与本次所要排序数列的第一个和最后一个数据交换。依此类推,直到数列的中间。

假设原有无序数列存放有N个数据,如图1所示。则第1次把此N个数的最小值MIN(N)和最大值MAX(N)找出,把MIN(N)与第1个数交换,把MAX(N)与第N个数交换,如图2所示。然后把剩下中间N-2个数的最小值MIN(N-2)和最大值MAX(N-2)找出,并分别与原数列的第2个数和第N-1个数相交换,之后以此类推。若N为偶数,则要进行N/2次,若N为奇数则要进行(N-1)/2次。

端点排序算法:

设待排序数据存储于数组a[N]。

2实验结果

表1是对冒泡排序、端点排序、选择排序、插入排序用C语言在Core 2.2G上做的一个比较。表中是用冒泡排序、端点排序、选择排序处理100个、1 000个、10 000个、100 000个随机数据(由RAND函数产生)所用的时间,每一个时间值是测试20次的平均值,单位为μs。

3结语

实验表明,端点排队序算法实现的端点排序算法速度明显优于冒泡排序算法,在数据个数较多的情况下优于选择排序。

摘要：提出了一种新的排序算法:端点排序算法。其方法为:依次找出数据总数为N的数列最小和最大值,把二者放在本次所排数列的两端,再把剩余两端之间的数据总数为N-2的数列的最小值和最大值找出,放在此数列的两端,依此类推,直至数列中间,实现整个数组的排序。实验表明,该算法具有与冒泡排序更快的性能。在数据个数较多的情况下优于选择排序。

关键词：排序算法,端点排序算法,冒泡排序算法,选择排序算法

参考文献

[1]严蔚敏,吴伟民.数据结构(C语言版)[M].北京:清华大学出版社,2002.

[2]CORMEN T H,LEISERSON C E,RIVEST R L,et al.算法导论[M].2版.北京:高等教育出版社,2002.

[3]王晓东.计算机算法设计与分析[M].北京:电子工业出版社,2007.

[4]周建钦.超快速排序[J].计算机工程与应用,2006,42(29):41-42.

[5]王永刚.排序算法综述[J].电脑知识与技术,2006,29(7):1-6.

[6]淦艳,杨有.五种排序算法的性能分析[J].重庆文理学院学报,2010,29(3):45-50.

[7]陶冶.开发自己的剖分软件以辅助性能测试[J].信息技术与标准化,2007(7):42-44.

[8]兰超.冒泡排序算法的优化[J].兵工自动化,2006(12):50-52.

[9]李宝艳,马英红.排序算法研究[J].电脑知识与技术,2007(8):424-456.

准确排序 语义连贯 第4篇

高考语文卷常以排序题形式来考查语言的“连贯”，下面就以试题为例，看看如何解答排序题。

一、理顺关系，明确句间条理

一个语段内，句与句之间常常会存在时间顺序、空间顺序或者逻辑顺序，这种顺序不可随意更改。所以，读懂每句话表达的意思，理顺句子间的关系是正确排序的基础。

例1 语意连贯的语段，排序最恰当的一项是______

①使用语言，不仅要用得对，在语法上不出毛病，而且要力求用得好，要有艺术性，有感染力，这就要讲究运用语言的艺术，也就是要讲究一点修辞。

②有意用不符合语法常规的办法取得某种修辞效果是许可的，然而这只是偶一为之，并且要有些特定的条件。

③如果语言不符合语法，说都说不通，就没有什么好的修辞可言。

④语言是用来传递信息、交流思想、表达情感的。

⑤好的修辞，必然是符合语法规律的。

A. ④①⑤③②B. ④③⑤①②

C. ⑤②①④③D. ⑤③④①②

解析： 这五个句子的主要意思分别是：①使用语言要讲究修辞，②特定条件下的修辞，③不好的修辞，④语言的作用，⑤好的修辞。由此可见，这个语段的结构应该是“总分”形式，“总”是指“运用语言要讲究修辞”，“分”即分别论述不同种类的修辞。按照这样的逻辑关系以及上下句的衔接词语，可以判断五个句子的正确顺序为④①⑤③②，答案选A。

二、统揽全局，抓住中心论点

遇到议论性的语段，先抓住中心论点，再分析其他句子是如何围绕论点进行论述的，会使排序变得容易很多。

例2 把下列带序号的句子组合成语意连贯的一段话并填入横线处。（只填序号）

理学家为什么崇古抑律·______古体与律体之辨跟诗歌史联系起来，就是古体的典范——汉魏晋诗与律体的典范——唐诗之辨。

①那么，为什么讲求声律、对偶等形式技巧就是品格低呢·

②他们认为，诗歌的审美方面、形式技巧方面对于人的道德修养没有正面的价值。

③以这种价值观去看诗歌的题材样式，古体诗就高于律诗。

④既然诗歌的审美方面没有价值，本来可以不讲，但是如果要进入到诗歌领域去谈诗的话，那么，在形式方面人为的工巧因素越多，其价值就越低。

⑤抛开诗歌的内容不论，单从形式上看，近体诗要讲求声律、对偶等，这些讲求在理学家看来，是其在品格上低于古体诗的重要原因。

解析：语段开头抛出“理学家为什么崇古抑律”的问题，接下来的句子自然与之有因果联系，我们不难找到⑤，这就构成了语段的中心论点——“理学家崇古抑律，因为从形式上看，古体诗的品格高于律诗”。既然理学家有这样的观点，自然要论证“为什么讲求声律、对偶等形式使近体诗的品格低”，所以⑤后紧跟过渡句①，然后再回答①提出的问题。句子②从“对道德修养的价值”角度出发，说明诗歌的形式技巧价值低，句子④具体分析句子②的观点，句子③得出结论。可见，正确的排序是⑤①②④③。

三、读懂句意，分析陈述角度

在描述某一事物时，语段内前后句子的陈述角度应该一致，首尾相贯。所以，在读懂句意的基础上，可以分析句子的陈述角度，以此为依据进行排序。

例3 依次填入下面一段文字横线处的语句，衔接最恰当的一组是

今天的日子很短，正在自己的脚下悄悄地流逝。______ 。

______，______ 。______ ，______ ，______，经营好每一个今天就等于经营好昨天和明天。

①今天的事应该今天完成，不能推到明天

②脚踏实地，全身心地经营好今天，才会有一个个实在的昨天

③因此，面对今天，我们不要太多地怀念过去

④接力棒交得好，才能走向辉煌的明天

⑤如果总是站在今天望明天，结果明天也会悄悄地溜走

⑥今天是昨天和明天的接力处

A. ⑤①⑥②④③ B. ⑤⑥①④③②

C. ⑥④③②①⑤ D. ⑥②③①④⑤

解析：这是一个议论性语段。句子②⑥讲“今天”与“昨天”及“明天”的关系，句子①③④⑤讲如何处理好“今天”与“昨天”“明天”的关系。语段以“今天”为话题开头，能与之衔接的只能是以“今天”为主语的①或⑥，选项中没有以①开头的，所以可以把答案锁定在C、D之中。我们只需分析句子④②哪一个接在句子⑥后更合适即可。句子④以“接力棒”开头，显然承接了句子⑥最后提出的“接力处”这一概念，所以，应该选C。

四、分析语言，注意整体协调

整体协调指的是句式结构和音韵节奏的协调。句式上，应注意上下文之间整句与散句、长句与短句、主动句与被动句、肯定句与否定句等的对应；音韵上，要关注节奏与押韵。

例4 填入下列句子空白处最恰当的一项是

埋伏和照应需要惨淡经营。埋伏处要能轻轻一笔，若不经意，______。要使读者看不出斧凿痕迹，只觉得

______ ，如一丛花，如一棵菜。虽由人力，却似天成。如果看出来这里是埋伏，那里是照应，______ 。

①照应处要顺理成章，水到渠成

②照应处要水到渠成，顺理成章

③清清爽爽，简简单单

④自自然然，完完整整

⑤便成死症

⑥便太浅显

A. ①④⑤ B. ①③⑥

C. ②③⑤ D. ②④⑥

解析：本题从音韵和谐的角度分析，很容易选择A，因为不难看出句末“成”“整”“症”等字押韵。再结合文段验证一下，首先，从逻辑看，“水到渠成”是“顺理成章”的结果，句子①②中应选择①。其次，语段中把“看不出斧凿痕迹”给人的感觉比做“一丛花”“一棵菜”，意在“天然、自然”，因此，不难选择句子④“自自然然，完完整整”。所以A选项是正确的。

词语排序 第5篇

这篇文章主要介绍了Go语言实现冒泡排序、选择排序、快速排序及插入排序的方法,以实例形式详细分析了几种常见的排序技巧与实现方法,非常具有实用价值,需要的朋友可以参考下

本文实例讲述了Go语言实现冒泡排序、选择排序、快速排序及插入排序的方法，分享给大家供大家参考。具体分析如下：

算法是程序的灵魂，而排序算法则是一种最基本的算法。排序算法有许多种，这里介绍4中排序算法：冒泡排序，选择排序，快速排序和插入排序，以从小到大为例。

一、冒泡排序

冒泡排序的原理是，对给定的数组进行多次遍历，每次均比较相邻的两个数，如果前一个比后一个大，则交换这两个数。经过第一次遍历之后，最大的数就在最右侧了；第二次遍历之后，第二大的数就在右数第二个位置了；以此类推。

代码如下:

//冒泡排序（排序10000个随机整数，用时约145ms）

func bubbleSort(nums []int) {

for i := 0; i < len(nums); i++ {

for j := 1; j < len(nums)-i; j++ {

if nums[j] < nums[j-1] {

//交换

nums[j], nums[j-1] = nums[j-1], nums[j]

}

}

}

}

二、选择排序

选择排序的原理是，对给定的数组进行多次遍历，每次均找出最大的一个值的索引。

代码如下:

//选择排序（排序10000个随机整数，用时约45ms）

func selectSort(nums []int) {

length := len(nums)

for i := 0; i < length; i++ {

maxIndex := 0

//寻找最大的一个数，保存索引值

for j := 1; j < length-i; j++ {

if nums[j] > nums[maxIndex] {

maxIndex = j

}

}

nums[length-i-1], nums[maxIndex] = nums[maxIndex], nums[length-i-1]

}

}

三、快速排序

快速排序的原理是，首先找到一个数pivot把数组‘平均‘分成两组，使其中一组的所有数字均大于另一组中的数字，此时pivot在数组中的位置就是它正确的位置。然后，对这两组数组再次进行这种操作。

代码如下:

//快速排序（排序10000个随机整数，用时约0.9ms）

func quickSort(nums []int) {

recursionSort(nums, 0, len(nums)-1)

}

func recursionSort(nums []int, left int, right int) {

if left < right {

pivot := partition(nums, left, right)

recursionSort(nums, left, pivot-1)

recursionSort(nums, pivot+1, right)

}

}

func partition(nums []int, left int, right int) int {

for left < right {

for left < right nums[left] <= nums[right] {

right--

}

if left < right {

nums[left], nums[right] = nums[right], nums[left]

left++

}

for left < right nums[left] <= nums[right] {

left++

}

if left < right {

nums[left], nums[right] = nums[right], nums[left]

right--

}

}

return left

}

四、插入排序

插入排序的原理是，从第二个数开始向右侧遍历，每次均把该位置的元素移动至左侧，放在放在一个正确的位置（比左侧大，比右侧小），

代码如下:

//插入排序（排序10000个整数，用时约30ms）

func insertSort(nums []int) {

for i := 1; i < len(nums); i++ {

if nums[i] < nums[i-1] {

j := i - 1

temp := nums[i]

for j >= 0 nums[j] > temp {

nums[j+1] = nums[j]

j--

}

nums[j+1] = temp

}

}

}

通过多次测试可以发现，快速排序是效率最高的。

词语排序 第6篇

在IT届有一道百算不厌其烦的题，俗称排序，不管是你参加BAT等高端笔试，亦或是藏匿于街头小巷的草根笔试，都会经常见到这样一道百年难得一解的问题。

今天LZ有幸与各位分享一下算法届的草根明星，排序届的领衔大神——插入排序以及归并排序。最后，在头脑风暴下，LZ又有幸认识了一位新朋友，名叫并行归并排序。接下来，咱们就一一认识一下，并且在最后来一次“算林大会”吧。

插入排序简介

插入排序，算林称最亲民的排序算法，插入排序采用最简单的插入方式对一个整数数组进行排序。它循环数组中从第二个开始的所有元素，并且将每一个循环到的元素插入到相应的位置，从而实现排序的目的。

插入排序的代码展示

使用Java代码描述插入排序，可以用以下的代码。

package algorithm;

/**

* @author zuoxiaolong

*

*/

public abstract class InsertSort {

public static void sort(int[] numbers){

for (int i = 1; i < numbers.length; i++) {

int currentNumber = numbers[i];

int j = i - 1;

while (j >= 0 numbers[j] > currentNumber) {

numbers[j + 1] = numbers[j];

j--;

}

numbers[j + 1] = currentNumber;

}

}

}

复制代码

这个算法从数组的第二个元素开始循环，将选中的元素与之前的元素一一比较，如果选中的元素小于之前的元素，则将之前的元素后移，最后再将选中的元素放在合适的位置。在这个算法执行的过程中，总是保持着索引i之前的数组是升序排列的。

插入排序理解起来比较简单，因此LZ就不过多的解释它的实现原理了，尚未理解的猿友可以自行研究。

插入排序的性能分析

接下来，咱们来简单分析一下插入排序的性能。首先，插入排序当中有两个循环，假设数组的大小为n，则第一个循环是n－1次，第二个while循环在最坏的情况下是1到n－1次。因此插入排序的时间复杂度大约为如下形式。

1+2+3+4+...＋n－1 ＝ n（n－1）/ 2 ＝ O（n2）

时间复杂度为输入规模的2次函数，可见插入排序的时间复杂度是比较高的。这是原理上的简单分析，最后在“算林大会”中，各位可以清楚的看到插入排序随着输入规模的增长，时间会指数倍的上升。

归并排序简介

归并排序，算林届的新秀，引领着分治法的潮流。归并排序将排序问题拆分，比如分成两个较小的数组，然后对拆分后的数组分别进行排序，最后再将排序后的较小数组进行合并。

这种思想是一种算法设计的思想，很多问题都可以采用这种方式解决。映射到编程领域，其实就是递归的思想。因此在归并排序的算法中，将会出现递归调用。

归并排序的代码展示

归并排序主要由两个方法组成，一个是用于合并两个已经排序的数组的方法，一个则是递归方法，用于将问题无限拆分。接下来咱们一起看看归并排序的Java代码展示，如下所示。

package algorithm;

/**

* @author zuoxiaolong

*

*/

public abstract class MergeSort {

public static void sort(int[] numbers){

sort(numbers, 0, numbers.length);

}

public static void sort(int[] numbers,int pos,int end){

if ((end - pos) > 1) {

int ffset = (end + pos) / 2;

sort(numbers, pos, offset);

sort(numbers, offset, end);

merge(numbers, pos, offset, end);

}

}

public static void merge(int[] numbers,int pos,int offset,int end){

int[] array1 = new int[offset - pos];

int[] array2 = new int[end - offset];

System.arraycopy(numbers, pos, array1, 0, array1.length);

System.arraycopy(numbers, offset, array2, 0, array2.length);

for (int i = pos,j=0,k=0; i < end ; i++) {

if (j == array1.length) {

System.arraycopy(array2, k, numbers, i, array2.length - k);

break;

}

if (k == array2.length) {

System.arraycopy(array1, j, numbers, i, array1.length - j);

break;

}

if (array1[j] <= array2[k]) {

numbers[i] = array1[j++];

} else {

numbers[i] = array2[k++];

}

}

}

}

可以看到，归并排序将一个长度为n的数组平均分为两个n/2的数组分别进行处理，因此，在sort方法中又调用了两次sort方法自身。当数组大小为1时，则认为该数组为已经为排好序的数组。因此在sort方法中，需要end与pos相差大于2时，才需要进一步拆分，这也是递归的终止条件。

此外，在代码中，使用了Java提供的arraycory函数进行数组复制，这种直接复制内存区域的方式，将会比循环赋值的方式速度更快。有些算法实现会给merge方法中的两个临时数组设置哨兵，目的是为了防止merge中for循环的前两个if判断。为了方便理解，LZ这里没有设置哨兵，当某一个数组的元素消耗完时，将直接使用arraycopy方法把另外一个数组copy到numbers当中。

归并排序的性能分析

与插入排序一样，咱们来简单分析一下归并排序的时间复杂度。咱们假设数组的大小为n，sort方法的时间复杂度为f（end－pos）。简单的分析merge方法的复杂度，不难发现为（end－pos）＊2，这个结果的前提是咱们认为arraycopy方法的复杂度为length参数。

基于以上的假设，由于end－pos的初始值为n，因此归并排序的复杂度大约为如下形式。

2＊f（n/2） ＋ 2＊n ＝ 2＊（2＊f（n/4）＋2＊（n/2）） ＋ 2＊n＝4＊f（n/4） ＋ 2＊n ＋ 2＊n ＝ n ＊f（1） ＋ 2＊n ＋...＋2＊n

其中f（1）的时间复杂度为常量，假设f（1）＝c，而2＊n将有log2n个。因此咱们得到归并排序的最终时间复杂度为如下形式。

cn ＋ 2n＊log2n ＝ O（n＊log2n）

归并排序的时间复杂度与插入排序相比，已经降低了很多，这一点在数组的输入规模较大时将会非常明显，因为log函数的增加速度将远远低于n的增加速度。

并行归并排序简介

并行归并排序是LZ在学习归并排序时意淫出来的，最近LZ正在研究Java的并发编程，恰好归并排序的子问题有一定的并行度与独立性，因此LZ版的并发归并排序就这样诞生了。事后，LZ也人肉过并行归并排序这个家伙，发现早已众所周知，不过在不知道的情况下自己能够想到是不是也应该窃喜一下呢。

并行归并排序与普通的归并排序没有多大区别，只是利用现在计算机多核的优势，在有可能的情况下，让两个或多个子问题的处理一起进行。这样一来，在效率上，并行归并排序将会比归并排序更胜一筹。

并行归并排序的代码展示

并行归并排序主要对sort方法进行了修改，基础的merge方法与普通的归并排序是一样的。因此在进行并行归并排序时，引用了归并排序的一些方法，具体的代码如下所示。

package algorithm;

import java.util.concurrent.CountDownLatch;

/**

* @author zuoxiaolong

*

*/

public abstract class MergeParallelSort {

private static final int maxAsynDepth = (int)(Math.log(Runtime.getRuntime.availableProcessors())/Math.log(2));

public static void sort(int[] numbers) {

sort(numbers, maxAsynDepth);

}

public static void sort(int[] numbers,Integer asynDepth) {

sortParallel(numbers, 0, numbers.length, asynDepth > maxAsynDepth ? maxAsynDepth : asynDepth, 1);

}

public static void sortParallel(final int[] numbers,final int pos,final int end,final int asynDepth,final int depth){

if ((end - pos) > 1) {

final CountDownLatch mergeSignal = new CountDownLatch(2);

final int ffset = (end + pos) / 2;

Thread thread1 = new SortThread(depth, asynDepth, numbers, mergeSignal, pos, offset);

Thread thread2 = new SortThread(depth, asynDepth, numbers, mergeSignal, offset, end);

thread1.start();

thread2.start();

try {

mergeSignal.await();

} catch (InterruptedException e) {}

MergeSort.merge(numbers, pos, offset, end);

}

}

static class SortThread extends Thread {

private int depth;

private int asynDepth;

private int[] numbers;

private CountDownLatch mergeSignal;

private int pos;

private int end;

/**

* @param depth

* @param asynDepth

* @param numbers

* @param mergeSignal

* @param pos

* @param end

*/

public SortThread(int depth, int asynDepth, int[] numbers, CountDownLatch mergeSignal, int pos, int end) {

super();

this.depth = depth;

this.asynDepth = asynDepth;

this.numbers = numbers;

this.mergeSignal = mergeSignal;

this.pos = pos;

this.end = end;

}

@Override

public void run() {

if (depth < asynDepth) {

sortParallel(numbers,pos,end,asynDepth,(depth + 1));

} else {

MergeSort.sort(numbers, pos, end);

}

mergeSignal.countDown();

}

}

}

在这段代码中，有几点是比较特殊的，LZ简单的说明一下，

1，分解后的问题采用了并行的方式处理，并且咱们设定了一个参数asynDepth去控制并行的深度，通常情况下，深度为(log2CPU核数)即可。

2，当子问题不进行并行处理时，并行归并排序调用了普通归并排序的方法，比如MergeSort.sort和MergeSort.merge。

3，因为合并操作依赖于两个子问题的完成，因此咱们设定了一个合并信号（mergeSignal），当信号发出时，才进行合并操作。

并行归并排序在原理上与普通的归并排序是一样的，只是对于子问题的处理采用了一定程度上的并行，因此如果猿友们理解归并排序，那么并行归并排序并不难理解。

并行归并排序的性能分析

并行归并排序只是将普通归并排序中一些可并行的操作进行了并行处理，因此在总体的时间复杂度上并没有质的变化，都是O（n＊log2n）。

由于并行归并排序将某些排序操作并行操作，因此在性能上一定是快于普通归并排序算法的。不过这也不是一定的，当数组规模太小时，并行带来的性能提高可能会小于线程创建和销毁的开销，此时并行归并排序的性能可能会低于普通归并排序。

算林大会

接下来，就是一周一度的算林大会了，本次算林大会主要由以上三种算法参加，胜者将会成为本周度最受欢迎算法。接下来是算林大会的代码，请各位猿友过目。

package algorithm;

import java.io.File;

import java.lang.reflect.Method;

import java.util.Random;

/**

* @author zuoxiaolong

*

*/

public class SortTests {

public static void main(String[] args) {

testAllSortIsCorrect();

testComputeTime(“MergeParallelSort”, 40000, 5);

testComputeTime(“MergeSort”, 40000, 5);

testComputeTime(“InsertSort”, 400, 5);

}

public static void testAllSortIsCorrect() {

File classpath = new File(SortTests.class.getResource(“”).getFile());

File[] classesFiles = classpath.listFiles();

for (int i = 0; i < classesFiles.length; i++) {

if (classesFiles[i].getName().endsWith(“Sort.class”)) {

System.out.println(“---测试” + classesFiles[i].getName() + “是否有效---”);

testSortIsCorrect(classesFiles[i].getName().split(“.”)[0]);

}

}

}

public static void testSortIsCorrect(String className){

for (int i = 1; i < 50; i++) {

int[] numbers = getRandomIntegerArray(1000 * i);

invoke(numbers, className);

for (int j = 1; j < numbers.length; j++) {

if (numbers[j] < numbers[j-1]) {

throw new RuntimeException(className + “ sort is error because ” + numbers[j] + “<” + numbers[j-1]);

}

}

}

System.out.println(“---” + className + “经测试有效---”);

}

public static void testComputeTime(String className,int initNumber,int times,Object... arguments) {

long[] timeArray = new long[times];

for (int i = initNumber,j = 0; j < times; i = i * 10,j++) {

timeArray[j] = computeTime(i, className, arguments);

}

System.out.print(className + “时间增加比例：”);

for (int i = 1; i < timeArray.length ; i++) {

System.out.print((float)timeArray[i]/timeArray[i - 1]);

if (i < timeArray.length - 1) {

System.out.print(“,”);

}

}

System.out.println();

}

public static long computeTime(int length,String className,Object... arguments){

int[] numbers = getRandomIntegerArray(length);

long start = System.currentTimeMillis();

System.out.print(“开始计算长度为”+numbers.length+“方法为”+className+“参数为[”);

for (int i = 0; i < arguments.length; i++) {

System.out.print(arguments[i]);

if (i < arguments.length - 1) {

System.out.print(“,”);

}

}

System.out.print(“]，时间为”);

invoke(numbers, className, arguments);

long time = System.currentTimeMillis()-start;

System.out.println(time + “ms”);

return time;

}

public static int[] getRandomIntegerArray(int length){

int[] numbers = new int[length];

for (int i = 0; i < numbers.length; i++) {

numbers[i] = new Random().nextInt(length);

}

return numbers;

}

public static void invoke(int[] numbers,String className,Object... arguments){

try {

Class

Class

parameterTypes[0] = int[].class;

for (int i = 0; i < arguments.length; i++) {

parameterTypes[i + 1] = arguments[i].getClass();

}

Method method = clazz.getDeclaredMethod(“sort”, parameterTypes);

Object[] parameters = new Object[parameterTypes.length];

parameters[0] = numbers;

for (int i = 0; i < arguments.length; i++) {

parameters[i + 1] = arguments[i];

}

method.invoke(null, parameters);

} catch (Exception e) {

throw new RuntimeException(e);

}

}

}

以上代码testAllSortIsCorrect方法首先验证了三种算法的正确性，也就是说经过sort方法后，数组是否已经升序排列。需要一提的是，由于插入排序的性能太低，因此插入排序测试的最大规模为400万，而归并排序测试的最大规模为4亿。

接下来，大家就一起看看运行结果吧。以下是在LZ的mac pro上的运行结果，硬件配置为16G内存，4核i7。这种配置下，异步深度（asynDepth）默认为log24=2。

---测试InsertSort.class是否有效---

---InsertSort经测试有效---

---测试MergeParallelSort.class是否有效---

---MergeParallelSort经测试有效---

---测试MergeSort.class是否有效---

---MergeSort经测试有效---

开始计算长度为40000方法为MergeParallelSort参数为[]，时间为6ms

开始计算长度为400000方法为MergeParallelSort参数为[]，时间为44ms

开始计算长度为4000000方法为MergeParallelSort参数为[]，时间为390ms

开始计算长度为40000000方法为MergeParallelSort参数为[]，时间为3872ms

开始计算长度为400000000方法为MergeParallelSort参数为[]，时间为47168ms

MergeParallelSort时间增加比例：7.3333335,8.863636,9.9282055,12.181818

开始计算长度为40000方法为MergeSort参数为[]，时间为7ms

开始计算长度为400000方法为MergeSort参数为[]，时间为81ms

开始计算长度为4000000方法为MergeSort参数为[]，时间为839ms

开始计算长度为40000000方法为MergeSort参数为[]，时间为9517ms

开始计算长度为400000000方法为MergeSort参数为[]，时间为104760ms

MergeSort时间增加比例：11.571428,10.358025,11.343266,11.00767

开始计算长度为400方法为InsertSort参数为[]，时间为0ms

开始计算长度为4000方法为InsertSort参数为[]，时间为3ms

开始计算长度为40000方法为InsertSort参数为[]，时间为245ms

开始计算长度为400000方法为InsertSort参数为[]，时间为23509ms

开始计算长度为4000000方法为InsertSort参数为[]，时间为3309180ms

InsertSort时间增加比例：Infinity,81.666664,95.9551,140.76227

复制代码

首先可以看到，三种算法都是运行正确的。接下来，咱们可以对比一下三种算法的性能。

根据输出结果，规模为400万时的区别是最明显与直观的。并行归并排序仅需要390ms就完成了400万规模的排序，而普通的归并排序则需要839ms才可以，至于插入排序，简直是不可理喻，竟然需要300多万ms，大约50分钟。

咱们再来看三者的时间增长趋势。两种归并排序基本上与规模的增长趋势相似，每当规模增加10倍时，时间也基本上增加10倍，而插入排序则几乎是以100倍的速度在增加，刚好是数组规模增长速度的平方。其中的Infinity是因为当数组规模为400时，毫秒级别的计时为0ms，因此当除数为0时，结果就为Infinity。