排序:
  1. 内部排序:
    (1). 交换排序:
      1). 冒泡排序 稳定
        一次比较相邻两个元素的大小,顺序错误的,将其位置互换
        (从高位到低位 或者 从低位到高位)

初始版: 

           var array = [6, 5, 3, 1, 8, 7, 2, 4],
length = array.length,
temp = '';
for (var i=0; i<length-1; i++) {
for (var j=0; j<length-i-1; j++) {
if (array[j]>array[j+1]) {
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
console.log(array)

 改进版(定义标志变量记录每次最后一次交换的位置索引,此标志变量之后的元素都已交换完成,故再次循环的时候只进行到标记变量的位置比较即可)

 var array = [6, 5, 3, 1, 8, 7, 2, 4],
temp = '',
i = array.length - 1;
while (i > 0) {
let pos = 0;
for (let j = 0; j < i; j++) {
if (array[j] > array[j + 1]) {
pos = j;
let temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
i = pos;
}
console.log(array)

鸡尾酒(定向冒泡排序)(从高位到低位的同时也从低位到高位)

         var array = [6,5,3,1,8,7,2,4],
length = array.length,
temp = '',
left = 0,
right = length-1;
while (left<right) {
for (var i=0; i<right; i++) {
if (array[i]>array[i+1]) {
temp = array[i];
array[i] = array[i+1];
array[i+1] = temp;
}
}
right--;
for (var i=right; i>left; i--) {
if (array[i]<array[i-1]) {
temp = array[i];
array[i] = array[i-1];
array[i-1] = temp;
}
}
left++;
}
console.log(array)

       2). 快速排序 不稳定
        1. 取数组中间索引(pivotIndex)
        2. 去数组中间位置元素(pivot = Number(array.splice(pivotIndex, 1)))
        3. 新建两个空数组left, right
        4. 循环跟数组中间元素比较,大的放right,小的放left
        5. 递归回调: 对left,right 分别递归回调形成有序的数组后
        6. 最后,将有序的left pivot right 三部分 concat 起来

 var array = [6,5,3,1,8,7,2,4];
function quickSort(array) {
if (array.length <= 1) {
return array;
}
const pivotIndex = parseInt(array.length / 2);
const pivot = Number(array.splice(pivotIndex, 1));
const left = []; const right = [];
for (let i = 0; i < array.length; i++) {
if (array[i] < pivot) {
left.push(array[i]);
} else {
right.push(array[i]);
}
}
return quickSort(left).concat([pivot], quickSort(right));
};
console.log(array)

    (2). 插入排序:
      1). 直接插入排序 稳定
        1. 取无序序列的第一个最为有序序列
        2. 从第二个开始抓取,从有序序列的末尾开始向前找
        3. 如果 比较到的元素(有序序列中的元素)(array[j]) > 被比较的元素(要插入的元素)(key),则 将前者向后移动一个位置(array[j+1] = array[j])
        4. 如果 比较到的元素(有序序列中的元素)(array[j]) >= 被比较的元素(要插入的元素)(key),则 将后者放置前者的下一个位置处(array[j+1] = key)

         var array = [6,5,3,1,8,7,2,4];
for (let i = 1; i < array.length; i++) {
let key = array[i];
let j = i - 1;
while (j >= 0 && array[j] > key) {
array[j + 1] = array[j];
j--;
}
array[j + 1] = key;
}
console.log(array)

      2). 二分法插入排序
        1. 取无序序列第一个元素作为有序序列(即有序序列的起始)(有序序列:array[0]~array[i-1])
        2. 取下一个元素(array[i])作为被插入元素并做记录为 key
        3. 取有序序列的开始及结束位置的索引分别为 left 和 right
        4. 取有序序列的中间索引为 middle= Math.floor((left+right)/2)
        5. 将 middle 位置的元素 array[middle] 与 被插入元素 key 比较,
          如果 key > array[middle],便置 left = middle+1,
          反之 key > array[middle] ,则置 right = middle-1,
          直至 right < left 为止
          (此步骤为 二分查找 原理)
        6. 对从 left 到 key值元素所在位置索引 i-1 处之间的有序序列 array[left]~array[i-1] 与 key 两者之间采用 直接插入法 进行插入
        7. 重复以上步骤 2~6

         var array = [6,5,3,1,8,7,2,4];
for (let i = 1; i < array.length; i++) {
let key = array[i], left = 0, right = i - 1;
//console.log(i+'++'+key);
//console.log(left+'=='+right);
while (left <= right) {
let middle = parseInt((left + right) / 2);
//console.log(left+'=='+middle+'=='+right)
if (key < array[middle]) {
right = middle - 1;
} else {
left = middle + 1;
}
//console.log(left+'=='+right)
}
//console.log(array)
for (let j = i - 1; j >= left; j--) {
array[j + 1] = array[j];
//console.log(array)
}
array[left] = key;
//console.log(array)
}
console.log(array)

      3). 希尔排序 不稳定
        不太理解

         var arr=[49,38,65,97,76,13,27,49,55,4],
len=arr.length;
for(var fraction = Math.floor(len/2);fraction>0;fraction = Math.floor(fraction/2)){
for(var i=fraction;i<len;i++){
for(var j=i-fraction;j>=0&&arr[j]>arr[fraction+j];j-=fraction){
var temp=arr[j];
arr[j]=arr[fraction+j];
arr[fraction+j]=temp;
}
}
}
console.log(arr);

    (3). 选择排序:
      1). 简单选择排序 不稳定
        1. 取序列的第一个元素作为有序序列,并取该序列末尾索引位置为作参照,minIndex=0
        2. 从序列的第二个元素开始与 array[minIndex] 做比较,如果小就记该元素位置索引为 minIndex,
        3. 重复操作步骤2 直至再无更小元素为止,将此时的 minIndex 与有序序列的末尾元素互换
        (先从未排序序列中找出最小(大)元素,将该最小元素与序列的起始位置交换,至此 最小元素即到了有序元素的起始位置,
        然后 再从剩余的未排序序列中继续寻找最小(大)元素,依次与未排序序列中的起始位置互换,至此 次大的元素就依次放到了有序序列的末尾)

         var array = [6,5,3,1,8,7,2,4],
