数组中的计算-CSDN博客

1.简单的数组排序sort

如果数组中的元素时字符串类型，那么用sort会非常好用

var names = ["David","Mike","Cynthia","Clayton","Bryan","Raymond"];
names.sort();
console.log(names); //["Bryan", "Clayton", "Cynthia", "David", "Mike", "Raymond"]

如果数组中的元素是数字类型，那么要得到准确的结果，就不能同上面的排序一样了。

    function compare(num1,num2){
        return num1 - num2;
    }
    var nums = [3,2,1,200,30];
    nums.sort(compare);
    console.log(nums);   //[1, 2, 3, 30, 200]

 //->ary.sort() 这样的话只能处理10以内的数字进行排序,因为它是按照UNICODE编码的值进行排序的
 //->ary.sort(function (a, b) {return a - b;}); 由小到大排序
//->ary.sort(function (a, b) {return b - a;}); 由大到小排序
    
var ary = [12, 23, 34, 45,1];
console.log(ary.sort(function(a,b){return a-b;})); // [1, 12, 23, 34, 45]

2.创建二维数组

简单方式：针对小规模的数组

var grades = [[12,3,4],[3,4,55],[99,33,44]];
console.log(grades[2][2]);  //44

函数方式

Array.matrix = function(numrows,numcols,initial){
    var arr = [];
    for(var i =0;i<numrows;i++){
           var conlumns = [];
           for(var j=0;j<numcols;j++){
                  conlumns[j] = initial;
           }
                          arr[i] = conlumns;
    }
    return arr;
}
    
var nums = Array.matrix(6,6,0);   //0

3.求二维数组的平均数

以行来求平均数（参差不齐的数组是指数组中每行的元素个数彼此不同。有一行可能包含三个元素，另一行可能包含五个元素，有些行甚至只包含一个元素，对于参差不齐的函数下面的方法仍然试用）

var grades = [[89, 77, 78],[76, 82, 81],[91, 94, 89]];
var total = 0;
var average = 0.0;
for (var row = 0; row < grades.length; ++row) {
            for (var col = 0; col < grades[row].length; ++col) { 
                      total += grades[row][col];
            }
         average = total / grades[row].length;
         console.log("Student " + parseInt(row+1) + " average: " + average.toFixed(2));
          total = 0;
          average = 0.0;
}

以下为程序的输出：

Student 1 average: 81.33

Student 2 average: 79.67

Student 3 average: 91.33

以列来求平均数

var grades = [[89, 77, 1],[76, 82, 1],[5,5]];
var total = 0;
var average = 0.0;
for (var col = 0; col < grades.length; col++) {
for (var row = 0; row < grades[col].length; row++) {
   total += grades[row][col];
}
 average = total / grades[col].length;
 console.log("Test " + parseInt(col+1) + " average: " + average.toFixed(2));
 total = 0;
 average = 0.0;
}

该程序的输出为：

Test 1 average: 56.67

Test 2 average: 54.67

Test 3 average: 1.00

4.插入排序

//->插入排序：
    //->把第一张牌放在左手
    //->以后拿到每一张牌的时候,和左手中的牌进行依次比较(一般来说我们的习惯是从后往前比较),如果当前的牌比倒数第一张小,在继续往左比...一直到遇到当前的牌已经比手里的某张牌大了，则把这张牌插入到某张牌的后面(某张牌下一张牌的前面)

       function insertSort(ary) {
    
          //->newAry存储的就是我左手中已经抓取的牌
           var newAry = [];
            newAry.push(ary[0]);//->先抓第一张牌
    
            //->依次把桌面上第二张及以后的牌抓到
           for (var i = 1; i < ary.length; i++) {
              var cur = ary[i];
    
               //->抓到当前牌之后,分别的从后往前和左手中的牌进行比较
                for (var j = newAry.length - 1; j >= 0;) {
                   if (cur < newAry[j]) {//->当前新抓的牌比左手中的newAry[j]这张牌小,继续和newAry[j]前面的牌比
                       j--;
                       if (j === -1) {//->说明当前拿的这张牌比左手所有的牌都小,我么把这张牌放在开头位置即可
                            newAry.unshift(cur);
                      }
                 } else {//->当前新抓的牌比左手中的newAry[j]这张牌大,放在newAry[j]这张牌的后面,也相当于插入到newAry[j+1]这张牌的前面
                      newAry.splice(j + 1, 0, cur);
                        j = -1;
                   }
             }
            }
            return newAry;
        }
  
     var ary = [6, 3, 5, 7, 2, 4];
     var res = insertSort(ary);
     console.log(res);


       for(var i=0;i<ary.length;i++){
           console.log(ary[i]);
        }

       for(var i=ary.length-1;i>=0;i--){
           console.log(ary[i]);
       }

