JavaScript(5)-数组的定义和使用,数组中的常用函数,数组排序-冒泡排序法

---

---

一、数组介绍

1. JS数组的概念

数组的字面意思就是一组数据，一组数据（一般情况下是相同类型的数据, 不一定都是数字）

2. 数组的作用

使用单独的变量名来存储一系列的值, 数组是特殊的变量，它可以同时保存一个以上的值。

如上节课中我们学过的arguments就是一个数组, 里面保存了多个参数.

3. 为什么要使用数组?

  如果您有一个项目列表（例如汽车品牌列表），在单个变量中存储这些品牌名称是这样的:  

var cars1=“Volvo”, cars2 =“BMW”, cars3 = ”Benz“;
不过，假如您希望对变量进行遍历并找出特定的那个值？或者如果您需要存储 300个汽车品牌，而不是 3 个呢？ 解决方法就是创建数组！

二、数组的定义和使用

1, 数组的定义

方式一:
new Array（参数，参数,…）: 只有一个数字参数时是数组的长度（new可以省略,但一般尽量写上）
例如:

 var arr = new Array();   //定义一个空数组 
 var arr = new Array(10);  //创建一个包含 10 个元素的数组，没有赋值
 var arr = new Array(“芙蓉姐姐”,30);  //创建一个数组有两个元素

方式二:
var arr = [1,2,3,4,5]; //字面量定义方式

2, 数组元素的获取(访问)

 arr[0]: 表示数组的第一个元素，0是下标，也叫索引
 arr[1]: 表示数组的第二个元素，1是下标 

3, 数组的长度

  数组长度(数组元素的个数) : arr.length
length属性, 不仅是只读的，也可以设置

例如:

var colors = new Array("red", "blue", "green");
colors.length=2;
console.log(colors[2]);

数组的下标从0开始, 所以数组的最后一个元素的下标为： arr.length – 1
注意: 下标可以是变量或表达式

4， 数组的赋值

给数组赋值，就是给数组的元素赋值，需要通过给数组的每个元素一一赋值，
如：arr[0] = 20;  //让数组的第一个元素的值为20；
       arr[1] = 12;  //让数组的第二个元素的值为12；

• 以下为通过for循环给数组的每个元素赋值，赋成下标的平方。

  for(var i=0;i<10;i++){
         arr[i] = i*i;
    }

• 以下为通过for循环给数组的每个元素赋值，赋值一个随机数:Math.random()

for(var i=0;i<10;i++){
     arr[i] = Math.random();
}

Math.random()的范围是: 0~1(包括0, 不包括1)

5, 数组的使用

使用数组就是在使用数组的每个元素，因为数组相当于若干个相同类型的变量。

遍历数组:
之前我们讲过通过下标获取单个数组元素, 但有时候我们需要批量使用数组, 这个时候我们需要遍历整个数组.

1. 普通for循环

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

2. for…in遍历: 用于遍历数组或者对象

  for(var i in arr){
         console.log(arr[i]);
    }

三、数组中的常用函数

1, 栈方法 : push() 和 pop()

 ECMAScript 数组提供了一种让数组的行为类似于其他数据结构的方法。可以让数组像栈一样，可以限制插入和删除项的数据结构。栈是一种数据结构(后进先出)，也就是说最后添加的元素最早被移除。而栈中元素的插入(或叫推入)和移除(或叫弹出)，只发生在一个位置——栈的顶部。ECMAScript 为数组专门提供了 push()和 pop()方法。

