常见的Javaｓｃｒｉｐｔ实现算法（如冒泡、快速、鸽巢、奇偶等）
复制代码代码如下所示：l { 6, 2, 4，1, 98, 34，5, 9, 23，8, 10, 32 }
冒泡排序
/ *功能冒泡排序（ARR）{
arr.slice newarr =（）
如果（newarr.length 2）返回newarr
对于（var i = 0；i < newarr.length - 1；i++）{
对于（var j = 0；J < newarr.length -我- 1；j++）{
如果（newarr { J } > newarr { j + 1 }）{
{ } = { newarr {J}. newarr { j + 1 }，{ 1 } newarr J + = newarr { J } } { 0 }
}
}
}
返回newarr
}
console.log（L）
结果：冒泡排序（L）
console.log（结果）。
快速排序
/ *功能快速排序（ARR）{
如果（arr.length 1）报酬；
var左}，
右= }，
中间= }；
VaR中= ARR { math.floor（arr.length / 2）}
对于（var i = 0；i < arr.length；i++）{
如果（ARR {我} <中）{
Left.push（ARR {我}）；
别的}如果（ARR {我} >中）{
Right.push（ARR {我}）；
{人}
Middle.push（中）；
}
}
返回{ } .concat（快速排序（左），中间，快速排序（右））
}
VaR结果= quicksort（L）
console.log（结果）
* /
选择类
/ *功能选择排序（ARR）{
最小值＝9999，
极小指标= 0；
var左}，
arr.slice（右）；
如果（arr.length 1）报酬；
对于（var i = 0；i < arr.length；i++）{
如果（ARR {我}分钟）{
min = ARR {我}；
极小指标=我；
}
}
Left.push（min）；
right.splice（极小指标，1）；
返回{ } .concat（左，selectSort（右））
}
VaR结果=选择排序（L）
console.log（结果）。
插入排序
/ *功能插入排序（ARR）{
VaR TMP；
对于（var i = 1；i < arr.length；i++）{
TMP = ARR {我}；
对于（var j = i；j 0；j -）{
如果（ARR { 1 } >，TMP）{
ARR { } = { J J ARR 1 }；
{人}
打破；
}
}
ARR { } = TMP {J}.；
}
报酬；
}
VaR结果=插入排序（L）
console.log（结果）。
排序
/ *功能桶排序（ARR）{
变量桶{ }；
var newarr = { }；
对于（var i = 0；i < arr.length；i++）{
{ } } {我斗ARR = ARR {我}；
}
对于（var i = 0；i < bucket.length；i++）{
如果（桶{ }）！=未定义的）{
Newarr.push（斗{我}）
}
}
返回newarr；
}
VaR结果=桶排序（L）
console.log（结果）。
/ /归档整理，非负整数
/ *功能pigeonholesort（ARR）{
无功temparr = { }；
对于（var i = 0，L = arr.length；i < L；i++）{
temparr { } } = {我ARR（temparr { } } {我度+ 1）| | 1；
}
var结果，{，}，计数；
对于（var k = 0；K＜temparr.length；K+）{
数= temparr {K }；
如果（计数）{
对于（var i = 0；i <计数；i + +）{
result.push（K）；
}
}
}
返回结果；
}
VaR结果= pigeonholesort（L）
console.log（结果）。
合并排序
/ *功能归并排序（ARR）{
如果（arr.length 1）报酬；
VaR中= math.floor（arr.length / 2）；
VaR左= mergeSort（arr.slice（0中））；
VaR对=归并（arr.slice（中））；
var结果{ }；
而（left.length权。长度）{
如果（左{ 1 } left.length <=右{ 0 }）{
结果：result.concat（左）；
左= }；
如果（右{ 1 } } right.length <左{ 0 }）{
结果：result.concat（右）；
右= }；
{人}
如果（右{ 0 } <左{ 0 }）{
result.push（right.shift（））；
{人}
result.push（left.shift（））；
}
}
}
结果：result.concat（左，右）；
返回结果；
}
/ *功能归并排序（ARR）{
var合并=函数（左，右）{
var结果{ }；
而（left.length > 0 right.length > 0）{
如果（左{ 0 } <右{ 0 }）{
result.push（left.shift（））；
{人}
result.push（right.shift（））；
}
}
返回result.concat（左）Concat（右）；
}
如果（arr.length = = 1）报酬；
VaR中= math.floor（arr.length / 2），
左= arr.slice（0中），
右= arr.slice（中）；
合并的收益（mergeSort（左），归并排序（右））；
}
VaR结果= mergeSort（L）
console.log（结果）
* /
堆排序
/ *功能排序（ARR）{
无功findroot =功能（ARR，P，长度）{
P = P | | 0；
长度=长arr.length | |；
自arguments.callee VaR；
var = P * 2 + 1；
var =（p + 1）* 2；
左，右；
如果（L＜长度）左=自我（ARR，L，长度）；
如果（R＜长度）右=自我（ARR，r，长度）；
如果（左> ARR { } { } P）P = {左ARR，ARR {我} = { } }数组p { 0 }；
如果（右> ARR { p } { } = { p）改编权，ARR {红} = { } }，{ 0 } P；
报酬{ p }；
}；
对于（var i = arr.length；我> 0；我--）{
FindRoot（ARR，0，我）；
{ 1 }被我= { ARR { 0 }，{ 0 } = { ARR ARR我- 1 } } { 0 }；
}
报酬；
}
VaR结果=堆排序（L）
console.log（结果）。
奇偶校验排列
/ *功能oddevensort（ARR）{
var换=真，
k＝0；
而（换）{
如果（K＞0）换= false；
对于（var i = K；我< arr.length - 1；I = 2）{
如果（ARR {我} { 1 }我> ARR）{
ARR {我} = { 1 } {我+ ARR，ARR {我+ 1 } = {我} }，{ 0 }；
换=真；
}
}
k = { 1, 0 } }
}
报酬；
}
VaR结果= oddevensort（L）
console.log（结果）。
功能oddevensort（ARR）{
var换=真；
而（换）{
换= false；
对于（var i = 0；i < arr.length；i = 2）{
如果（ARR {我} { 1 }我> ARR）{
ARR {我} = { 1 } {我+ ARR，ARR {我+ 1 } = {我} }，{ 0 }；
换=真；
}
}
对于（var i = 1；i < arr.length；i = 2）{
如果（ARR {我} { 1 }我> ARR）{
ARR {我} = { 1 } {我+ ARR，ARR {我+ 1 } = {我} }，{ 0 }；
换=真；
}
}
}
报酬；
}
VaR结果= oddevensort（L）
console.log（结果）