数组，数组API
数组关联数组数组API数组排序栈和队列
一.数组
二.关联数组
三.数组API
四. 数组排序
五.栈和队列
- 数组:
什么是: 连续存储多个数据的存储空间，再起一个名字
多个变量的集合，起一个同一的变量名。
为什么: 程序=数据结构+算法
算法：程序执行的步骤！
数据结构：内存中数据存储的方式！
好的数据结构，可以极大提高程序的执行效率
如果一组相关的多个数据，只有集中存储，才便于管理和查找。
何时使用：集中存储多个相关数据时
如何使用：
创建: 5种:
（1）. 数组直接量,
创建空数组: var arr=[];
创建同时初始化元素:var arr=[值1,….]
（2.） 实例化对象,
创建空数组: var arr=new Array();
arr.length -> 0
String(arr) -> “”
创建空数组,初始化元素个数:
var arr=new Array(n);
arr.length -> n
String(arr) -> ,,,,,,,…
创建数组同时初始化元素:
var arr=new Array(值1,值2…);
访问元素: 数组名[下标]
var arr=[ 1 , 2 , 3 , 4 , 5 , 6 ]
索引值 0 1 2 3 4 5
值 arr[i] arr[i+1] arr[i+2] arr[i+3] arr[i+4] arr[length-1]
长度（length）为最大索引下标值+1，如例子length为5+1
下标: 数组中唯一标识每个元素存储位置的序号
默认下标从0开始，连续不重复
最大下标永远是length-1.
数组中每个元素的用法和普通变量完全一样！
js中数组三特点：
1. 不限制元素个数！
访问不存在的下标:不报错！返回undefined
为不存在下标赋值:会在指定位置新建元素
自动修改length为最大下标+1
固定套路:
（1. ） 访问最后一个元素: arr[arr.length-1]
（2. ）向数组末尾追加新元素:
arr[arr.length]=值;
arr.length自动被+1
<script>
var num=[];
num[0]="happy";
num[1]="new";
num[2]="year";
num[3]="2016";
document.write(num);// happy,new,year,2016
num[num.length]="发大财";
document.write(num);// happy,new,year,2016,发大财
num[num.length]="hahah";
document.write(num);// happy,new,year,2016,发大财,hahah
</script> （3.） 缩容: 改小length属性，可删除结尾的元素
2. 不限制元素的数据类型!
数组是引用类型的对象：
引用计数器: 表示一个对象被几个变量引用的属性
垃圾回收进程: 检查并回收不再使用的对象的后台程序
专门检查引用计数器
一旦引用计数器为0，就释放对象。
如何主动释放对象：将引用对象的变量都设置为null
建议，只要用完较大的对象，都要主动释放
数组的length属性:记录了数组的元素个数;
length不能真实反映数组的元素个数
仅时最大下标+1而已。
数组的遍历: for(var i=0;i<arr.length;i++){
//当前元素: arr[i]
}
var num=[];
num[0]="happy";
num[1]="new";
num[2]="year";
num[3]="2016";
for(var i=0;i<num.length;i++){
document.write(num[i]);
}// happynewyear2016
也可使用for in 遍历for(var i in num){
document.write(num[i])；}// happynewyear2016关联(hash)数组:
什么是索引数组: 下标为数字的数组
什么是关联数组: 可自定义下标名称的数组
下标也称为元素的key
何时使用: 需要明确定义每个元素的名称和意义时
如何创建关联数组:
Step1. 先创建普通空数组: var fbb=[];
Step2. 向空数组中添加元素，自定义下标名
下标名必须是字符串:
fbb[“name”]=”范冰冰”;
fbb[“math”]=89;
fbb[“chs”]=61;
fbb[“eng”]=95;
如何访问关联数组元素:和访问索引数组完全一样
数组名[“下标名”]关联(hash)数组原理:
hash算法: 将给定的不同字符串，计算出尽量不同的序号
存入新元素: 将自定义下标名称交给hash算法计算一个唯一的序号。然后将值存入数组中序号指定的位置。
获取元素值: 将要查找的下标名交给hash算法，计算出和存储时完全相同的序号，直接到序号所在位置获取元素值。
hash数组最大优点: 查找效率极高！
无需遍历，和元素个数无关！
遍历关联数组: length属性失效，始终是0
for(var key in hash){//自动依次获取每个key
hash[key]//获得当前元素值 }
var num=[];
num["哈哈"]="happy";
num["嘻嘻"]="new";
num["呵呵"]="year";
num["呵呵呵"]="2016";
for(var i in num ){
document.write(i+" : "+num[i])}//i为key num为hash}
//输出为：哈哈 : happy嘻嘻 : new呵呵 : year呵呵呵 : 2016
js底层，一切都是hash数组:
一切全局变量，对象的属性以及数组的元素，都可用[“key”]访问。
for in循环，即可遍历索引数组，也可遍历hash数组，也可遍历对象的属性。
但for循环，只能遍历索引数组
3. 数组API: API就是别人已经实现的现成对象或方法
程序员只需要使用，不需要关心原理。
1. arr to string:
var str=String(arr); 默认用逗号分隔每个元素值
var str=arr.join(“自定义连接符”);
如果省略自定义参数，默认和String相同(用逗号“,”)
固定套路:
1. 优化字符串拼接: 2步:
Step1: 先将要拼接的子字符串放在数组中
Step2: 将数组一次性无缝拼接为字符串
无缝拼接： arr.join("");
凡是频繁字符串拼接，都要用数组.join实现
栗子：将day02 homework中所有循环中的+=拼接，改为数组.join方式实现。
2. 将数组元素拼接为页面元素：
开始标签
+arr.join("结束标签开始标签")
+结束标签
凡是批量替换父元素下所有子元素，就要先拼接为字符串，再放入innerHTML中。补上开头和结尾。
拼接：arr.concat()不修改原数组，生成新数组
返回值
返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。
var newArr=arr1.concat(值1,值2,arr2,…)
将参数中的值追加到arr1的值之后，返回新数组
参数中的数组会被打撒成单个元素，再拼接
<script type="text/javascript">
var a = [1,2,3];
document.write(a.concat(4,5));
</script>
输出：
1,2,3,4,5
<script type="text/javascript">
var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
var arr2 = new Array(3)
arr2[0] = "James"
arr2[1] = "Adrew"
arr2[2] = "Martin"
document.write(arr.concat(arr2))
</script>输出：
George,John,Thomas,James,Adrew,Martin
截取子数组: arr.slice()**含头不含尾
不修改原数组，生成新数组
从指定位置开始，到指定位置结束，截取中间的子元素，组成临时的新数组返回。
请注意，该方法并不会修改数组，而是返回一个子数组。如果想删除数组中的一段元素，应该使用方法 Array.splice()。
var subArr=arr.slice(starti,endi+1);
<script type="text/javascript">
var arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr[3] = "James"
arr[4] = "Adrew"
arr[5] = "Martin"
document.write(arr + "<br />")//输出:George,John,Thomas,James,Adrew,Martin
document.write(arr.slice(2,4) + "<br />")//输出:Thomas,James//含头不含尾
document.write(arr)// 输出: George,John,Thomas,James,Adrew,Martin//原数组值不变
</script> 一.数组API:
1. arr.splice(): 删除 插入 替换
删除: var deleted=arr.splice(starti,n)
强调: 直接修改原数组
starti是开始删除的位置
n是删除个数
deleted 接收被删除的元素组成的临时子数组
如果被删除的元素还有其他用途，就要继续保存
插入: arr.splice(starti,0,值1,值2,…)
在starti位置插入多个值
原starti位置的值向后顺移。
var arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr[3] = "James"
arr[4] = "Adrew"
arr[5] = "Martin"
document.write(arr + "<br />")
arr.splice(2,0,"William")//index2的值变成“William” 原本的值向后移变成index3的值
document.write(arr + "<br />")
</script>
输出：
George,John,Thomas,James,Adrew,Martin
George,John,William,Thomas,James,Adrew,Martin替换: var deleted=arr.splice(starti,n,值1,…);
删除的元素个数n，不一定和新值个数相等。
也就是被删除的元素个数为n，新添加的元素个数不一定为n
强调：splice方法没有打散数组参数的功能
在本例中我们将删除位于 index 2 的元素，并添加一个新元素来替代被删除的元素：
var arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr[3] = "James"
arr[4] = "Adrew"
arr[5] = "Martin"
document.write(arr + "<br />")
arr.splice(2,1,"William")
document.write(arr)
输出：
George,John,Thomas,James,Adrew,Martin
George,John,William,James,Adrew,Martin
在本例中我们将删除从 index 2 (“Thomas”) 开始的三个元素，并添加一个新元素 (“William”) 来替代被删除的元素：
<script type="text/javascript">
var arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr[3] = "James"
arr[4] = "Adrew"
arr[5] = "Martin"
document.write(arr + "<br />")
arr.splice(2,3,"William")
document.write(arr)
</script>
输出：
George,John,Thomas,James,Adrew,Martin
George,John,William,Martin二.翻转数组：arr.reverse();
var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
document.write(arr + "<br />") //输出：George,John,Thomas
document.write(arr.reverse())//输出：Thomas,John,George
数组排序:
手写冒泡排序算法:
function bubbleSort(arr) {
var i = arr.length, j;
var tempExchangVal;
while (i > 0) {
for (j = 0; j < i - 1; j++) {
if (arr[j] > arr[j + 1]) {
tempExchangVal = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tempExchangVal;
}
}
i--;
}
return arr;
}
var arr = [3, 2, 4, 9, 1, 5, 7, 6, 8];
var arrSorted = bubbleSort(arr);
console.log(arrSorted);
alert(arrSorted);//1,2,3,4,5,6,7,8,9 冒泡排序:从数组第一个元素开始
一次比较当前元素和下一个元素
如果当前元素>下一个元素
交换当前元素和下一个元素的值
- arr.sort():
默认将所有元素转为字符串PK Unicode (仅适合于对字符串内容排序)
如何自定义排序规则: 2步：
1. 自定义比较器函数: 专门比较任意两值大小的函数
要求: 1. 必须有2个参数
2. 必须返回一个数字
如果a>b，就返回正数
如果a
arr=[1,34,54,314,6544,44,52,];
function compare(a,b){return a-b;}
var result=arr.sort(compare);
document.write(result);//1,34,44,52,54,314,6544 原理: 函数也是对象
函数名其实仅是引用函数对象的变量
函数对象也可作为参数传递！不加()，只用函数名
任何情况下，函数名()都表示立刻执行函数，返回结果
执行效率: 浏览器的arr.sort方法进行过反复优化，执行效率比普通冒泡排序高的多！
所有，开发首选arr.sort(compare)
<script type="text/javascript">
function sortt(arr){
for(var i=0;i<arr.length;i++){
for(var j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){
var temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;}}}}
var arr=[1,2,5,77,55,11,845,774];
sortt(arr);
console.log(arr)
</script> 栈和队列:
js中没有专门栈和队列类型，其实都是用数组模拟的栈:一端封闭，只能从另一端进出的数组
FILO
结尾出入栈:
入: arr.push(值) 将 值 压入数组末尾
arr.push(parseInt(Math.random()*(max-min+1)+min));
上述列子为向arr数组中添加一个自然数
如需要添加多个（例子为添加10个），则需要使用for循环
for(var i=0,arr=[];i<10;i++){
arr.push(parseInt(Math.random()*(12-8+1)+8));
}
console.log(String(arr));
如果需要添加的在某个范围之间且数字不重复
如双色球（列子中为在1-33中选出6个不重复的数字）
function doubleBall(){
//声明空数组reds
var reds=[];
//反复生成红球，只要reds的length<6，就要继续
while(reds.length<6){
// 在1~33之间生成一个红球号码,保存在red中
var red=parseInt(Math.random()*33+1);
// 遍历reds中每个元素
for(var i=0;i<reds.length;i++){
//如果当前元素==red,就退出循环
if(reds[i]==red){ break; }
}//(遍历结束)
//如果i==length，就将red压入reds中
reds.push(red);
}//(循环结束)出: var last=arr.pop()
从数组 末尾 弹出1个元素
好处: 新出入栈元素，不影响其他元素的位置
开头出入栈: 入: arr.unshift(值) 将 值 插入到开头
出: var first=arr.shift();
从数组 开头 弹出第1个元素
缺点: 每出入栈一次元素，其余所有元素的位置都要改变
何时使用栈: 保证始终使用数组中最新的元素时
队列: 只能从一端进入，从另一端出
FIFO
从结尾入队列: arr.push(值)
从开头出队列: var first=arr.shift()
何时使用队列: 希望按照先来后到的顺序使用数据时
CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！
更多推荐
1
0- 0
已为社区贡献2条内容
所有评论(0)