前端排序算法总结

最新推荐文章于 2023-07-11 11:29:50 发布
最新推荐文章于 2023-07-11 11:29:50 发布
阅读量1.7k 收藏 4
点赞数
分类专栏： 数据结构和算法 文章标签： 排序算法 前端 函数 大全 二分查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoxinhui521/article/details/77278354
版权

JS简单实现排序算法

归并排序
function merge(left, right) {
    var result = [];
    while(left.length > 0 && right.length > 0) {
        if(left[0] < right[0]) {
            result.push(left.shift());
        }
        else {
            result.push(right.shift());
        }
    }
    return result;
}
function mergeSort(arr){
    if(arr.length==1) {return arr};
    var mid=Math.floor(arr.length/2);
    var left_arr=arr.slice(0,mid),right_arr=arr.slice(mid);
    return merge(mergeSort(left_arr),mergeSort(right_arr));
}
堆排序
function AdjustHeap(arr, pos, len){
    var swap = arr[pos];     
    var child = pos * 2 + 1;  
    while(child < len){
        if(child + 1 < len && arr[child] < arr[child + 1]){
            child += 1;
        }
        if(arr[pos] < arr[child]){
            arr[pos] = arr[child];
            pos = child;
            child = pos * 2 + 1;
        }
        else{
            break;
        }
        arr[pos] = swap;
    }
}
function HeapSort(arr){
    for(var j=arr.length/2; j>=0; j--){
        AdjustHeap(arr, j, arr.length);
    }
    for(var i=arr.length-1; i>0; i--){  
        var swap = arr[i];  
        arr[i] = arr[0];
        arr[0] = swap;
        AdjustHeap(arr, 0, i); 
    }
}
快排
 function quickSort(arr){
    if(arr.length<=1){return arr;}
    var pivotIndex=Math.floor(arr.length/2);
    var pivot=arr.splice(pivotIndex,1)[0];
    var left=[];
    var right=[];
    for(var i=0;i<arr.length;i++){
        if(arr[i]<=pivot){
            left.push(arr[i]);
        }
        else{
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot],quickSort(right));
}

编写一个函数实现对Object，Array，Boolean，Number，String这五种主要数据类型进行值复制。

function clone(obj){
    var o;
    switch (typeof obj){
        case "undefined":
            break;
        case "string":
            o=obj+"";
            break;
        case "number":
            o=obj-0;
            break;
        case "boolean":
            o=obj;
            break;
        case "object":
            if(obj===null){
                o=null;
            } else {
                if(Object.prototype.toString.call(obj).slice(8,-1)==="Array"){
                    o=[];
                    for(var i=0;i<obj.length;i++){
                        o.push(clone(obj[i]));
                    }
                } else {
                    o={};
                    for(var k in obj){
                        o[k] = clone(obj[k]);
                    }
                }
            }
            break;
        default:
            o = obj;
            break;
    }
    return o;
}

冒泡排序