push(): 接收任意数量的参数，把它们逐个添加到数组的末尾，并返回修改后数组的长度;
pop(): 从数组末尾移除最后一个元素，减少数组的 length 值，然后返回移除的元素;
例如:
数组末尾添加一个元素，并且返回长度

 console.log(arr.push(‘张家界')); 

移除数组末尾元素,并返回移除的元素

 var b = arr.pop();	

2, 队列方法 : push() , shift() 和 unshift()

队列在数组的末端添加元素，从数组的前端移除元素
push(): 和栈方法中的push是同一个，
shift(): 方法从数组前端移除一个元素,
unshift(): 方法从数组前端添加一个或多个元素。

例如:
数组末尾添加一个元素，并且返回长度
console.log(arr.push(‘深圳’));
移除数组开头元素，并返回移除的元素
console.log(arr.shift());
数组开头添加两个元素
console.log(arr.unshift(‘广东’,‘深圳’));

3, 排序方法: reverse()和 sort()

• reverse() : 逆向排序, 原数组也被逆向排序了

  例如:

 var arr = [1,2,3,4,5];
  console.log(arr.reverse()); //逆向排序方法，返回排序后的数组
  console.log (arr);    

• sort() : 从小到大排序 , 原数组也被升序排序了

  例如:

 var arr= [4,1,7,3,9,2];
   console.log(arr.sort());   //从小到大排序，返回排序后的数组
   console.log(arr);  

sort()详解 :
sort 方法的默认排序在数字排序上有些问题，因为数字排序和数字字符串排序的算法是一样的。我们必须修改这一特征，修改的方式，就是给 sort(参数)方法传递一个函数参数。

 //如果一定要使用sort()进行排序, 可以传递一个函数
      function compare (value1, value2) {
	if (value1 <= value2) {
	        return -1;  //返回0和-1, 表示不交换值
	}
	return 1;   //返回1, 表示会交换值
      }
      var box = [0, 1, 5, 10, 15];
      var aseBox = box.sort(compare);   //返回升序的数组

4, 数组操作的方法

• ECMAScript 为操作已经包含在数组中的元素提供了很多方法。

concat() : 追加数据, 创建一个新数组, 不改变原数组
      var arr = [2, 3, 4, ‘绿箭侠’, ‘黑寡妇’];
      var arr2 = arr.concat(‘美队’, ‘雷神’);
      console.log(arr);
      console.log(arr2); 

• slice() : 不修改原数组, 将原数组中的指定区域数据提取出来

var arr = [2, 3, 4, "绿巨人"];
  var arr2 = arr.slice(1, 3);  //并没有修改原数组,将原数组中的元素提取出来,生成新数组, 取的是下标在区域: [1,3)
  console.log(arr);
  console.log(arr2);

• splice() : 截取原数组中指定的数据, 会改变原数组

var arr = [2, 3, 4, '绿箭侠', '黑寡妇'];
  var arr2 = arr.splice(2, 1);   //第一个参数代表我要开始截取的下标位置
		         //第二个参数截取的长度, 如果只有两个参数, 则表示删除操作
  console.log(arr);     //[2, 3, '绿箭侠', '黑寡妇'];
  console.log(arr2);   //4

注意: splice和slice的区别

• splice() 详解:

插入: 如果有3个或以上参数,且第二个参数(长度)为0,则表示插入

 arr.splice(1, 0, “绿巨人”, “冬兵”); //在下标为1的位置插入: "绿巨人","冬兵"

替换: 如果有3个或以上的参数, 且第二个参数(长度)不为0, 则表示替换

  arr.splice(1, 1, “绿巨人”, “冬兵”);  //在下标为1的位置替换成: "绿巨人","冬兵"

删除: 如果只有两个参数, 则表示删除指定区域的数据

  arr.splice(0, 2);  //删除原数组的部分数据, 并返回截取的数据

join() : 连接数组中的元素, 并返回连接后的字符串, 不传参则以逗号连接

arr.join(“+”);

四、数组排序

1冒泡排序

用冒泡排序，对输入的6个数进行排序
思路：输入6个无序的数字，从头到尾依次比较相邻两个数字大小，若大数在前、小数在后，则交换两数位置，依次比较，使全部数据按从小到大排列

例如: 将数组[8,9,7,6,5,4]进行升序排序[4,5,6,7,8,9]

2选择排序

1. 每次选择当前的第一个数为最小值

2. 这个值跟后面的所有去比较 然后对应的比我这个值还小 把下标记录起来将这个下标赋值给min

3. 判断min是否是我前面给到的值 如果是不做操作 如果不是交换位置

 function selectorSort(array){
            for(var i = 0 ; i<array.length-1; i++){
                //设置第一个数为最小值
                var min = i
                for(var j=i+1;j<arr.length;j++){
                    if(array[min]<array[j]){//如果比最小值还小
                        min = j//使用min记录一下这个值
                    }
                }
                if(min!=i){
                    //min不指向我们开始指定的下标
                    var temp = array[i]
                    array[i] = array[min]
                    array[min] = temp
                }
            }
        }
        selectorSort(arr)
        console.log(arr);

3.插入排序

1.第一种方法

//从后往前比 初始下标为1
    var arr4 = [5,9,4,3,1,8,2,6]
    function inserSort(array){
        for(var i = 1;i<array.length;i++){
            for(var j = i; j>0; j--){
                if(array[j-1]>array[j]){
                    var temp = array[j-1]
                    array[j-1] = array[j]
                    array[j] = temp
                }
            }
        }
    }

  
    inserSort(arr4)
    console.log(arr4);

2.第二种方法

```markup
function insertion(array) {
        for (var i = 1; i < array.length; i++) {
          var preIndex = i - 1; //获取前一个下标
          var current = array[i]; //先保存当前的值 为防止
          while (preIndex >= 0 && current < array[preIndex]) {
            //如果前一个下标等于0 和 当前的值为小于是一个
            array[preIndex + 1] = array[preIndex]; //将本身这个位置的值赋值为是一个
            preIndex--; //递减 继续往前走
          }
          array[preIndex + 1] = current; //当前的位置的值等于原本位置的值
        }
      }
      insertion(arr);
      console.log(arr);

快速排序

//   快速排序
      var arr = [1, 3, 8, 5, 6, 2]; //length7 中间值为4
      function quickSort(arr) {
        if (arr.length <= 1) {
          return arr;
        }
        var centerIndex = Math.round(arr.length / 2);
        var center = arr.splice(centerIndex, 1)[0];
        var left = [];
        var right = [];
        for (var i = 0; i < arr.length; i++) {
          if (arr[i] < center) {
            left.push(arr[i]);
          } else {
            right.push(arr[i]);
          }
        }
        return quickSort(left).center([center], quickSort(right));
      }
      console.log(quickSort(arr));

---