length = array.length;
for (let i = 0; i < length - 1; i++) {
let minIndex = i;
console.log(array[minIndex]);
for (let j = i + 1; j < length; j++) {
if (array[j] < array[minIndex]) {
minIndex = j;
}
}
let temp = array[i];
array[i] = array[minIndex];
array[minIndex] = temp;
console.log(array);
}
console.log(array)

      2). 堆排序 不稳定

    (4). 归并排序: 稳定
      1). 递归原理
        1. 利用递归将数组对半开分为 left,right 两个数组,直到每个拆分完的数组中只有一个元素为止,将每个数组视为有序数组
        2. 创建一个新的数组 newArray 来放排好序的元素
        3. 从每个数组的第一个元素开始拿来比较,往newArray里放,小的先放,大的后放
        注:步骤1 是递归进最里层,步骤3 是递归往外出,最后得到有序序列

             function mergeSort(array) {
if (array.length < 2) {
return array;
}
const middle = parseInt(array.length / 2);
const left = array.slice(0, middle);
const right = array.slice(middle);
return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right) {
const newArray = [];
while (left.length && right.length) {
if (left[0] <= right[0]) {
newArray.push(left.shift());
} else {
newArray.push(right.shift());
}
}
while (left.length) {
newArray.push(left.shift());
}
while (right.length) {
newArray.push(right.shift());
}
return newArray;
}

      2). 基数排序: 稳定
  2. 外部排序:
    (1). 计数排序 稳定
    (2). 桶排序 稳定

http://www.cnblogs.com/eniac12/p/5329396.html

http://www.cnblogs.com/eniac12/p/5332117.html

http://www.jianshu.com/p/96f5c19e13df

