数组使用入门+冒泡、顺序排序

数组 array

当我们需要处理一组数据时，一定性定义很多变量，比较难处理。这个时候我们就需要用到数组。

概念：
数组：一组数据的集合。其中每个数据被称为数组的元素。在数组中存放任意类型的数据。数组是将一组数据存储到单个变量名下的方式。

数组声明

三种声明：
1.通过new关键字创建数组。
2.省略new关键字创建数组
3.字面量赋值

// 声明数组
        // var arr = new Array(10);
        // var arr =  Array(10);
        // 以上两个声明了一个长度为10的数组
        // var arr = new Array(10, 20, true, "hello");
        // var arr = Array(10, 20, true, "hello");
        var arr = [10, 20, true, "hello"];
        // 声明了一个数组，元素有10, 20, true, "hello"
        alert(arr)

【注】前两种方式，若传入参数只有一个，且为number时，这个数字表示声明的数组的长度，而不是存放的数据。

基本应用

数组的长度
arr.length

var arr = [10, 20, true, "hello", 11];
        // 数组长度
        alert(arr.length);

数组的下标
从0开始，数据在数组中的序号。最大值为length-1.

访问数组元素。
格式：数组变量名[下标]
访问数组元素，需要通过下标去访问。

 var arr = [10, 20, true, "hello", 11];
 // 输出数组中其中一个元素
  alert(arr[2]);

数组的遍历 （循环）

两种循环遍历方式：
1.普通的for循环。
2.for…in 循环 快速遍历法/快速枚举法
格式：
for (var 自定义变量名 in 数组变量名) {

       }

区别：
1.for in不需要每次都判断，效率更高
2.for in若在遍历过程中，数组发生了变化，可能会出现问题，不安全。

	var arr = [10, 20, true, "hello", 11];
	// 遍历数组中的所有元素，并输出
	// for (var i = 0; i < arr.length; i++) {
	//     document.write(arr[i] + " ");
	// }
	for (var i in arr) {
	    document.write(arr[i] + " ");
	}

数组方法

push()
功能：给数组的末尾添加元素
格式：数组名.push(参数…)
返回值：插入元素后的数组长度

 		var arr = [1, 2, "hello", 9, 5];
        var arr1 = arr.push("world");
        alert(arr);
        alert(arr1);

pop()
功能：在数组的末尾取下一个元素
格式：数组名.pop()
返回值：取下的元素。

		var arr = [1, 2, "hello", 9, 5];
		var arr2 = arr.pop();
		alert(arr);
        alert(arr2);

unshift()
功能：从数组的头部添加元素
格式：数组名.unshift(参数…)
返回值：插入元素后的数组长度

		var arr = [1, 2, "hello", 9, 5];
		var arr3 = arr.unshift(5, "world");
		alert(arr);
        alert(arr3);

shift()
功能：从数组的头部取下一个元素
格式：数组名.shift()
返回值：取下的元素。

		var arr = [1, 2, "hello", 9, 5];
		var arr3 = arr.shift();
		alert(arr);
        alert(arr3);

concat()
功能：合并数组。
格式：数组名.concat(数组);
1.copy原数组，生成新数组。
2.将输入的数组中的元素单独拆分出来，添加到新数组中。

		var arr = [1, 2, "hello", 9, 5];
		var newArr = ["我", "是", "后", "来", "的"]
        var arr4 = arr.concat(newArr);
        alert(arr);
        alert(arr4);

slice()
功能：获取当前数组指定区域的元素，生成新数组。
格式：数组名.slice(start,end) 含头不含尾
start:开始位置的下标
end：结束位置的下标
返回值：新数组，原数组不变。

		var arr = [1, 2, "hello", 9, 5];
        var arr5 = arr.slice(1, 4);
        alert(arr);
        alert(arr5);

splice()
截取
格式：数组.splice(start,length,数据…)
返回值：截取的元素
参数：
start：开始截取的位置
length：截取的长度
第三个参数开始：在start位置开始，插入新元素。
对数组元素的

新增
arr.splice(4,0,“5”);

		var arr = [1, 2, "hello", 9, 5];
		arr.splice(2, 0, "ok");
        alert(arr);

修改
arr.splice(2,1,4);

		var arr = [1, 2, "hello", 9, 5];
        arr.splice(2, 1, "ok");
        alert(arr);

删除
arr.splice(2,1);

		var arr = [1, 2, "hello", 9, 5];
		arr.splice(2, 2);
        alert(arr);

join()
格式：数组.join(字符串);
功能：将数组中元素用指定的字符串拼接
返回值：拼接好的字符串

		var arr = [1, 2, "hello", 9, 5];
       	var only = arr.join("、");
        alert(arr);
        alert(only);

reverse()
功能：将数组元素反转。
格式:数组.reverse();
该方法会修改原数组。

		var arr = [1, 2, "hello", 9, 5];
		arr.reverse()
        alert(arr);

sort()
对数组中的元素进行排序

		var arr = [1, 2, 9, 5];
		var arr10 = arr.sort();
        alert(arr);
        alert(arr4);

ES5新增常见方法

indexof()
功能：在数组中查找第一次出现元素的下标。
格式：数组.index(item,start);
参数：
item：要查找的元素
start：开始查找的位置
返回值：查找到的元素下标，若未查到，则返回-1。

		var arr = [1, 2, "hello", 9, 5];
        var arr11 = arr.indexOf("hello");
        alert(arr11);

forEach()
格式：数组.forEach(function(item,index,arr)){

   }

参数：
item：当前遍历的元素，
index：当前遍历元素的下标
arr：数组

			var arr12 = arr.forEach(function(item, index, arr) {
            document.write("元素为  " + item + "  下标为  " + index);
            document.write("<br/>")
       	 	});

冒泡排序

规则：从左到右，数组中相邻的两个元素进行比较。将较大（较小）的数放在后面。
规律:每一轮都可以找出一个最大（最小）值，放在正确的位置上。
比较的轮次：数组的长度-1
每一轮比较的次数：数组长度-当前的轮次

		var arr = [2, 8, 6, 3, 5];
        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;
                }
            }
        }
        alert(arr);

选择排序

规则：选出一个固定位置，让这个位置上的数与后面的数比较，如果大于（小于）后面的数，则交换位置。然后对该位置进行下一轮比较。
规律：每一轮，在当前位置找到正确的值。
比较的轮次：数组的长度-1
每一轮比较的次数：数组长度-当前的轮次

		var arr = [2, 8, 6, 3, 5];
        for (var i = 0; i < arr.length - 1; i++) {
            for (var j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    var temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        alert(arr);