数组

1.数组的概念

var a = Number(prompt("请输入一个数"));
var b = Number(prompt("请输入一个数"));
var c = Number(prompt("请输入一个数"));
var e = Number(prompt("请输入一个数"));
var f = Number(prompt("请输入一个数"));
var g = Number(prompt("请输入一个数"));
var h = Number(prompt("请输入一个数"));
var i = Number(prompt("请输入一个数"));
var j = Number(prompt("请输入一个数"));
var k = Number(prompt("请输入一个数"));
alert((a + b + c + e + f + g + h + i + j + k)/ 10);

这个程序很简单，但是如果是100人呢，难道要真的复制100遍？
怎么解决？显然是使用循环。
但是尝试一下就会发现，循环使用不上，因为无法去控制变量a.b.c，也就是无法将循环控制变量和变量a.b.c联系起来。

var a = [];
var sum = 0;
for(var i=0;i<5;i++){
    a[i] = Number(prompt("请输入分数"));
    sum = sum + a[i];
}
var ave = sum / a.length;
alert(ave);

这段代码能够实现同样的功能，而且如果是100人的话，只要把循环的条件改为i<100即可，整个程序的结构和代码量和人数多少没有关系。
为什么和人数没有关系？因为和循环结合起来了
为什么能和循环结合起来呢？因为我们把变量的表达方式改变了，即名称+序号的方式(a[0]、a[1]、a[2]……)，那么序号是可以用循环变量去控制。
2.数组的定义与元素访问
怎么用？
定义：
定义有三种方式

（1）var a = [];
（2）Var a = new Array();
（3）Var a = [0,0,0];

访问元素：数组名+下标
a[0] a[3]
需要注意下标从0开始，所以在使用的时候需要注意越界问题，比如5个元素的数组，那么它的下标范围[0,4],不包括[5]，[5]已经越界了。
数组的本质：一组变量的集合，或者说是一组内存单元。只不过对于变量的表达方式使用的是数组名+下标的方式。
3.数组的常用和属性方法
数组的属性
Length：
1.告诉我们数组的长度：数组名.length
2.通过该属性可以改变数组的长度
数组常用的方法：
（1）
1.unshift：在数组头部添加元素，返回值返回的是新数组的长度。

var b = a.unshift(1);

2.Shift：删除数组头部的元素，返回值是删除的头部元素

var c = a.shift(6)

（2）
1.IndexOf：查找数组中重复出现的元素第一个出现的位置，返回值是该元素的下标

var a = ["我","爱","中","国","也","爱","我","自","己"];
var b = a.IndexOf("爱");
alert(a);
alert(b);

2.LastIndexOf：查找数组中重复出现的元素最后一个出现的位置，返回值是该元素的下标

var a = ["我","爱","中","国","也","爱","我","自","己"];
var b = a.lastIndexOf("爱");
alert(a);
alert(b);

3.push：在数组后面添加元素，返回值是添加元素后返回的数组的长度

    var a = ["我","爱","中","国","也","爱","我","自","己"];
    var b = a.push("!","#");
//    a[a.length] = "#"
    alert(b)

4.pop：从数组的尾部删除最后一个元素，返回值是删除的元素。

    var a = ["我","爱","中","国","也","爱","我","自","己"];
    var b = a.push("!","#");
//    a[a.length] = "#"
    var c = a.pop("#")
    alert(a);
    alert(b);
    alert(c);

5.slice(开始位置的下标，结束位置的下标)：只能提取数组中指定连续的子数组。前包括，后不包括。
提取中国：

var a = ["我","爱","中","国","也","爱","我","自","己"];
var b = a.slice(2,4);
alert(b);

6.Splice(开始删除位置的下标，要删除元素的长度，要选择插入或者替换内容)splice有“剪接”的含义。前面两个参数定义“剪”的部分，第三个参数定义“接”的部分，经过不同的参数组合就可以实现一下三个功能：
1.删除操作：删除数组中指定的任意元素
2.插入操作：在数组中指定的位置插入元素
3.替换操作：在数组中替换指定位置的元素
删除 也","爱","我","自","己"：

var a = ["我","爱","中","国","也","爱","我","自","己"];
var b = a.splice(4, 5);
alert(a);
alert(b);

插入：

var a = ["我","爱","中","国"];
var b = a.splice(3,0,"华","人","民","共","和");
alert(a);

替换：

var a = ["我","爱","中","国"];
var b = a.splice(2,2,"自","己");
alert(a);

7.reverse：将数组中的元素反序输出。在原数组的基础上进行反序输出，不会再创建一个新的数组。

var a = [1,2,3,4];
var b = a.reverse();
alert(a);
alert(b);

8.map:原数组的映射，经过原数组的加工，返回给一个新数组。
一般我们传递的参数都是数值、字符串等类型的数据，有可能可能需要传递一个函数，那么如何传递一个函数呢?
函数名代表这个函数的入口地址
匿名函数

var a = [2,4,6,8];
var b = a.map(fun);
function fun(value,index,self){
   self[index] = value * value;
}
alert(a);

我们可以将以上内容简写为：

var a = [2,4,6,8];
var b = a.map(function(value,index,self){
    self[index] = value * value;
});
alert(a);

（1）查找
Indexof系统提供的
我们可以实现自己的查找方法
a.顺序查找
这种查找方法最简单，查找次数与数据量成正比，效率不高

var a =[3,7,51,11,43,87,5,99,22,51,8];
var num = Number(prompt("请输入要查找的值"));
var index = -1;//最初认为要找的值不在数组中
for(var i in a){
    if(a[i] == num){
        index = i;
        break;
    }
}
alert(index);

b.折半查找（二分查找）
假设在一个已经有序的数组中，可以利用折半查找大幅度提高效率

/*
* 思路：
* 1.用start表示查找范围的起点，end表示终点
* 2.只要start<=end就重复以下步骤
* 3.和中间位置（mid）的那个数进行比较
* a.相等:找到了，结束
* b.大于：在前半段去找，也就是end=mid-1
* c.小于：在后半段去找，也就是start=mid+1
* 4.输出查找结果
* */
var a =[3,5,7,8,11,22,43,51,87,99];
var num = Number(prompt("请输入要查找的值"));
var index = -1;//最初认为要找的值不在数组中
var start = 0;
var end = a.length-1;
while(start <= end){
    var mid =Math.ceil((start + end)/2);//计算中间位置;
    if(num == a[mid] ){
        index = mid;
        break;
    }else{
        if(num > a[mid]){
            //在后半段找
            start = mid+1;
        }else{
            //在前半段找
            end = mid-1;
        }
    }
}
alert(index);

折半查找的最坏查找次数与数据量是对数关系，所以说它的查找效率是很高的，但是任何事情往往都有两面性，它的高效率是有代价的，也就是要求有序。
（2）排序（冒泡排序） （选择排序）

var a =[3,7,11,43,87,5,99,22,51,8];
for(var i=0;i< a.length-1;i++){
    for (var j = 0; j <= a.length-i-1; j++) {
        if (a[j] > a[j + 1]) {
            var t = a[j];
            a[j] = a[j + 1];
            a[j + 1] = t;
        }
    }
}
alert(a.toString());

（3）队列
先进先出（FIFO）在头部出队(shift)，在尾部入队(push)
（4）堆栈
先进后出（FILO），在尾部进栈(push)，也在尾部出栈(pop)