js 常用排序整理的更多相关文章

  1. js常用函数整理

    类型转换:parseInt\parseFloat\toString 类型判断:typeof;eg:if(typeof(var)!="undefined")\isNaN 字符处理函数 ...

  2. js常用代码整理

    引用js <script type="text/javascript" src="js/jquery-1.11.2.min.js"></scr ...

  3. js 常用排序

    1. 冒泡排序 原理:从第一个元素开始,把当前元素和下一个索引元素进行比较.如果当前元素大,那么就交换位置,重复操作直到比较到最后一个元素 function bubbleSort(arr) { if ...

  4. js常用正则整理

    个人博客: http://mcchen.club //校验是否全由数字组成 function isDigit(s) { var patrn=/^[0-9]{1,20}$/; if (!patrn.ex ...

  5. js 常用的比较排序算法总结

    每天学习一点点 编程PDF电子书.视频教程免费下载:http://www.shitanlife.com/code 一直很惧怕算法,总是感觉特别伤脑子,因此至今为止,几种基本的排序算法一直都不是很清楚, ...

  6. js数组学习整理

    原文地址:js数组学习整理 常用的js数组操作方法及原理 1.声明数组的方式 var colors = new Array();//空的数组 var colors = new Array(3); // ...

  7. Java常用排序算法+程序员必须掌握的8大排序算法+二分法查找法

    Java 常用排序算法/程序员必须掌握的 8大排序算法 本文由网络资料整理转载而来,如有问题,欢迎指正! 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排 ...

  8. JS正则表达式大全(整理详细且实用)

    JS正则表达式大全(整理详细且实用).需要的朋友可以过来参考下,希望对大家有所帮助!! 正则表达式中的特殊字符 字符 含意 \ 做为转意,即通常在"\"后面的字符不按原来意义解释, ...

  9. JS常用的标准函数

    原文:JS常用的标准函数 1.Array类型函数 array.concat(item...) 函数功能:关联数组,实现数组相加功能,但并不影响原先数组,concat返回新数组. array.join( ...

随机推荐

  1. STM32F0 中 ADC 多通道转换结果相同的问题

    前言 前段时间调试 STM32F030 的 ADC,在多通道转换时遇到了奇怪的问题,使用官方的例程和库函数连续转换多个 ADC 通道,得到的几个通道的结果是一样的,解决办法参考了 关于STM32F0系 ...

  2. 【Java】qatools.properties

    Link: https://github.com/qatools/properties 今天在GitHub上看到一个Java库,能方便帮助读取properties的配置文件. 具体使用可以参考上面的链 ...

  3. tp5 路由定义

    路由定义 | Route::rule('路由表达式','路由地址','请求类型'); > route 目录下的任何路由定义文件都是有效的,默认的路由定义文件是 route.php > 可以 ...

  4. rest-assured的xmlPath使用方法总结

    xmlPath的使用方法跟JsonPath的使用方法相近,下面简单总结一下: 准备xml文件数据: <records> <car name='HSV Maloo' make='Hol ...

  5. sql语句中变量的写法

        $sql = "update cat set num=num+1 where cat_id=$art[cat_id]";    $sql = "update ca ...

  6. TensorFlow-简单的卷积神经网络

    先弄懂卷积神经网络的原理,推荐这两篇博客:http://blog.csdn.net/yunpiao123456/article/details/52437794   http://blog.csdn. ...

  7. 微信小程序中如何使用setData修改数组或对象中的某一参数

    本人也是刚开始接触微信小程序,在微信小程序中经常会遇到修改数组中某一项的值,比如array[0]或者是对象中object.item的值.这些值在微信小程序中都需要使用一个名为setData的方法,而这 ...

  8. mysql PXC集群方案总结

    同时写集群内的所有机器 写性能依赖最慢的那个机器 读性能提高X倍

  9. 解决 TwebBrowser 不能隐藏的问题

    TOleControl(WebBrowser1).Visible := False

  10. 0前端 框架 库_千万别去碰js呀 混合APP_webAPP_美工 选有类型的语言,比如TypeScript

    常用知识点,技巧 添加库到本地: (举例 element-ui) 用npm命令行把包下载到本地 在电脑里找到资源文件,比如 C:\Users\XiaoCong\AppData\Roaming\npm\ ...