精华内容
下载资源
问答
  • <script> vararr2=[9,88,67,24,39,74,28];...//sort排序 arr2.sort(function(a,b){ returna-b }) console.log(arr2); //冒泡排序 for(vari=0;i<arr2.length;i++){ for(vark=0;k<arr2.le...

    <script>

         var arr2 = [9, 88, 67, 24, 39, 74, 28];

        //sort排序

        arr2.sort(function(a,b){

            return a-b

        })

        console.log(arr2);

        //冒泡排序

        for (var i = 0; i < arr2.length; i++) {

            for (var k = 0; k < arr2.length; k++) {

                if (arr2[k] > arr2[k + 1]) {

                    var temp = arr2[k]

                    arr2[k] = arr2[k + 1]

                    arr2[k + 1] = temp

                }

            }

        }

        console.log(arr2);

        //选择排序

            for(var i = 0;i<arr2.length;i++){//比较的轮数

                for(var j = i+1;j<arr2.length;j++){//每轮比较的次数

                    if(arr2[i]>arr2[j]){

                        var temp = arr2[i]

                        arr2[i] = arr2[j]

                        arr2[j] = temp

                    }

                }

            }

            console.log(arr2)

        //插入排序

        var arr = [23, 11, 3, 12, 4, 6, 42];

        for (let i = 0; i < arr.length-1; i++) {

            for(var j  = i+1;j>=0;j--){

                if (arr[j]<arr[j-1]) {

                    var temp = arr[j-1];

                    arr[j-1] = arr[j];

                    arr[j] = temp;

                }

            }   

        }

        console.log(arr);

    </script>

    展开全文
  • 有时候我们做项目的时候往往会需要把数组里面一些重复的项去掉,但是原生JS排序,有筛选等等,但是就是没有数组去重怎么办呢? 这能怎么办,自己手动实现嘛。 数组不像对象和hash有唯一的标志特征(key)。所以,...
  • js数组排序几种方法

    千次阅读 2019-10-23 10:24:19
    是的大的元素放到后边,元素交换位置,从而一步步的交换元素的位置,使得最大的元素放到数组的末尾,这样内部的循环就进行了一轮,再根据外部的循环依次再把次大一点的元素放到数组的末尾,从而实现数组的逐步排序。...

    1、冒泡排序

    以从小到大排序为例,冒泡排序的原理就是通过两层循环把数组中两两相邻的元素进行比较,是的大的元素放到后边,元素交换位置,从而一步步的交换元素的位置,使得最大的元素放到数组的末尾,这样内部的循环就进行了一轮,再根据外部的循环依次再把次大一点的元素放到数组的末尾,从而实现数组的逐步排序。代码如下:

    // 冒泡排序
    var arr = [52,3,8,57,75,2,1];
    for (var i = 0; i<arr.length; i++) {
    	for (var j =0;j<arr.length-i; j++) {
    		if(arr[j]>arr[j+1]){
    			var temp = arr[j];
    			arr[j]=arr[j+1];
    			arr[j+1]=temp; 
    		}
    	}
    }
    console.log(arr); //[1, 2, 3, 8, 52, 57, 75]

    这里面通过一个变量temp实现相邻两个元素的位置替换,从而循环一轮使得最大的元素放到数组的末尾。

    2、快速排序

    快速排序是运用递归进行循环调用函数从而使得数组进行排序,代码如下:

    // 快速排序
    function quickSort(arr){
      if(arr.length <= 1) return arr;
      var Temp = Math.floor(arr.length/2);
      var left = [],right = [];
      var num = arr.splice(Temp,1)[0];
      for(var i = 0;i < arr.length;i ++){
        if(arr[i] < num){
          left.push(arr[i]);
        }
        else {
          right.push(arr[i]);
        }
      }
      return quickSort(left).concat(num,quickSort(right));
    }
    var arr=[5,2,1,10,8,12,40,26,30];
    console.log(quickSort(arr)); //[1, 2, 5, 8, 10, 12, 26, 30, 40]

    其原理是首先创建一个递归函数,也就是函数的返回值还是函数本身,直到符合条件之后递归函数停止运行,像这个函数就是当时arr数组的长度小于等于1的时候该递归函数停止运行。基本原理就是先找到数组中的中间那个元素的索引,如果数组长度是双数,那么就默认向上取值,也就是默认取数组长度/2+1位索引,在根据索引去的数组中间的值,然后创建两个空数组,用来放置比该元素小的值和比该元素大的值,在循环数组进行判断,如果数组的元素小于该中间位置元素的值,就放到左边数组,反之放到右边的数组,在函数中返回值设置为左边数组+中间的值+右边数组的拼接新数组,然后再根据递归对左边和右边的数组分别进行刚才的操作,直到数组的长度小于或者等于1,这时候停止,这时候调用函数之后,传入一个数组,就会自动返回数组排序之后的新数组,这就是快速排序的原理。

    3、sort排序

    // sort排序
    var arr=[8,12,312,4,5];
    function sortArray(n1,n2){
        return n1-n2;
    }
    arr.sort(sortArray); 
    console.log(arr) //[4, 5, 8, 12, 312]

    sort默认排序是按照字符来排序的,也就是ascii字母排序的,如果想要改变默认的排序方式,就要给他加一个自定义排序规则

    function sortArray(n1,n2){
        return n1-n2;
    }

    这个函数的意思是:若 n1小于 n2,即 n1-n2  小于零,则返回一个小于零的值,数组将按照升序排列。

    function sortArray(n1,n2){
        return n2-n1;
    }

    这个函数的意思是:若 n1 大于 n2, 即 n1 - n2 大于零,则返回一个大于零的值,数组将按照降序排列。

    4、选择排序

    选择排序原理就是选择出数组中最大或者是最小的数放到最前面,然后在一次循环,选择次一级最大或者最小的数,从而得到想要的排序数组。

    // 选择排序
    var arr = [14, 82, 7, 1, 9, 0];
    for(var i = 0; i < arr.length - 1; i++){
        for(var j = i + 1; j < arr.length; j++){
            if(arr[i] > arr[j]){
                var tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
     }
    console.log(arr);//[0, 1, 7, 9, 14, 82]

    选择排序也是运用中间变量的方法进行了数组元素位置的变换,从而使得最大或者最小的的元素一次从前向后排列。

    展开全文
  • 1.Javascript的sort方法,本方法的原理是冒泡排序,这里默认从小到大排序 <script> var arr = [23,13,34,65,65,45,89,13,1]; var newArr = arr.sort(function(a,b){ return a - b; }); console.log...

    下面主要介绍了数组排序的五种方式——sort()方法、选择排序、冒泡排序、插入排序和快速排序

    刚兴趣的朋友,可以往下看哦。

    1.js中的sort()方法

    基本思想:根据提供的排序规则,对数组元素进行排序。
                      使用数字排序,必须通过一个函数作为参数来调用。

    var arr = [123,203,23,13,34,65,65,45,89,13,1];
    function func(a,b){
    	return a-b;
    }
    console.log(arr.sort(func)); //(11) [1, 13, 13, 23, 34, 45, 65, 65, 89, 123, 203]

    2.选择排序

    基本思想:首先在未排序数组中找到最小(大)元素,存放在数组的起始位置。
                      再从剩余数组元素中继续寻找最小(大)元素,返回放在已排序数组的末尾
                      重复第二步,直到所有元素都排序完成
    动画演示:

    var arr = [123,203,23,13,34,65,65,45,89,13,1];
    for(var i=0;i<arr.length;i++){
    	for(var j=i+1;j<arr.length;j++){
    		//如果第一个比第二个大,就交换他们两个位置
    		if(arr[i]>arr[j]){
    			var temp = arr[i];
    			arr[i] = arr[j];
    			arr[j] = temp;
    		}
    	}
    }
    console.log(arr); //(11) [1, 13, 13, 23, 34, 45, 65, 65, 89, 123, 203]

    3.冒泡排序

    基本思想:一次比较两个相邻的数,如果不符合规则互换位置,一次比较就能够将最大或最小的值放在数组最后一位
                      继续对除【最后一位】之外的所有元素重复上述过程
    动画演示:

    var arr = [123,203,23,13,34,65,65,45,89,13,1];
    for(var i=0; i<arr.length-1; i++){
    	//每一轮比较要比多少次
    	for(var j=0; j<arr.length-1-i; j++){
    	    //如果第一个比第二个大,就交换他们两个位置
    	    if(arr[j]>arr[j+1]){
    	        var temp = arr[j];
    	        arr[j] = arr[j+1];
    	        arr[j+1] = temp;
    	    }
    	}    
    }
    console.log(arr); //(11) [1, 13, 13, 23, 34, 45, 65, 65, 89, 123, 203]

    4.插入排序

    基本思想:将数组第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。
                      从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。
                      如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。
    动画演示:

    var arr = [123,203,23,13,34,65,65,45,89,13,1];
    var preIndex, current;
    for(var i=1;i<arr.length;i++){
    	preIndex = i-1;
    	current = arr[i];
    	while(preIndex>=0 && arr[preIndex]>current) {
    	    arr[preIndex+1] = arr[preIndex];
    	    preIndex--;
    	}
    	arr[preIndex+1] = current;
    }
    console.log(arr); //(11) [1, 13, 13, 23, 34, 45, 65, 65, 89, 123, 203]

    5.快速排序(依托递归函数)

    基本思想:在已知数据集合中随便去一个基准(pivot)
                      将其余数据以基准为中心,大于分放右边,小于的放左边
                      将左右两个子集重复以上两个步骤
    动画演示:

    var arr = [123,203,23,13,34,65,65,45,89,13,1];	
    //创建快速排序函数
    function quickSort(tempArr){
    	//递归终止条件
    	if(tempArr.length<=1){
    		return tempArr;
    	};
    	//取基准
    	var pivotIndex = Math.floor(tempArr.length/2);
    	var pivot = tempArr.splice(pivotIndex,1);
    	//分左右
    	var leftArr = [];
    	var rightArr = [];
    	for(var i=0;i<tempArr.length;i++){
    		if(tempArr[i]>pivot){
    			rightArr.push(tempArr[i]);
    		}else{
    			leftArr.push(tempArr[i]);
    	    };
    	};
    	return quickSort(leftArr).concat(pivot,quickSort(rightArr));
    };
    console.log(quickSort(arr)); //(11) [1, 13, 13, 23, 34, 45, 65, 65, 89, 123, 203]

     

    展开全文
  • js数组排序 (4种方法)

    千次阅读 2019-09-25 09:32:07
    js递归排序法 (性能消耗低): <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Document</title> </head> <body> <script> let...

    1、递归排序法 (性能消耗低):

    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>Document</title>
    </head>
    <body>
      <script>
        let arr = [1,4,2,6,7,9,11,5,8,10,3];
        //let arr = [1,4,2,3];  //可以拿这个演示更好理解
        //划分
        function mergeSort(arr){
          let len = arr.length;
          //起初为两个两个进行比较
          if(len < 2){
            return arr;
          }
          //以mid作为分界线
          let mid = Math.floor(len/2);
          //拆分成left于right两个数组
          let left = arr.slice(0,mid);
          let right = arr.slice(mid);
          //递归  逆向思考最后一次 mergeSort(left)于mergeSort(right)长度都为1的情况
          return merge(mergeSort(left),mergeSort(right));
        }
    
        //排序
        function merge(left,right){
          let result = [];
          while(left.length >0 && right.length >0){
            if(left[0] <= right[0]){
              //删除left数组第一项push到result内
              result.push(left.shift());
            }else{
              result.push(right.shift());
            }
          }
          
          //此时如果还有一个数组内有值就将它push到result数组里面
          while(left.length){
            result.push(left.shift());
          }
          while(right.length){
            result.push(right.shift());
          }
          //返回排序好的数组
          return result;
        }
        let newArr = mergeSort(arr);
        console.log(newArr);  //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
    
      </script>
    </body>
    </html>
    

    2、快速排序法:

    //快速排序
    let arr = [1,4,2,6,7,9,11,5,8,10,3];
    function quickSort(arr){
      let len = arr.length;
      quick(arr,0,len-1);
    }
    function quick(arr,left,right){
      let point = left;       //第一项
      let index = point + 1;  //遍历起点
      let len = arr.length;
      //以arr[point]作为参照物 起点开始遍历到终点 将比arr[point]小的值放左边
      for(let i=index; i<=right; i++){
        if(arr[i] < arr[point]){
          swap(arr,i,index);  //换位置
          index++;  //交换点往前移一位
        }
      }
      //最后让 第一项 与 arr[index-1]作交换
      swap(arr,point,index-1);
    
      index--;  //arr左右的分割点
      let leftE = index-1;   //left的终点
      let rightB = index+1;  //right的起点
      //每边大于2个数才需要递归 直到每边只有一个数
      if(leftE > left){
        quick(arr,point,leftE);
      }
      if(rightB < right){
        quick(arr,rightB,right);
      }
    }
    //换位置
    function swap(arr,i,j){
      let tmp = arr[i];
      arr[i] = arr[j];
      arr[j] = tmp;
    }
    
    quickSort(arr)
    console.log(arr) //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
    

    3、堆排序法:

    let arr = [1,4,2,6,7,9,11,5,8,10,3];
    //堆排序
    function heapSort(arr){
      let len = arr.length;
      //初始化堆调整
      for(let j=Math.floor(len/2)-1; j>=0; j--){
        heap(arr,j,len);
      }
      for(let i =len-1; i>0; i--){
        swap(arr,0,i);
        len --;
        heap(arr,0,len);
      }
    }
    function heap(arr,i,len){
      //从第i个开始一层一层逆向得出最大的数
        let left = 2*i+1, //得出左边子集
           right = 2*i+2; //得出右边子集
             max = arr[i], //设最后一个为最大值
        maxIndex = i; 
        //和最大值比较 并更新最大值的max Index
        if(left<len && arr[left]>max){
          maxIndex = left;
        }
        if(right<len && arr[right]>max){
          maxIndex = right;
        }
        if(maxIndex !== i){
          //最大值交换
          swap(arr,i,maxIndex);
          heap(arr,maxIndex,len);
        }
    }
    //交换
    function swap(arr,i,j){
      let tmp = arr[i];
      arr[i] = arr[j];
      arr[j] = tmp;
    }
    heapSort(arr)
    console.log(arr) //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
    

    4、基数排序法: (低消耗)

    在这里插入图片描述

    //基数排序法
    function redixSort(arr){
      let len = arr.length;
      //找出数组中最大数的位数
      let maxNum = arr[0];
      let redixArr = [];
      for(let i=1; i<len; i++){
        if(arr[i] > maxNum){
          maxNum = arr[i];
        }
      }
      let x=10,y=1;
      let maxDigit = maxNum.toString().length; //最大位数
      for(let i=0; i<maxDigit; i++){
        for(let j=0; j<len; j++){
          let v = Math.floor(arr[j] % x/y);
          if(!redixArr[v])redixArr[v] = [];
          redixArr[v].push(arr[j]); //个位 十位 百位...排序
        }
        x *=10;
        y *=10;
        let index =0;
        //排序好的遍历回arr数组内
        for(let j=0,len=redixArr.length;j<len; j++){
          let item = redixArr[j];
          if(!item)continue;
          item.forEach(v=>{
              arr[index ++] = v;
          });
        }
        //最后将redixArr排序清空等待下一次排序
        redixArr = [];
      }
    }
    arr = [233,434,565,23,78,2,54,56,9];
    redixSort(arr);
    console.log(arr); //[2, 9, 23, 54, 56, 78, 233, 434, 565]
    
    展开全文
  • 数组排序几种方法

    2020-06-02 16:08:53
    1.数组方法 sort()排序 2.冒泡排序(两层循环,两两互换) 算法步骤: 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的...
  • 一、数组的拓展方法sort() 1.语法形式 array.sort(function(a,b){ //从小到大排序 return a - b; //从大到小排序 //return b - a; }) 2.返回值 原数组 var arr = [11, 85, 94, 89, 45, 13, ...
  • 开发中,遇到数组排序的需求很频繁,这篇文章会介绍个常见排序思路。 一、希尔排序(性能最好) 如果要从大到小排列,则 while(arr[n] > arr[n – interval] && n > 0) 。 // 希尔排序算法 function xier(arr){ ...
  • js数组排序常用的几种方法

    千次阅读 2020-09-09 22:16:52
    js数组排序(冒泡、快速、插入) 1.冒泡排序法 将数组中的相邻两个元素进行比较,将比较大(较小)的数通过两两比较移动到数组末尾(开始),执行一遍内层循环,确定一个最大(最小)的数,外层循环从数组末尾...
  • 1.常用的数组自带的方法 var arr = [6, 3, 8, 7, 1, 5, 4, 2, 9]; arr.sort(function(a, b){ return a - b;//升序排列 //return b - a;//降序排列 }); //结果是[1, 2, 3, 4, 5, 6, 7, 8, 9] console.log(arr); 2....
  • 数组排序几种方式

    2021-04-29 11:51:46
    在数据结构算法中常见和不常见的排序方式,可分为比较类排序和非比较类排序: 比较类排序,通过比较来决定元素之间的相对次序,它的时间复杂度不能突破O(nlogn),也称之为非线性时间比较类排序。非比较类排序则与之...
  • 这篇文章是对于 JS数组排序的常见方法的一个总结 : 前置知识 : 排序大的分类可以分为两:内排序和外排序。在排序过程中,全部记录存放在内存,则称为内排序,如果排序过程中需要使用外存,则称为外排序。...
  • 数组的常用方法 1、push() 后增加 push,压栈,相当于在数组的末尾加上一个元素 eg: var arr = [1, 2, 3] // 使用 push 方法追加一个元素在末尾 arr.push(4) console.log(arr) // [1, 2, 3, 4] 2、pop() 后删除 ...
  • JS数组的查找方式有:顺序查找、折半查找。 (1)查找 indexOf系统提供的 我们也可以实现自己的查找方法 a.顺序查找  var a =[3,7,11,43,87,5,99,22,51,8];  var num = Number(prompt("请输入要查找的值...
  • 思考之后,我想出来的解决方案思路简单来说是,首先统计出每个单词的出现次数以及最后一次出现时的下标数,按照每个单词是出现次数进行第一轮排序排序之后,根据单词出现次数对次数相同的单词再...
  • 1、sort()方法排序 var arr = [10, 57, 88, 60, 20, 30, 24, 50, 80, 29]; arr.sort(function(a,b){ //return a-b;//升序 return b-a;//降序 }) console.log(arr); 2、选择排序 var arr = [10, 57, 88, 60, 20,...
  • 一、冒泡排序 ...重复这样的动作,重复多少次,由数组的长度决定,比如length为2,重复一次就行,length为3,就重复两次..依次类推,要重复length-1次; // 冒泡排序(从小到大) function sortArr (arr) { ...
  • 数组调用方法 数组中的索引有很多作用,下面是四作用: 1,通过索引下标,调用数组中,指定单元的数据 var arr = ['北京','上海','广州','重庆','天津']; arr[0] ---> 调用索引下标是 0 ,实际是第一个单元的数据...
  • 1. JavaScript的sort()方法 var array = [1, 4, -8, -3, 6, 12, 9, 8]; function compare(a, b) { return a - b; }; array.sort(compare); console.log(array); // [-8, -3, 1, 4, 6, 8, 9, 12] sort()方法排列数...
  • JS数组去重的几种常见方法 一、简单的去重方法 // 最简单数组去重法 /* * 新建一新数组,遍历传入数组,值不在新数组就push进该新数组中 * IE8以下不支持数组的indexOf方法 * */ function uniq(array){ var temp = ...
  • js打乱数组几种方法

    千次阅读 多人点赞 2019-03-03 09:40:32
    今天有小伙伴问到,数组打乱都有什么方法,那么打乱数组有太多的方法了,我这里简单的说三 利用sort排序方式打乱数组 var arr = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] var randomNumber =...
  • js数组几种常见排序

    千次阅读 2018-08-09 11:17:17
    JavaScript的sort()方法 ``` var array = [1,4,-8,-3,6,12,9,8]; function compare(val1,val2){  return val1-val2; }; array.sort(compare); document.write(array); ``` sort()方法按照升序排列数组项,会调用...
  • js数组几种方法总结 1.toString()方法,将数组转化为字符串,将数组值(用逗号分割)的字符串 var arr = [12,34,445,67,878,89]; console.log(arr.toString()); 可以看出将arr转化为带逗号的字符串 2.join()...
  • 数组去重分几种情况:数组的项全部是数值;数组的项全部是字符串;数组的项全部是对象;数组的长度 1 indexOf 去重 let array = [1, 2, 4, 2, 3]; function unique(array) { let res = []; const len = array....
  • js数组去重的几种方法

    千次阅读 2016-12-14 15:01:44
    这个面试题想必大家都不陌生,很多面试过的人都遇到过,这个面试题难度确实不大,但是...下面我们来介绍几种数组去重的方法: 一、第一种方法:   var a=Array(1,2,3,4,1,2,3,4,2,1) for(i=0;i;i++){ for(x=
  • 1、随机排列 function shuffle(arr) { var i, j, temp for (i = arr.length - 1; i > 0; i--) { j = Math.floor(Math.random() * ...在开发者,我们经常需要过滤重复的值,这里提供几种方式来过滤数组的重复值。
  • javascript数组排序

    2018-11-25 10:52:44
    最常用的数组操作之一是排序,按一定的秩序对数组...为了解决这个问题,JavaScript数组具有sort方法,使用方法如下: array.sort((a, b) =&gt; a-b); JavaScript引擎实现了排序算法。我们需要提供回调函数,告...
  • 数组去重 ​ 虽说去重问题在开发中基本不用前端去处理,但前端依然要熟练使用,而且去重...第一种方法–利用数组indexOf()方法 javascript Array.prototype.only = function() { var arr = this; var newArr =...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,189
精华内容 16,075
关键字:

js数组排序的几种方法