简化：

var ary = [6, 3, 5, 7, 2, 4];
    function insertSort(ary) {
        var key;
        var j;
        for (var i = 1; i < ary.length; i++) {
            key = ary[i];
            j = i - 1;
            while (j > -1 && ary[j] > key) {
                ary[j + 1] = ary[j];
                j--;
            }
            ary[j + 1] = key;
        }
        return ary;
    }
    console.log(insertSort(ary));

5.快速排序(递归)

<script type="text/javascript">
    //快速排序的思想:
    //1)我们首先在数组中找一个"基准点"(一般把基准点选择为数组中间的这一项)
    //->Math.floor(ary.length/2)  例如：一共9项,获取的结果是4(第五项,正好是中间项);一共10项,获取的结果是5(第六项),也接近中间项;
    //2)拿基准点和数组中的其他项进行比较,比基准点小的放在左边,比基准点大的放在右边
    //3)以后的每一遍都重复上述的两个操作,直到当前这一边只有一项的时候停止处理...

    function quickSort(ary) {
        //->如果传递过来的数组只有一项了,不需要再按照快速的思想拆了,直接把这个一项的数组返回即可
        if (ary.length <= 1) {
            return ary;
        }

        var pointIndex = Math.floor(ary.length / 2);//->找到基准点的索引
        var pointValue = ary.splice(pointIndex, 1)[0];//->通过基准点的索引在原来的数组中,删除这一项,并把基准点这一项的值获取到

        //->拿基准点的值和原来的数组中每一项进行比较,把小于基准点的放在左边,把大于基准点的放在右边
        var left = [];
        var right = [];
        for (var i = 0; i < ary.length; i++) {
            var cur = ary[i];
            cur < pointValue ? left.push(cur) : right.push(cur);
        }

        return quickSort(left).concat([pointValue], quickSort(right));
    }

    var ary = [12, 13, 23, 14, 20, 26, 34, 13, 16];
    var res = quickSort(ary);
    console.log(res);
</script>

6.冒泡排序