function BubbleSort1(arr) {
    var i,j;
    for(var i=0;i<arr.length-1;i++){
        for(var j=arr.length-1;j>=i;j--){
            if(arr[j-1]>arr[j]){
                var temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;
            }
        }
    }
    return arr;
}
//改进冒泡
function BubbleSort2(arr) {
    var i,j;
    var flag=true;
    for(var i=0;i<arr.length-1  && flag;i++){
        flag=false;
        for(var j=arr.length-1;j>=i;j--){
            if(arr[j-1]>arr[j]){
                var temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;
                flag=true;
            }
        }
    }
    return arr;
}
//选择排序
function SelectSort(arr) {
    var i,j,min;
    for(var i=0;i<arr.length-1;i++){
        min=i;
        for(var j=i+1;j<arr.length;j++){
            if(arr[min]>arr[j])
                min=j;
        }
        if(i!=min){
            var temp=arr[min];
            arr[min]=arr[i];
            arr[i]=temp;
        }
    }
    return arr;
}
//直接插入排序
function InsertSort(arr) {
    var i,j;
    for(var i=1;i<arr.length;i++){
        if(arr[i]<arr[i-1]){
            var temp=arr[i];
            for (var j=i-1;arr[j]>temp;j--){
                arr[j+1]=arr[j];
            }
            arr[j+1]=temp;
        }
    }
    return arr;
}
//插入排序
function insertionSort(arr) {
    for(var i=1;i<arr.length;i++){
        key=arr[i];
        var j=i-1;
        while ( j>=0 && arr[j]>key){
            arr[j+1]=arr[j];
            j=j-1;
        }
        arr[j+1]=key;
    }
    return arr;
}
//希尔排序
function ShellSort(arr) {
    var i,j;
    var increment=arr.length;
    while (increment>1){
        increment=Math.floor(increment/3)+1;
        for(i=increment;i<arr.length;i++){
            if(arr[i]<arr[i-increment]){
                var tmp=arr[i];
                for(j=i-increment;j>=0&&tmp<arr[j];j-=increment){
                    arr[j+increment]=arr[j];
                }
                arr[j+increment]=tmp;
            }
        }
    }
    return arr;
}
//堆排序
function HeapSort(arr) {
    var i;
    for(i=Math.floor(arr.length/2);i>=0;i--){
        HeapAjust(arr,i,arr.length);
    }
    for (i=arr.length-1;i>0;i--){
        var temp=arr[0];
        arr[0]=arr[i];
        arr[i]=temp;
        HeapAjust(arr,0,i-1);
    }
    return arr;
}
function HeapAjust(arr,s,m) {
    var temp;
    temp=arr[s];
    for(var j=2*s;j<=m;j*=2){
        if((j<m) && (arr[j]<arr[j+1])){
            ++j;
        }
        if(temp>=arr[j]){
            break;
        }
        arr[s]=arr[j];
        s=j;
    }
    arr[s]=temp;

}
//归并排序 递归方式
function mergeSort(arr){
    var len = arr.length;
    if(len > 1){
        var index = Math.floor(len / 2);
        var left = arr.slice(0, index), right = arr.slice(index);
        return merge(mergeSort(left), mergeSort(right));
    }else{
        return arr;
    }
}
function merge(left, right){
    var arr = [];
    while(left.length && right.length){
        if(left[0] < right[0]){
            arr.push(left.shift());
        }else{
            arr.push(right.shift());
        }
    }
    return arr.concat(left, right);
}
//归并排序
//大辉版
function MergeSort(arr) {
    MSort(arr,arr,0,arr.length-1);
}
function MergeSort(arr) {
    MSort(arr,0,arr.length-1);
    return arr;
}
//将SR归并排序为result
function MSort(arr,s,t) {

    if(s==t){
        return;
    } else {
        var m=Math.floor((s+t)/2);
        MSort(arr,s,m);
        MSort(arr,m+1,t);
        Merge(arr,s,m,t);
    }
}
//SR源数组，SR[i,m],SR[m+1,n]组合为TR[i,n]
function Merge(arr,left,mid,right) {
    var i,j,k;
    var temp=[];
    i=left;
    j=mid+1;
    k=0;
    while(i<=mid&&j<=right){
        if(arr[i]<arr[j]){
            temp[k++]=arr[i++];
        } else {
            temp[k++]=arr[j++];
        }
    }

    while(i<=mid){
        temp[k++]=arr[i++];
    }
    while(j<=right){
        temp[k++]=arr[j++];
    }

    k=0;
    for(i=left;i<=right;i++){
        arr[i]=temp[k++];
    }
}


