这学期刚刚学完数据结构,之前就自己写了一点东西,现在整理一下。

  1. <!DOCTYPE html>
  2. <html>
  3.  
  4. <head>
  5. <meta charset="utf-8">
  6. <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
  7. <title>JS实现排序</title>
  8. <meta name="description" content="用JS自己写的排序算法">
  9. <meta name="keywords" content="JS,排序">
  10. </head>
  11.  
  12. <body>
  13. <script type="text/javascript">
  14. //从小到大排序
  15. var a = [, , , , , , , , ];
  16. //第一种:简单冒泡排序
  17. function bubbleSort0(ar) {
  18. for (var i = ; i < ar.length - ; i++) { //a.length长的数组只要进行a.length-1次排序,0-a.length-2刚好为a.length-1的长度
  19. for (var j = i + ; j < ar.length; j++) {
  20. if (a[i] > a[j]) {
  21. a[i] ^= a[j]; //交换两个数
  22. a[j] ^= a[i];
  23. a[i] ^= a[j];
  24. }
  25. }
  26. }
  27. }
  28. bubbleSort0(a);
  29. console.log("简单冒泡排序:" + a);
  30.  
  31. //第二种:正宗冒泡排序
  32. var a = [, , , , , , , , ];
  33. function bubbleSort(ar) {
  34. var flag = true;
  35. for (var i = ; i < ar.length - && flag; i++) { //a.length长的数组只要进行a.length-1次排序,0-a.length-2刚好为a.length-1的长度
  36. for (var j = ar.length - ; j > i; j--) { //判断条件与下面的判断条件的边界值需要注意
  37. flag = false; //默认标志为false,则当不进入下面括号的时候代表i之后的数已经排好了序,这里用的是上一轮排序的结果
  38. if (a[j] < a[j - ]) {
  39. a[j] ^= a[j - ];
  40. a[j - ] ^= a[j];
  41. a[j] ^= a[j - ];
  42. flag = true; //当i后面有数据交换的时候则认为排序没有完成
  43. }
  44. }
  45. }
  46. }
  47. bubbleSort(a);
  48. console.log("正宗冒泡排序:" + a);
  49.  
  50. //第三种:简单选择排序
  51. var a = [, , , , , , , , ];
  52.  
  53. function selectSort(ar) {
  54. for (var i = ; i < ar.length - ; i++) {
  55. var temp = i;
  56. for (var j = i + ; j < ar.length; j++) {
  57. if (a[j] < a[temp])
  58. temp = j;
  59. }
  60. if (temp != i) {
  61. a[i] ^= a[temp];
  62. a[temp] ^= a[i];
  63. a[i] ^= a[temp];
  64. }
  65. }
  66. }
  67. selectSort(a);
  68. console.log("简单选择排序:" + a);
  69.  
  70. //第四种:插入排序
  71. var a = [, , , , , , , , , ]; //第一个0是放暂存数的,为了能让后面的数有空间挪动
  72. function insertSort(ar) {
  73. for (var i = ; i < ar.length; i++) { //假设a[1]为已经排好序的数列,虽然只有一个数
  74. if (a[i] < a[i - ]) { //当后面的数比前面的数小的时候
  75. a[] = a[i];
  76. for (var j = i - ; a[j] > a[]; j--) //暂存位还可以起到比较的作用
  77. a[j + ] = a[j];
  78. a[j + ] = a[];
  79. }
  80. }
  81. a[] = ; //小洁癖,还原暂存数位为0,美观
  82. }
  83. insertSort(a);
  84. console.log("插入排序:" + a);
  85.  
  86. //第五种:希尔排序
  87. var a = [, , , , , , , , , ]; //第一个0是放暂存数的,为了能让后面的数有空间挪动
  88. function shellSort(ar) {
  89. var incre = ar.length - ; //初始化递增量为数组内排序的数字的长度,不包括暂存位
  90. do {
  91. incre = parseInt(incre / ) + ; //经研究递增量为n/3+1,n/9+1,n/27+1……时的排序效率最高,这里取n/3+1方法
  92. for (var i = incre + ; i <= ar.length - ; i++) {
  93. if (a[i] < a[i - incre]) {
  94. a[] = a[i];
  95. for (var j = i - incre; j > && a[j] > a[]; j -= incre)
  96. a[j + incre] = a[j];
  97. a[j + incre] = a[];
  98. }
  99. }
  100. } while (incre > );
  101. a[] = ;
  102. }
  103. shellSort(a);
  104. console.log("希尔排序:" + a);
  105.  
  106. //第六种:基数排序
  107. var b = [, , , , , , , , ]; //测试基数排序的数组,定义大一点
  108. function radixSort(arr) {
  109. var i, j, k, lsd;
  110. var n = ; //变量n,每次递增10倍
  111. var t = ; //数字的最大位数递增量,从个位开始
  112. var temp = new Array(); //创建一维数组
  113. var count = new Array();
  114. for (i = ; i < ; i++) {
  115. temp[i] = new Array(arr.length); //创建二维数组
  116. }
  117. for (i = ; i < ; i++) { //初始化二维数组和计数数组
  118. count[i] = ;
  119. for (j = ; j < arr.length; j++)
  120. temp[i][j] = ;
  121. }
  122. var numLength = getNumberLength(arr); //得到数的宽度,比如[337,1,22]得到为3,函数放在基数排序函数radixSort的最后
  123. while (t++ <= numLength) { //这里循环数组数字的位数进行统计和收集
  124.  
  125. for (j = ; j < arr.length; j++) { //统计
  126. lsd = parseInt((arr[j] / n) % ); //取得当前位数的数字
  127. temp[lsd][count[lsd]++] = arr[j]; //将其存入二维数组temp
  128. }
  129. for (i = , k = ; i < ; i++) { //收集二维数组的计数存入原来的数组
  130. if (count[i] != ) //当前的数字统计有数
  131. for (j = ; j < count[i]; j++) //***计数数组的作用体现了,不用每次都把二维数组temp置0
  132. arr[k++] = temp[i][j];
  133. count[i] = ;
  134. }
  135. n *= ; //统计后一位数组
  136. }
  137.  
  138. function getNumberLength(a) { //计算数组的数字的最大长度,比如[337,1,22]得到为3,放在最后没关系,JS有隐式提升
  139. var numberLength, max = ;
  140. for (var i = ; i < a.length; i++) {
  141. var temp = a[i];
  142. numberLength = ;
  143. while (temp >= ) {
  144. temp /= ;
  145. numberLength++;
  146. if (temp < ) {
  147. numberLength++;
  148. break;
  149. }
  150. }
  151. if (numberLength > max)
  152. max = numberLength;
  153. }
  154. return max;
  155. }
  156. }
  157. radixSort(b);
  158. console.log("基数排序:" + b);
  159.  
  160. //第七种:快速排序
  161. var a = [, , , , , , , , ]; //第一个0是放暂存数的,为了能让后面的数有空间挪动
  162. function quickSort(ar, low, high) {
  163. var povit;
  164. if (low < high) {
  165. povit = partition(ar, low, high);
  166. quickSort(ar, low, povit - );
  167. quickSort(ar, povit + , high);
  168. }
  169. }
  170. //求枢轴
  171. function partition(ar, low, high) {
  172. var povitkey;
  173. povitkey = ar[low]; //取最低的数作为枢轴
  174. var temp;
  175. while (low < high) {
  176. while (low < high && ar[high] >= povitkey)
  177. high--;
  178. if (ar[high] != ar[low]) {
  179. ar[high] ^= ar[low];
  180. ar[low] ^= ar[high];
  181. ar[high] ^= ar[low];
  182. }
  183. while (low < high && ar[low] <= povitkey)
  184. low++;
  185. if (ar[high] != ar[low]) {
  186. ar[high] ^= ar[low];
  187. ar[low] ^= ar[high];
  188. ar[high] ^= ar[low];
  189. }
  190. }
  191. return low;
  192. }
  193. quickSort(a, , a.length - );
  194. console.log("快速排序:" + a);
  195.  
  196. //第八种:堆排序
  197. var a = [, , , , , , , , , ]; //第一个0是放暂存数的,为了能让后面的数有空间挪动
  198. function heapSort(ar) {
  199. var i;
  200. for (i = parseInt((ar.length - ) / ); i > ; i--) { //构建大顶堆
  201. heapAdjust(ar, i, ar.length - );
  202. }
  203. for (i = ar.length - ; i > ; i--) {
  204. //交换两个数,ar[1]和ar[i]
  205. ar[] ^= ar[i];
  206. ar[i] ^= ar[];
  207. ar[] ^= ar[i];
  208. heapAdjust(ar, , i - );
  209. }
  210. }
  211.  
  212. function heapAdjust(ar, s, m) { //s为上标,m为下标
  213. var temp, j;
  214. temp = ar[s];
  215. for (j = * s; j <= m; j *= ) {
  216. if (j < m && ar[j + ] > ar[j]) //当右孩子比左孩子大的时候
  217. j++;
  218. if (temp > ar[j])
  219. break;
  220. ar[s] = ar[j];
  221. s = j;
  222. }
  223. ar[s] = temp;
  224. }
  225. heapSort(a);
  226. console.log("堆排序:" + a);
  227.  
  228. //第八种:堆排序改进
  229. var a = [, , , , , , , , ]; //第一个0是放暂存数的,为了能让后面的数有空间挪动
  230. function heapSort(ar) {
  231. var i;
  232. for (i = parseInt((ar.length - ) / ) - ; i >= ; i--) { //构建大顶堆
  233. heapAdjust(ar, i, ar.length - );
  234. }
  235. for (i = ar.length - ; i >= ; i--) {
  236. //交换两个数,ar[1]和ar[i]
  237. ar[] ^= ar[i];
  238. ar[i] ^= ar[];
  239. ar[] ^= ar[i];
  240. if (i !== )
  241. heapAdjust(ar, , i - );
  242. }
  243. }
  244.  
  245. function heapAdjust(ar, s, m) { //s为上标,m为下标
  246. var temp, j;
  247. temp = ar[s];
  248. for (j = * s; j <= m; j *= ) {
  249. if (j < m && ar[j + ] > ar[j]) //当右孩子比左孩子大的时候
  250. j++;
  251. if (temp > ar[j])
  252. break;
  253. ar[s] = ar[j];
  254. s = j;
  255. }
  256. ar[s] = temp;
  257. }
  258. heapSort(a);
  259. console.log("堆排序改进:" + a);
  260. </script>
  261. </body>
  262.  
  263. </html>

