数据结构中各种排序方法综述（js实现）

新技术不断变化，一些基础是将来不断更新的技术的坚实基础，最近，为了重新利用JS在数据结构中的排序算法对数据结构进行审查，并在嵌入式演示的底层。

简单排序

冒泡排序

冒泡排序是最简单的排序算法，时间复杂度是n平方，代码如下所示：
功能的冒泡排序（阵列）{
对于（var i = 0；i < array.length；i++）{
对于（var j = array.length；J > 0；J—）{
如果（数组{ } <数组{ - 1 }）{
var数组= j - 1 }；
数组{ 1 } =数组{ }；
数组{ = } =温度；
}

}
输出
document.write（这是一个+（i + 1）+子循环。结果是：；
对于（var k = 0；K＜array.length；K+）{
document.write（数组{ } + K
}
document.write（）；
输出端
}
}
直接插入排序

直接插入排序也属于简单排序算法，时间复杂度为n平方，但性能略优于冒泡排序。代码如下：
函数插入排序（阵列）{
VaR的温度；
对于（var i = 1；i < array.length；i++）{
数组= { }；
对于（var j = i；j > 0个温度<数组{ 1 }；j -）{
数组{数组= j - 1 }；
}
数组{ = } =温度
输出
段的结果（+我+：）
对于（n = 0 n＜VaR；array.length；n + +）{
document.write（数组{ } +
}

document.write（）
输出端

}
}
选择排序

选择排序也属于简单排序算法，时间复杂度为n平方，性能略优于冒泡排序，代码如下：
功能选择排序（阵列）{
最小温度；；
对于（var i = 0；i < array.length；i++）{
min = i；
对于（var j = i + 1；J < array.length；j++）{
如果（数组{ } }，数组{ }）
min = j；
}
如果（最小）！= i）{
数组= { }；
数组{ } =数组{ }；
数组{ = } =温度；
}
输出
段的结果（+我+：）
对于（n = 0 n＜VaR；array.length；n + +）{
document.write（数组{ } +
}

document.write（）
输出端

}
}
复杂排序
Shell排序

Hill是升级排序插入排序，22，1959 Hill比较简单的排序和比较建立步跳过N平方的时间复杂度，Hill根据不同的时间步长的复杂性从nlogn的最佳和最差的N平方排序，代码如下：
功能shallsort（阵列）{
无功增量= array.length；
Var我
var临时变量
var计数= 0；
{做
增量= math.floor（增量 / 3）+ 1；
对（我=增量；i < array.length；i++）{
如果（数组{ } <数组{增量}）{
数组= { }；
对于（var j = i增量；j = 0温度<数组{ }；j =增量）{

数组{增量+ } =数组{ }；

}
数组{ +增量} =临时温度；
输出
计数+；
段的结果（+数+：）
对于（n = 0 n＜VaR；array.length；n + +）{
document.write（数组{ } +
}
输出端
}
}
}
当（增量> 1）

}
堆排序

堆排序是对排序的升级。我们通过选择堆和排序来选择最大或最小值以在队列前排建立顶值或最小值。时间每一个案件复杂度nlogn。代码如下：
功能排序（阵列）{
VaR的温度；
var i；
对（我= math.floor（array.length / 2）；我> = 0；我--）{
heapadjust（数组，我array.length - 1）； / /阵列构建成一个大的桩顶
}
对（我= array.length - 1；我> = 0；我--）{
根节点被交换出去了。
数组= { }；
数组{ } =数组{ 0 }；
数组{ 0 } =温度；

数组的其余部分构造为继续堆的大顶。
heapadjust（数组，0，我1）；
输出
document.write（结果+（array.length我）。ToString（）+万能是：）
对于（n = 0 n＜VaR；array.length；n + +）{
document.write（数组{ } +
}
输出端
}
}
子树调整
启动数组的下标数组。
max是数组结束下标。
功能heapadjust（数组的开始，max）{
变量，j；
数组= }，温度是根节点的值。
对于（j = 2 *开始；j < max；j = 2）{）{
如果（J Max <数组} <数组{ + 1 }）获得较大的孩子
++；

}
如果（数组= { }）
打破；
数组{ } =数组{ }；
启动= j；
}
数组{开始=温度；

}
归并排序

合并排序是复杂排序中唯一的稳定排序。排序是通过对有序数组进行排序来完成的。合并排序的时间复杂度为n平方。代码如下：

/ / / / dest来源目标阵列
启动下标
/ / T靶下标
功能很多（源，dest，S，T）{
中间值
VaR复用=新的数组（）；
如果（s = T）{
DeST {s} =源{ }；

}
{其他
M = math.floor（（S + T） / 2）；
MSort（源，复用，S，M）；
MSort（源，复用，M + 1，T）；
合并（复用，dest，S，M，T）；
输出
段的结果（+数+：）
对于（n = 0 n＜VaR；dest.length；n + +）{
document.write（数组{ } +
}
输出端
}

}

根据融合序列的两个数组
源原始数组
/ / dest排序后的数组
第一个下标
第二个数组下标
总长度
合并功能（源，dest，S，M，N）{
用于（var = m + 1，k = s；j < s＝m；k + +）{
如果（源< } <源> }）{
{ } = { DeST K源+ + }；
}
{其他
{ } = { DeST K源J++ }；
}
}

剩下的/命令一排排阵列添加到桌子底
如果（m）{
对于（var l = 0；l < = s；s + +）{
DeST { k+1 } = { }源+ L；
}
}
如果（j n）{
对于（var l＝0；l < n = j；l + +）{
DeST { k+1 } = { } + L源{J}.；
}

}
}
快速排序

快速排序是目前已知的速度最快的排序，时间复杂度nlogn，代码如下：
var计数= 0；
功能快速排序（阵列、低、高）{
VaR的温度；

如果（低<高）{

VaR的关键点= quicksorthelp（阵列、低、高）；
计数+；
document.write（台湾+数+节点，其中包括所有水果的排序是：）
对于（var = 0；L＜array.length；L + +）{
document.write（数组{ L } +
}
QuickSort（阵列、低，关键点1）；
QuickSort（数组，关键点+ 1，高）；
}
}
功能quicksorthelp（阵列、低、高）{
当（低<高）{

当（低高<数组{低} } =数组{ }）{
高；
}
数组= { }；
数组{ } =数组{ { }；
数组{；
当（低高<数组{低} } =数组{ }）{
低+ +
}
数组= { }；
数组{ } =数组{ { }；
数组{；

}
收益低；
}
所有上述数据结构排序方法综述（JS实现）是所有萧边分享你的内容。我希望能给你一个参考，希望你能支持它。