关于排序都会讲的名词:(我自己的理解)

  时间复杂度:  指排序过程中,程序消耗的时间。

  空间复杂度:  指排序过程中,程序所消耗内存的大小。

     稳定:  如果两个值相等,a和b,a=b且a在b位置的左边,排序后依旧在左边(或者上下排列的话,可以理解为前边)。

    不稳定:  两个相等的值在一起,排序会让其互换位置。

关于稳定和不稳定,有图说明:

如上图一:北京成都、上海广州,这两对,值相等,分别都是90和50,北京在成都的前边吧,

如上图二:排序后,按大小顺序排列,但是之前成都在后边,现在跑到北京的前边了。

如上图三:再次点击排序按钮,西安和呼和浩特分别是最大最小没有动,但是北京成都、上海广州这两对互换了位置

这就是不稳定。

如果不互换,按照图一的位置,最终的排序应该是:西、北、成、上、广、呼。且无论后期点多少次排序,都将是这个顺序才是。

一、冒泡排序

源代码:

var arrData=[12,35,23,18,95,2,67,9,56];
sortArr(arrData); function sortArr(arr){
for(i=0;i<arr.length-1;i++){
for(j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
var temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr;
}

分析用的代码:

 var arrData=[12,35,23,18,95,2,67,9,56];
sortArr(arrData); function sortArr(arr){
for(i=0;i<arr.length-1;i++){
console.log("i="+i+",下标对应数为"+arr[i]+",大循环 "+(i+1));
for(j=0;j<arr.length-1-i;j++){
console.log("j="+j+",下标对应数为"+arr[j]+",小循环"+(i+1)+"-"+(j+1));
console.log("j+1对应的数是"+arr[j+1]);
console.log(arr[j]+"和"+arr[j+1]+"比");
if(arr[j]>arr[j+1]){
console.log(arr[j]+"大于"+arr[j+1]+",互换位置");
var temp=arr[j];
console.log("先把"+arr[j]+"存到temp中");
arr[j]=arr[j+1];
console.log("再让"+arr[j]+"等于后边比他小的"+arr[j+1]);
arr[j+1]=temp;
console.log("最后把存在temp中前边较大的值"+temp+"给了后边的arr[j+1]");
}else{
console.log(arr[j]+"小于"+arr[j+1]+",跳过本次循环");
}
}
}
return arr;
}

分析代码

排序过程中,文字描述

输出结果:[2, 9, 12, 18, 23, 35, 56, 67, 95];
初始值对比:[12,35,23,18,95,2,67,9,56];

 i=0,下标对应数为12,大循环 1
j=0,下标对应数为12,小循环1-1
j+1对应的数是35
12和35比
12小于35,跳过本次循环
j=1,下标对应数为35,小循环1-2
j+1对应的数是23
35和23比
35大于23,互换位置
先把35存到temp中
再让前边的大值35等于后边比他小的23
最后把存在temp中前边较大的值35给了后边的arr[j+1]
调换23与35的顺序完成
j=2,下标对应数为35,小循环1-3
j+1对应的数是18
35和18比
35大于18,互换位置
先把35存到temp中
再让前边的大值35等于后边比他小的18
最后把存在temp中前边较大的值35给了后边的arr[j+1]
调换18与35的顺序完成
j=3,下标对应数为35,小循环1-4
j+1对应的数是95
35和95比
35小于95,跳过本次循环
j=4,下标对应数为95,小循环1-5
j+1对应的数是2
95和2比
95大于2,互换位置
先把95存到temp中
再让前边的大值95等于后边比他小的2
最后把存在temp中前边较大的值95给了后边的arr[j+1]
调换2与95的顺序完成
j=5,下标对应数为95,小循环1-6
j+1对应的数是67
95和67比
95大于67,互换位置
先把95存到temp中
再让前边的大值95等于后边比他小的67
最后把存在temp中前边较大的值95给了后边的arr[j+1]
调换67与95的顺序完成
j=6,下标对应数为95,小循环1-7
j+1对应的数是9
95和9比
95大于9,互换位置
先把95存到temp中
再让前边的大值95等于后边比他小的9
最后把存在temp中前边较大的值95给了后边的arr[j+1]
调换9与95的顺序完成
j=7,下标对应数为95,小循环1-8
j+1对应的数是56
95和56比
95大于56,互换位置
先把95存到temp中
再让前边的大值95等于后边比他小的56
最后把存在temp中前边较大的值95给了后边的arr[j+1]
调换56与95的顺序完成
i=1,下标对应数为23,大循环 2
j=0,下标对应数为12,小循环2-1
j+1对应的数是23
12和23比
12小于23,跳过本次循环
j=1,下标对应数为23,小循环2-2
j+1对应的数是18
23和18比
23大于18,互换位置
先把23存到temp中
再让前边的大值23等于后边比他小的18
最后把存在temp中前边较大的值23给了后边的arr[j+1]
调换18与23的顺序完成
j=2,下标对应数为23,小循环2-3
j+1对应的数是35
23和35比
23小于35,跳过本次循环
j=3,下标对应数为35,小循环2-4
j+1对应的数是2
35和2比
35大于2,互换位置
先把35存到temp中
再让前边的大值35等于后边比他小的2
最后把存在temp中前边较大的值35给了后边的arr[j+1]
调换2与35的顺序完成
j=4,下标对应数为35,小循环2-5
j+1对应的数是67
35和67比
35小于67,跳过本次循环
j=5,下标对应数为67,小循环2-6
j+1对应的数是9
67和9比
67大于9,互换位置
先把67存到temp中
再让前边的大值67等于后边比他小的9
最后把存在temp中前边较大的值67给了后边的arr[j+1]
调换9与67的顺序完成
j=6,下标对应数为67,小循环2-7
j+1对应的数是56
67和56比
67大于56,互换位置
先把67存到temp中
再让前边的大值67等于后边比他小的56
最后把存在temp中前边较大的值67给了后边的arr[j+1]
调换56与67的顺序完成
i=2,下标对应数为23,大循环 3
j=0,下标对应数为12,小循环3-1
j+1对应的数是18
12和18比
12小于18,跳过本次循环
j=1,下标对应数为18,小循环3-2
j+1对应的数是23
18和23比
18小于23,跳过本次循环
j=2,下标对应数为23,小循环3-3
j+1对应的数是2
23和2比
23大于2,互换位置
先把23存到temp中
再让前边的大值23等于后边比他小的2
最后把存在temp中前边较大的值23给了后边的arr[j+1]
调换2与23的顺序完成
j=3,下标对应数为23,小循环3-4
j+1对应的数是35
23和35比
23小于35,跳过本次循环
j=4,下标对应数为35,小循环3-5
j+1对应的数是9
35和9比
35大于9,互换位置
先把35存到temp中
再让前边的大值35等于后边比他小的9
最后把存在temp中前边较大的值35给了后边的arr[j+1]
调换9与35的顺序完成
j=5,下标对应数为35,小循环3-6
j+1对应的数是56
35和56比
35小于56,跳过本次循环
i=3,下标对应数为23,大循环 4
j=0,下标对应数为12,小循环4-1
j+1对应的数是18
12和18比
12小于18,跳过本次循环
j=1,下标对应数为18,小循环4-2
j+1对应的数是2
18和2比
18大于2,互换位置
先把18存到temp中
再让前边的大值18等于后边比他小的2
最后把存在temp中前边较大的值18给了后边的arr[j+1]
调换2与18的顺序完成
j=2,下标对应数为18,小循环4-3
j+1对应的数是23
18和23比
18小于23,跳过本次循环
j=3,下标对应数为23,小循环4-4
j+1对应的数是9
23和9比
23大于9,互换位置
先把23存到temp中
再让前边的大值23等于后边比他小的9
最后把存在temp中前边较大的值23给了后边的arr[j+1]
调换9与23的顺序完成
j=4,下标对应数为23,小循环4-5
j+1对应的数是35
23和35比
23小于35,跳过本次循环
i=4,下标对应数为23,大循环 5
j=0,下标对应数为12,小循环5-1
j+1对应的数是2
12和2比
12大于2,互换位置
先把12存到temp中
再让前边的大值12等于后边比他小的2
最后把存在temp中前边较大的值12给了后边的arr[j+1]
调换2与12的顺序完成
j=1,下标对应数为12,小循环5-2
j+1对应的数是18
12和18比
12小于18,跳过本次循环
j=2,下标对应数为18,小循环5-3
j+1对应的数是9
18和9比
18大于9,互换位置
先把18存到temp中
再让前边的大值18等于后边比他小的9
最后把存在temp中前边较大的值18给了后边的arr[j+1]
调换9与18的顺序完成
j=3,下标对应数为18,小循环5-4
j+1对应的数是23
18和23比
18小于23,跳过本次循环
i=5,下标对应数为35,大循环 6
j=0,下标对应数为2,小循环6-1
j+1对应的数是12
2和12比
2小于12,跳过本次循环
j=1,下标对应数为12,小循环6-2
j+1对应的数是9
12和9比
12大于9,互换位置
先把12存到temp中
再让前边的大值12等于后边比他小的9
最后把存在temp中前边较大的值12给了后边的arr[j+1]
调换9与12的顺序完成
j=2,下标对应数为12,小循环6-3
j+1对应的数是18
12和18比
12小于18,跳过本次循环
i=6,下标对应数为56,大循环 7
j=0,下标对应数为2,小循环7-1
j+1对应的数是9
2和9比
2小于9,跳过本次循环
j=1,下标对应数为9,小循环7-2
j+1对应的数是12
9和12比
9小于12,跳过本次循环
i=7,下标对应数为67,大循环 8
j=0,下标对应数为2,小循环8-1
j+1对应的数是9
2和9比
2小于9,跳过本次循环
输出结果:[2, 9, 12, 18, 23, 35, 56, 67, 95];
初始值对比:[12,35,23,18,95,2,67,9,56];

文字描述冒泡排序的全过程

原理:

第一遍循环,在内循环里把最大的数拍到了最后。

第二遍循环i,在内循环里,排除掉最后一个最大的不循环,将剩下的再次循环,把次要大的排到最后。

最终,出来从大到小的循环。

再循环里边,让当前循环到的数和后一个比较,若小于不动位置,若大于,则将这个数先存到temp中,然后让这个数等于后一个数,再让后一个数等于temp,完成两个数的位置调换。

依次类推,最后比后一个数大的数,都被移到了最后。

若变成从大到小的循环:

只需把  if(arr[j]>arr[j+1])  处的大于号换成小于号即可。

JS-几大排序算法(更新中...)的更多相关文章

  1. 几大排序算法的Java实现(原创)

    几大排序算法的Java实现 更新中... 注: 该类中附有随机生成[min, max)范围不重复整数的方法,如果各位看官对此方法有什么更好的建议,欢迎提出交流. 各个算法的思路都写在该类的注释中了,同 ...

  2. JS的排序算法

    排序是最基本的算法(本文排序为升序Ascending),常见的有以下几种: 1.冒泡排序 Bubble Sort 2.选择排序 Selection Sort 3.插入排序 Insertion Sort ...

  3. 几大排序算法的Java实现

    很多的面试题都问到了排序算法,中间的算法和思想比较重要,这边我选择了5种常用排序算法并用Java进行了实现.自己写一个模板已防以后面试用到.大家可以看过算法之后,自己去实现一下. 1.冒泡排序:大数向 ...

  4. js 实现排序算法 -- 快速排序(Quick Sort)

    原文: 十大经典排序算法(动图演示) 快速排序 快速排序的基本思想:通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整 ...

  5. js 实现排序算法 -- 插入排序(Insertion Sort)

    原文: 十大经典排序算法(动图演示) 插入排序 插入排序(Insertion-Sort)的算法描述是一种简单直观的排序算法.它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描, ...

  6. js 实现排序算法 -- 选择排序(Selection Sort)

    原文: 十大经典排序算法(动图演示) 选择排序(Selection Sort) 选择排序(Selection-sort)是一种简单直观的排序算法.它的工作原理:首先在未排序序列中找到最小(大)元素,存 ...

  7. JS常见排序算法

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  8. js 实现排序算法 -- 归并排序(Merge Sort)

    原文: 十大经典排序算法(动图演示) 归并排序 归并排序是建立在归并操作上的一种有效的排序算法.该算法是采用分治法(Divide and Conquer)的一个非常典型的应用.将已有序的子序列合并,得 ...

  9. js 实现排序算法 -- 希尔排序(Shell Sort)

    原文: 十大经典排序算法(动图演示) 希尔排序 1959年Shell发明,第一个突破O(n2)的排序算法,是简单插入排序的改进版.它与插入排序的不同之处在于,它会优先比较距离较远的元素.希尔排序又叫缩 ...

  10. js 实现排序算法 -- 冒泡排序(Bubble Sort)

    原文: 十大经典排序算法(动图演示) 冒泡排序(Bubble Sort) 冒泡排序是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来.走访数列的工作 ...

随机推荐

  1. POJ 3481 Double Queue(STL)

    题意  模拟银行的排队系统  有三种操作  1-加入优先级为p 编号为k的人到队列  2-服务当前优先级最大的   3-服务当前优先级最小的  0-退出系统 能够用stl中的map   由于map本身 ...

  2. Windows下安装Oracle12C(二)

    一.安装Oracle 参考 Windows下安装Oracle12C(一) 二.新建用户 1. 安装完成后,启动SQLPlus,然后输入内置的用户名和密码 用户名:sys   密码:as sysdba ...

  3. Spring Cloud 微服务的那点事

    什么是微服务 微服务的概念源于2014年3月Martin Fowler所写的一篇文章“Microservices”. 微服务架构是一种架构模式,它提倡将单一应用程序划分成一组小的服务,服务之间互相协调 ...

  4. Compile cpp File Manually without IDE under Mingw Environment

    环境准备. 安装mingw并设置好系统PATH. mingw.windows下的GUN编程环境. 系统变量的作用--可运行文件的搜索路径. 这样在cmd直接输入g++就能调用到D:\Program F ...

  5. mysql 找不到或无法加载已注册的 .Net Framework Data Provider和Unable to find the requested .Net Framework Data Provider. It may not be installed解决

    需要安装 mysql-connector-net-6.7.4.msi 在C盘安装mysql的位置找到三个DLL,复制到Bin文件夹下 在Web.config文件中添加对应配置: <system. ...

  6. 前端可视化编程:liveReload安装,sublime 3

    需要插件  sublime text3:View in Browser:LiveReload chrome:liveReload 配置方法 一:sublime text3 sublime 3下载地址: ...

  7. Sublime的Package Control安装方法

    Package Control插件本身是一个为了方便管理插件的插件 最简单的方式是通过Sublime Text 3的console命令界面进行安装 Sublime text3 import urlli ...

  8. python 类属性 、实例属性,可变数据结构作为类属性需要注意的地方

    1.一些经典的python错误不去阅读和不重视,就会把错误的做法带入到实际项目中来,甚至造成难以排查问题. 2.有一个大笨猪,按java写观察者模式,java写得是直接在类名下声明一个实例属性(不加s ...

  9. 【scala】 scala 基础(一)

    至于什么是scala,摘录一段 维基百科的解释: scala 下载 安装 省略 1.环境变量配置完成后 命令行报错,因为scala 的安装路径里边包含空格 修改后即可.由于我的本地包含空格,此处CLI ...

  10. 标准SQL资料整理

    最近感觉SQL忘记的很快,于是把SQL的基础知识整理了下. 使用的工具是MindManager 9. 资料来自W3C School:http://www.w3school.com.cn/sql/ind ...