分析：

    //    var ary = [4, 3, 5, 2, 1];
    //->[1, 2, 3, 4, 5]
    //->冒泡排序的思想：让当前项和后一项进行比较，如果当前项大于后一项,两者交换位置

    //第一轮:
    //4>3 交换位置 [3, 4, 5, 2, 1]
    //4<5 不需要交换位置 [3, 4, 5, 2, 1]
    //5>2 交换位置 [3, 4, 2, 5, 1]
    //5>1 交换位置 [3, 4, 2, 1, 5]
    //->虽然没有实现最后的目标,但是已经把数组中当前最大的那个值5已经放在数组的末尾位置了
    //->第一轮比较了四次 一共五个数,不用和自己比,最多比较四次

    //第二轮
    //3<4 不交换 [3, 4, 2, 1, 5]
    //4>2 交换 [3, 2, 4, 1, 5]
    //4>1 交换 [3, 2, 1, 4, 5]
    //->也没有实现最后的目标,但是把剩余项中最大的那个4放在倒数第二位了
    //->第一轮比较了三次 首先不用和自己比,最多四次,但是第一轮我们已经把最大的一个数放末尾了,不需要再和末尾的5比了

    //第三轮
    //3>2 交换 [2, 3, 1, 4, 5]
    //3>1 交换 [2, 1, 3, 4, 5]
    //->第一轮比较了两次 首先不用和自己比,最多四次,但是第一轮/第二轮我们已经把最大的两个数放末尾了,不需要再和末尾的4/5比了

    //第四轮
    //2>1 交换 [1, 2, 3, 4, 5]

    //每一轮当前项和后一项两两比较的话,虽然不一定达到最后的目标结果,但是已经把当前最大的那个值放在后面了 ->数组一共有五项,我只需要比较四轮,把四个最大值分别的放在末尾,就实现了排序 ->一共最多需要比较多少轮:ary.length-1

    //->i轮数 i=0  i<ary.length-1
    //->j每一轮比较的次数
    //i=0 第一轮 4 ary.length-1-0  ary.length-1->不用和自己比
    //i=1 第二轮 3 ary.length-1-1
    //i=2 第三轮 2 ary.length-1-2
    //i=3 第四轮 1 ary.length-1-3
    //...
    //每一轮比较的次数 ary.length-1-i


    //->两者交换位置
    //    var a = 12;
    //    var b = 13;
    //    var c = null;
    //    c = a;
    //    a = b;
    //    b = c;
    //    console.log(a,b);//->13,12

    //->如果不能使用第三个空瓶子如何处理?
    //    var a = 12;
    //    var b = 13;
    //    a = a + b;//->a=25
    //    b = a - b;//b=25-13=12
    //    a = a - b;//a=25-12=13


      function bubbleSort(ary) {
            var temp = null;
            for (var i = 0; i < ary.length - 1; i++) {//i->轮数
                for (var j = 0; j < ary.length - 1 - i; j++) {//j->每一轮比较的次数
                    if (ary[j] > ary[j + 1]) {
                        temp = ary[j];
                        ary[j] = ary[j + 1];
                        ary[j + 1] = temp;
                    }
                }
           }
            return ary;
        }
        var ary = [4, 3, 5, 2, 1];
        var res = bubbleSort(ary);
       console.log(res);

优化：

//->优化
    var ary = [2, 1, 3, 5, 4];

    //在第一轮比较前设置一个变量等于false ->var flag = false;
    //第一轮 i=0
    //2>1 [1, 2, 3, 5, 4] 只要有需要交换位置的 我就让flag=true
    //2<3 [1, 2, 3, 5, 4]
    //3<5 [1, 2, 3, 5, 4]
    //5>4 [1, 2, 3, 4, 5]

    //->flag=true 说明上一轮有交换的了,我继续执行下一轮

    //->在第二轮开始之前,我在让flag等于false
    //第二轮 i=1
    //1<2 [1, 2, 3, 4, 5]
    //2<3 [1, 2, 3, 4, 5]
    //3<4 [1, 2, 3, 4, 5]

    //->flag=false 当前第二轮一个都没有交换，说明数组已经排序好了,没必要在往下比较其它的轮数了，我们结束循环即可


    function bubbleSort(ary) {
        var flag = false;
        for (var i = 0; i < ary.length - 1; i++) {
            for (var j = 0; j < ary.length - 1 - i; j++) {
                if (ary[j] > ary[j + 1]) {
                    ary[j] = ary[j] + ary[j + 1];
                    ary[j + 1] = ary[j] - ary[j + 1];
                    ary[j] = ary[j] - ary[j + 1];
                    flag = true;//->只要本轮有交换就让flag=true
                }
            }
            if (flag) {//->flag==true 上一轮有交换的,继续执行下一轮,并且让flag重新的赋值false
                flag = false;
            } else {//->上一轮没有交换的,已经排好序了,直接结束循环即可
                break;
            }
        }
        return ary;
    }
    console.log(bubbleSort([2, 1, 3, 5, 4]));
</script>