也不知道是不是最好的排序算法,学的时候是用的C语言写的,C语言的版本后面再整理吧,这里的都是JS的。

感觉高级语言封装好了太多东西,像排序只要一个sort方法就搞定了,但是自己写完才知道,后面封装了太多东西,一个排序方法可能Brenden Eich(JS发明者)已经写了几百行代码。

像Java,C#等等都封装了太多的基本代码在里面,感觉我们开发项目就是在组装电脑,拿起内存和硬盘看下型号插插插。最后剩下的就只有动手能力了。

keep fighting!:)

 

自己写的JS排序算法的更多相关文章

  1. js排序算法汇总

    JS家的排序算法   十大经典算法排序总结对比 一张图概括: 主流排序算法概览 名词解释: n: 数据规模k:“桶”的个数In-place: 占用常数内存,不占用额外内存Out-place: 占用额外 ...

  2. 总结下js排序算法和乱序算法

    其实本人最怕的就是算法,大学算法课就感觉老师在讲天书,而且对于前端来说,算法在实际的应用中实在是很有限.毕竟算法要依靠大量的数据为基础才能发挥出算法的效率,就浏览器那性能,......是吧,退一万步说 ...

  3. 排序图解:js排序算法实现

    之前写过js实现数组去重, 今天继续研究数组: 排序算法实现. 排序是数据结构主要内容,并不限于语言主要在于思想:大学曾经用C语言研究过一段时间的排序实现, 这段时间有空用JS再将排序知识点熟悉一遍. ...

  4. 常用的 JS 排序算法整理

    关于排序算法的问题可以在网上搜到一大堆,但是纯 JS 版比较零散,之前面试的时候特意整理了一遍,附带排序效率比较. //1.冒泡排序 var bubbleSort = function(arr) { ...

  5. 用Java来写常见的排序算法

    随着校招的临近 算法是校招中很重要的一个部分 总结了常见几种排序算法,各种算法的时间复杂度和空间复杂度大家也需要多了解下 package com.huwei.sort; /** * 各种排序算法 * ...

  6. js排序算法总结—冒泡,快速,选择,插入,希尔,归并

    相信排序是任何一个程序猿都会用到的东西,今天简单总结记录下常见的排序算法. 一.冒泡排序 说起冒泡排序,可能每个人都不会陌生,实现思路相当简单明了,就是不停的对数组进行两两比较,将较大(较小)的一项放 ...

  7. js排序算法总结——冒泡,快速,选择,插入,希尔,归并

    相信排序是任何一个程序猿都会用到的东西,今天简单总结记录下常见的排序算法. 一.冒泡排序 说起冒泡排序,可能每个人都不会陌生,实现思路相当简单明了,就是不停的对数组进行两两比较,将较大(较小)的一项放 ...

  8. 结构-行为-样式-Js排序算法之 直接插入排序

    最新因工作原因需要接触到算法,之前学习C++的时候有接触过算法,Javascript中实现算法其实也是大同小异.下面我讲下第一个实现的排序算法--直接插入排序.基本实现思路:假定一个数组中前n(n&g ...

  9. js排序算法总结

    快速排序 大致分三步: 1.找基准(一般是以中间项为基准) 2.遍历数组,小于基准的放在left,大于基准的放在right 3.递归 快速排序的平均时间复杂度是O(nlogn),最差情况是O(n²). ...

随机推荐

  1. xmpp muc 群聊协议 3

    6. Entity Use Cases A MUC implementation MUST support Service Discovery [7]. 服务端必须实现 service discove ...

  2. 只有ReflectionOnlyLoadFrom才可以拯救与GAC冲突的强命名程序集

    先说结论,如果有两个拥有相同程序集名称的强命名程序集,一个在GAC里,一个不在.怎样动态加载那个不在GAC里的程序集?答案就是只有Assembly.ReflectionOnlyLoadFrom才可以加 ...

  3. php学习之有用的资源 总结

    1.php之道,http://laravel-china.github.io/php-the-right-way/ 2.改变php变成效率 http://www.php100.com/html/duj ...

  4. access variables from the global scope 在全局范围内访问变量的2种方法

    w http://php.net/manual/zh/language.variables.scope.php http://php.net/manual/en/language.variables. ...

  5. linux里的CPU负载

    昨天查看Nagios警报信息,发现其中一台服务器CPU负载过重,机器为CentOS系统.信息如下: 2011-2-15 (星期二) 17:50 WARNING - load average: 9.73 ...

  6. 使用Docker创建Elasticsearch服务

    一.Docker是什么? Docker是一个开源工具,能将一个WEB应用封装在一个轻量级,便携且独立的容器里,然后可以运行在几乎任何服务环境下.Docker的容器能使应用跑在任何服务器上并且表现一致. ...

  7. Runtime Error! R6025-pure virtual function call 问题怎么解决

    一.故障现象:1.360软件的木马查杀.漏洞修复等组件不能使用,提示runtime error2.暴风影音等很多软件不能正常使用3.设备管理器不能打开,提示“MMC 不能打开文件”4.部分https安 ...

  8. export,import ,export default的区别

    首先要知道export,import ,export default是什么 ES6模块主要有两个功能:export和importexport用于对外输出本模块(一个文件可以理解为一个模块)变量的接口i ...

  9. Selenium定位不到指定元素原因之iframe(unable to locate element)

    浏览过程中,图片中的内容可能太小,无法看清,可以>右键>在新标签中打开 Outline 项目原因,需要用selenium实现模拟登陆.模拟上传文件,自然就需要模拟点击[上传]按钮: 模拟点 ...

  10. Python简单实现邮件群发

    Python简单实现邮件群发 import smtplib from email.mime.text import MIMEText from email.utils import formatadd ...