百度渣渣搜出来的都是c,c++,java版本,很少见简朴js版本,我恰好本身搞了一版,分享给你们
//1.冒泡排序
var exchange = function (a, i, j) // 交流A[i]和A[j]
{
var temp = a[i];
a[i] = a[j];
a[j] = temp;
}
var sort = function (a) {
var n = a.length;
for (var j = 0; j < n - 1; j++) // 每次最大元素就像气泡一样"浮"到数组的末了
{
for (var i = 0; i < n - 1 - j; i++) // 顺次比较相邻的两个元素,使较大的谁人向后移
{
if (a[i] > a[i + 1]) // 假如前提改成A[i] >= A[i + 1],则变成不稳固的排序算法
{
exchange(a, i, i + 1);
}
}
}
return a;
}
var a = [6, 5, 3, 1, 8, 7, 2, 4]; // 从小到大排序
// console.log(sort(a))
//------------2.挑选排序------------
var exchange = function (a, i, j) // 交流A[i]和A[j]
{
var temp = a[i];
a[i] = a[j];
a[j] = temp;
}
var selectSort = function (a) {
var n = a.length;
var i, j, min;
for (i = 0; i <= n - 2; i++) // 已排序序列的末端
{
min = i;
for (j = i + 1; j <= n - 1; j++) { // 未排序序列
if (a[j] < a[min])// 顺次找出未排序序列中的最小值,存放到已排序序列的末端
{
min = j;
}
}
if (min != i) {
exchange(a, min, i); // 该操纵很有可能把稳固性打乱,所以挑选排序是不稳固的排序算法
}
}
return a;
}
var a = [6, 5, 3, 1, 8, 7, 2, 4]; // 从小到大排序
console.log(selectSort(a))
//-----------3.插进去排序------------
var insertSort = function (a) {
var n = a.length;
var i, j, get;
for (i = 1; i < n; i++) // 相似抓扑克牌排序
{
get = a[i]; // 右手抓到一张扑克牌
j = i - 1; // 拿在左手上的牌老是排序好的
while (j >= 0 && a[j] > get) // 将抓到的牌与手牌从右向左举行比较
{
a[j + 1] = a[j]; // 假如该手牌比抓到的牌大,就将其右移
j--;
}
a[j + 1] = get;// 直到该手牌比抓到的牌小(或两者相称),将抓到的牌插进去到该手牌右侧(相称元素的相对序次未变,所以插进去排序是稳固的)
}
return a;
}
var a = [6, 5, 3, 1, 8, 7, 2, 4]; // 从小到大排序
console.log(insertSort(a))
//-----------4.shell排序------------
var shellSort = function (a) {
var n = a.length;
var i, j, get;
var h = 0;
while (h <= n) // 天生初始增量
{
h = 3 * h + 1;
}
while (h >= 1) {
for (i = h; i < n; i++) {
j = i - h;
get = a[i];
while ((j >= 0) && (a[j] > get)) {
a[j + h] = a[j];
j = j - h;
}
a[j + h] = get;
}
h = (h - 1) / 3; // 递减增量
}
return a;
}
var a = [6, 5, 3, 1, 8, 7, 2, 4]; // 从小到大排序
console.log(shellSort(a))
//-----------5.疾速排序----------------
var exchange = function (a, i, j) // 交流A[i]和A[j]
{
var temp = a[i];
a[i] = a[j];
a[j] = temp;
}
var partition = function (a, left, right) // 分别函数
{
var pivot = a[right]; // 挑选末了一个元素作为基准
var tail = left - 1; // tail为小于基准的子数组末了一个元素的索引
for (var i = left; i < right; i++) // 遍历基准之外的其他元素
{
if (a[i] <= pivot) // 把小于即是基准的元素放到前一个子数组中
{
tail++;
exchange(a, tail, i);
}
}
exchange(a, tail + 1, right); // 末了把基准放到前一个子数组的后边,剩下的子数组既是大于基准的子数组
// 该操纵很有可能把背面元素的稳固性打乱,所以疾速排序是不稳固的排序算法
return tail + 1; // 返回基准的索引
}
var quicksort = function (a, left, right) {
var pivot_index; // 基准的索引
if (left < right) {
pivot_index = partition(a, left, right);
quicksort(a, left, pivot_index - 1);
quicksort(a, pivot_index + 1, right);
}
return a;
}
var a = [6, 5, 3, 1, 8, 7, 2, 4]; // 从小到大排序
console.log(quicksort(a, 0, a.length - 1))