//归并排序 课本递归版
function MergeSort(arr) {
    var TR1=[];
    MSort(arr,TR1,0,arr.length-1);
    return TR1;
}
//将SR归并排序为result
function MSort(SR,TR1,s,t) {
    var m;
    var TR2=[];
    if(s==t){
        TR1[s]=SR[s];
    } else {
        var m=Math.floor((s+t)/2);
        MSort(SR,TR2,s,m);
        MSort(SR,TR2,m+1,t);
        Merge(TR2,TR1,s,m,t);
    }
}
//SR源数组，SR[i,m],SR[m+1,n]组合为TR[i,n]
function Merge(SR,TR,i,m,n) {
    var j,l;
    var k=0;
    for(j=m+1,k=i;i<=m&&j<=n;k++){
        if(SR[i]<SR[j]){
            TR[k]=SR[i++];
        } else {
            TR[k]=SR[j++];
        }
    }
    if(i<=m){
        for(l=0;l<=m-i;l++){
            TR[k+l]=SR[i+l];
        }
    }
    if(j<=n){
        for(l=0;l<=n-j;l++){
            TR[k+l]=SR[j+l];
        }
    }
    // return TR;
}
//归并排序 课本非递归版
function MergeSort2(arr) {
var TR=[];
var k=1;
while (k<arr.length){
    MergePass(arr,TR,k,arr.length);
    k=2*k;
    MergePass(TR,arr,k,arr.length);
    k=2*k;
}
return arr;
}
function MergePass(SR,TR,s,n) {
    var i=0;
    var j;
    while (i<=n-2*s){
        Merge(SR,TR,i,i+s-1,i+2*s-1);
        i=i+2*s;
    }
    if(i<n-s){
        Merge(SR,TR,i,i+s-1,n-1);
    } else {
        for(j=i;j<=n-1;j++){
            TR[j]=SR[j];
        }
    }
}
function Merge(SR,TR,i,m,n) {
    var j,l;
    var k=0;
    for(j=m+1,k=i;i<=m&&j<=n;k++){
        if(SR[i]<SR[j]){
            TR[k]=SR[i++];
        } else {
            TR[k]=SR[j++];
        }
    }
    if(i<=m){
        for(l=0;l<=m-i;l++){
            TR[k+l]=SR[i+l];
        }
    }
    if(j<=n){
        for(l=0;l<=n-j;l++){
            TR[k+l]=SR[j+l];
        }
    }
}
//快排 课本版
function QuickSort(arr){
    if(arr.length <= 1){
        return arr;
    }
    // 从中间取一个数
    var index = Math.floor(arr.length / 2);
    // 被选中的一个数
    //arr.splice返回的是一个数组
    var key = arr.splice(index, 1)[0];
    var left = [], right = [];
    for(var i = 0; i < arr.length; i++){
        if(arr[i] < key){
            left.push(arr[i]);
        }else{
            right.push(arr[i]);
        }
    }
    return QuickSort(left).concat(key, QuickSort(right));
}
// console.log(QuickSort([2,1,5,3,7,4,8,6,9]));


function QuickSort(arr) {
    QSort(arr,0,arr.length-1);
    return arr;
}
//对序列表中子序列作快排
function QSort(arr,low,high) {
    var pivot;
    if(low<high){
        pivot=Partion(arr,low,high);
        QSort(arr,low,pivot-1);
        QSort(arr,pivot+1,high);
    }
}
//返回枢轴所在位置
function Partion(arr,low,high) {
    pivotkey=arr[low];
    while (low<high){
        while (low<high&&arr[high]>=pivotkey){
            high--;
        }
        var temp=arr[low];
        arr[low]=arr[high];
        arr[high]=temp;
        while (low<high&&arr[low]<=pivotkey){
            low++;
        }
        var temp=arr[low];
        arr[low]=arr[high];
        arr[high]=temp;
    }
    return low;
}

//快排优化
function QuickSort(arr) {
    QSort(arr,0,arr.length-1);
    return arr;
}
//对序列表中子序列作快排
function QSort(arr,low,high) {
    var pivot;
    if(low<high){
        pivot=Partion(arr,low,high);
        QSort(arr,low,pivot-1);
        QSort(arr,pivot+1,high);
    }
}
//返回枢轴所在位置
function Partion(arr,low,high) {
    var pivotkey;
    var m=low+(high-low)/2;
    if(arr[low]>arr[high]){
        var temp=arr[low];
        arr[low]=arr[high];
        arr[high]=temp;
    }
    if(arr[m]>arr[high]){
        var temp=arr[high];
        arr[high]=arr[m];
        arr[m]=temp;
    }
    if(arr[m]>arr[low]){
        var temp=arr[low];
        arr[low]=arr[m];
        arr[m]=temp;
    }
    pivotkey=arr[low];
    while (low<high){
        while (low<high&&arr[high]>=pivotkey){
            high--;
        }
        var temp=arr[low];
        arr[low]=arr[high];
        arr[high]=temp;
        while (low<high&&arr[low]<=pivotkey){
            low++;
        }
        var temp=arr[low];
        arr[low]=arr[high];
        arr[high]=temp;
    }
    return low;
}
//再优化
function QuickSort(arr) {
    QSort(arr,0,arr.length-1);
    return arr;
}
//对序列表中子序列作快排
function QSort(arr,low,high) {
    var pivot;
    if(low<high){
        pivot=Partion(arr,low,high);
        QSort(arr,low,pivot-1);
        QSort(arr,pivot+1,high);
    }
}
//返回枢轴所在位置
function Partion(arr,low,high) {
    var pivotkey;
    var m=low+(high-low)/2;
    if(arr[low]>arr[high]){
        var temp=arr[low];
        arr[low]=arr[high];
        arr[high]=temp;
    }
    if(arr[m]>arr[high]){
        var temp=arr[high];
        arr[high]=arr[m];
        arr[m]=temp;
    }
    if(arr[m]>arr[low]){
        var temp=arr[low];
        arr[low]=arr[m];
        arr[m]=temp;
    }
    pivotkey=arr[low];
    var num=pivotkey;
    while (low<high){
        while (low<high&&arr[high]>=pivotkey){
            high--;
        }
        arr[low]=arr[high];
        while (low<high&&arr[low]<=pivotkey){
            low++;
        }
        arr[high]=arr[low];
    }
    arr[low]=num;
    return low;
}

二分查找

递归实现

function search(arr,low,high, key) {
    var mid = parseInt((high + low) / 2);
    if(arr[mid] == key){
        return mid;
    }else if (arr[mid] > key){
        high = mid - 1;
        return binary_search(arr, low, high, key);
    }else if (arr[mid] < key){
        low = mid + 1;
        return binary_search(arr, low, high, key);
    }
}

非递归实现

function search(arr,key) {
    var low,mid,high;
    low=0;
    high=arr.length;
    while (low<=high){
        mid=parseInt(low+high)/2;
        if(key<a[mid]){
            high=mid-1;
        } else if (key>a[mid]){
            low=mid+1;
        }
        else
            return mid;
    }
}
奔跑的前端er
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
利用前端动画实现算法可视化，比如各种排序算法动画实现.zip
06-01
利用前端动画实现算法可视化，比如各种排序算法动画实现.zip
JS实现快速排序，冒泡排序
weixin_30794491的博客
08-20 94
JS-排序详解-冒泡排序 说明 时间复杂度指的是一个算法执行所耗费的时间 空间复杂度指运行完一个程序所需内存的大小 稳定指，如果a=b,a在b的前面，排序后a仍然在b的前面 不稳定指，如果a=b，a在b的前面，排序后可能会交换位置 JS冒泡排序 原理 依次比较相邻的两个值，如果后面的比前面的小，则将小的元素排到前面。依照这个规则进行多次并且递减的迭代，直到顺序...
讲讲快速排序
weixin_45948019的博客
02-11 106
由chatGPT生成的一段内容
前端常见的排序算法
weixin_44761091的博客
04-11 5388
文章目录1.冒泡排序2.快速排序3.插入排序4.选择排序5.归并排序6.希尔排序7.计数排序8.基数排序 1.冒泡排序 基本思想：重复遍历要排序的数组，每次比较相邻两个元素的大小，如果顺序错误，则交换两个元素的位置 步骤： 比较相邻两个元素，如果位置不对交换两个元素 对每一对相邻的元素重读步骤1，直到最后，把最大（小）元素冒泡的最后一个位置 针对所有（除最后一个）元素，重复步骤1，2 重复步骤1，2，3，直到排序完成 代码实现： function bubbleSort (arr) { let len
【前端面试必读】js排序的几种方法
A_soulmate的博客
02-07 2274
1.冒泡排序 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 function bSort(arr) { var len = arr.length; for (var i = 0; i < len-1; i++) { for (var j = 0; j <
【Vue2.0学习】— 列表排序（四十一）
道阻且长，行则将至。
10-16 1049
从小到大排列（升序排列）从大到小排列（降序排列）
前端面试算法题1
08-03
问题四：冒泡排序问题五：快速排序2017/5/9 下午4:06前端算法面试题第2页 共5页问题六：不借助临时变量，进行两个整数的交换问题七：找出下列正数组的最大
flutter-使用flutter开发的web前端-用于展示排序算法原理.zip
最新发布
03-10
flutter flutter_使用flutter开发的web前端_用于展示排序算法原理
总结在前端排序中遇到的问题
12-10
貌似前端圈一直以来流传着一种误解：前端用不到算法知识。长久以来，大家或许都曾受这种说法的影响。直到前阵子遇到一个产品需求，回过头...排序算法 感觉这个没什么介绍的必要，作为计算机科学的一种基础算法，描述就
【排序算法】-常见的排序算法
05-08
【排序算法】-常见的排序算法
JS前端列表排序
06-08
JS前端列表排序，封装好的组件，解放后台数据列表的排序。
前端自定义列表排序
weixin_48414904的博客
07-05 1428
前端自定义排序
前端实现列表排序 (时间 名称 升序 降序)
张一西的博客
10-30 4963
function pcompare(prop,rev) { // 第二个参数没有传递，默认升序排序 if(rev === undefined) { rev = 1; }else { rev = rev ? 1: -1; } return function(obj1,obj2) { // 方括号.
前端JS实现八大排序（含原理及改进）
m0_52711377的博客
01-20 1361
冒泡排序 原理 两相邻的数依次比较 若从小到大排列两两比较时前一个数比后一个数大互换位置 相互比较完一轮最大的数就会到最后面，并且不再参与比较 循环比较 直到比较完成 一张网图 实现 ...
前端需要掌握的十大排序算法
廖龙东个人博客
06-13 743
选择排序（Selection Sort）是一种简单直观的排序算法，它的原理是每一轮从待排序的元素中选择最小（或最大）的元素，将其与序列中的第一个元素交换位置，然后再从剩下的元素中选择最小（或最大）的元素，与序列中的第二个元素交换位置，以此类推，直到整个序列有序。归并排序是一种分治算法，通过将数组分成较小的子数组并对它们进行排序，然后再将排好序的子数组进行合并，从而实现整体的排序。在最坏情况下，时间复杂度为O(n^2)，但快速排序的平均时间复杂度较低，因此它通常被认为是一种高效的排序算法。
前端需要了解的一些排序方法总结
weixin_44953633的博客
05-09 757
前端需要了解的一些排序方法总结 1. 冒泡排序 含义：冒泡排序是一种很常见的排序方法，其本质就是比较相邻的元素大小，把相对小的往前排，对从开头的每一组元素都进行比较，并不断重复这个过程。 其js代码如下： function BubbleSort(arr){ var len = arr.length; for(let i = 0; i < len-1; i++){ //从第一组开始比较 for (let j = 0; j < len-1-i; j++){ if(arr[j] &
Vue+element-UI实现列表排序（sortable、custom）
coinisi_li的博客
07-11 5522
只能实现当前页数据的排序，无法实现整张表全部数据的排序，所以需要采取自定义的排序方式重新触发接口，获取排序好的全部列表。属性：当你需要自定义排序逻辑，例如根据特定字段进行复杂的排序，或者需要对非字符串和数字类型的数据进行排序时，可以使用。当用户点击表头的排序按钮时，表格会自动按照该列的值进行升序或降序排序。属性：当你的表格数据是简单的字符串或数字类型，并且你只需要对列进行普通的升序或降序排序时，可以使用。事件，在事件回调中可以获取当前排序的字段名和排序顺序，从而向接口请求排序后的表格数据。
js 中 中文、空格、数字、字符串混合排序
m0_38125257的博客
03-11 4475
js 中 中文、空格、数字、字符串混合排序 // 调用： var goods = [ {'goodSn': 'x02','goodName': '牛仔裤z', 'price': '178'}, {'goodSn': 'a03','goodName': '直三正品拖鞋', 'price': '78'}, {'goodSn': 'a04','goodName': '哈哈', 'price': '78'}, {'goodSn': 'a05','goodName': '#', 'price': '78'}, {'g
前端常用排序算法
Yu_Jian_Qt的博客
11-16 886
1、sort排序 js内置方法，使用如果数组成员不是数字类型，也可以返回一个回调，用于自定义条件判断排序。 let list = [2,34,1,567,34,33,21,2,0,342,1,111,78]; let resList = list.sort(function(a,b) { return a-b; }); console.log(resList); //[0, 1, 1, 2, 2, 21, 33, 34, 34, 78, 111, 342, 567] 2、冒泡排序 嵌套循环，比较相邻两个
生成前端排序算法的代码
07-25
当提到前端排序算法的代码时，常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序等。我将为你提供一个示例代码，展示如何使用JavaScript实现快速排序算法： ```javascript // 快速排序函数 function ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值