资讯专栏INFORMATION COLUMN

js的数据结构与算法--数组

yeyan1996 / 1050人阅读

1.创建数组
var numbers = [];
var numbers = new Array();
//在调用 Array 的构造函数时,可以只传入一个参数,用来指定数组的长度
var numbers = new Array(10)
console.log(numbers.length)// 显示 10
可以调用 Array.isArray() 来判断一个对象是否是数组
2.由字符串生成数组

1字符串对象的 split() 方法也可以生成数组

var sentence = "the quick brown fox jumped over the lazy dog";
var words = sentence.split(" ");
for (var i = 0; i < words.length; ++i) {
    print("word " + i + ": " + words[i]);
}
//该程序的输出为:
word 0: the
word 1: quick
word 2: brown
word 3: fox
word 4: jumped
word 5: over
word 6: the
word 7: lazy
word 8: dog

(1)浅复制,新数组依然指向原来的数组(当把一个数组赋给另外一个数组时,只是为被赋值的数组增加了一个新的引用。当你通过原引用修改了数组的值,另外一个引用也会感知到这个变化)

var nums = [];
for (var i = 0; i < 100; i++) {
    nums[i] = i+1;
}
var samenums = nums;
nums[0] = 400;
print(samenums[0]); // 显示 400

(2)深复制,将原数组中的每一个元素都复制一份到新数组中。

function copy(arr1, arr2) {
    for (var i = 0; i < arr1.length; i++) {
        arr2[i] = arr1[i];
    }
}
var nums = [];
for (var i = 0; i < 100; i++) {
    nums[i] = i+1;
}
var samenums = [];
copy(nums, samenums);
nums[0] = 400;
print(samenums[0]); // 显示 1
3.存取函数
JavaScript 提供了一组用来访问数组元素的函数,叫做存取函数,这些函数返回目标数组
的某种变体

查找元素

(1)indexOf(),用来查找传进来的参数在目标数组中是否存在,如果目标数组包含该参数,就返回该元素在数组中的索引;如果不包含,就返回 -1。如果数组中包含多个相同的元素,indexOf() 函数总是返回第一个与参数相同的元素的索引。
(2)lastIndexOf(),该函数返回相同元素中最后一个元素的索引,如果没找到相同元素,则返回 -1

数组的字符串表示
将数组转化为字符串:join() 和 toString(),这两个方法都返回一个包含数组所有元素的字符串,各元素之间用逗号分隔开

由已有数组创建新数组
concat() 和 splice() 方法允许通过已有数组创建新数组。concat 方法可以合并多个数组
创建一个新数组,splice() 方法截取一个数组的子集创建一个新数组。

var names = ["David", "Cynthia", "Raymond", "Clayton", "Mike", "Jennifer"];
var namestr = names.join();
print(namestr); // David,Cynthia,Raymond,Clayton,Mike,Jennifer
namestr = names.toString();
print(namestr); // David,Cynthia,Raymond,Clayton,Mike,Jennifer
4.为数组添加元素

push() 方法会将一个元素添加到数组末尾
unshift() 方法可以将元素添加在数组的开头

5.从数组中删除元素

使用 pop() 方法可以删除数组末尾的元素
shift() 方法可以删除数组的第一个元素
使用 splice() 方法为数组添加元素,需提供如下参数:
• 起始索引(也就是你希望开始添加元素的地方);
• 需要删除的元素个数(添加元素时该参数设为 0);
• 想要添加进数组的元素。

6.为数组排序

reverse(),该方法将数组中元素的顺序进行翻转
sort() 方法是按照字典顺序对元素进行排序的,因此它假定元素都是字符串类型

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

对于数字类型,该函数可以是一个简单的相减操作,从一个数字中减去另外一个数字。如
果结果为负,那么被减数小于减数;如果结果为 0,那么被减数与减数相等;如果结果为
正,那么被减数大于减数。
将这些搞清楚之后,传入一个大小比较函数,再来看看前面的例子:
function compare(num1, num2) {
return num1 - num2;
}
var nums = [3,1,2,100,4,200];
nums.sort(compare);
console.log(nums); // 1,2,3,4,100,200
sort() 函数使用了 compare() 函数对数组按照数字大小进行排序,而不是按照字典顺序。

7.迭代器方法

不生成新数组的迭代器方法
是 forEach(),该方法接受一个函数作为参数,对数组中的每个元素使用该函数。

 function square(num) {
    console.log(num, num * num);
   }
  var nums = [1,2,3,4,5,6,7,8,9,10];
  nums.forEach(square);
  //该程序的输出为:
    1 1
    2 4
    3 9
    4 16
    5 25
    6 36
    7 49
    8 64
    9 81
    10 100
every(),该方法接受一个返回值为布尔类型的函数,对数组中的每个元素使用该函数。如果对于所有的元素,该函数均返回 true,则该方法返回 true。

请输入代码
 function isEven(num) {
    return num % 2 == 0;
    }
    var nums = [2,4,6,8,10];
    var even = nums.every(isEven);
    if (even) {
        console.log("all numbers are even");
    }
    else {
         console.log("not all numbers are even");
    }
    //输出为:
    all numbers are even
some() 方法也接受一个返回值为布尔类型的函数,只要有一个元素使得该函数返回 true,
该方法就返回 true。
function isEven(num) {
return num % 2 == 0;
}
var nums = [1,2,3,4,5,6,7,8,9,10];
var someEven = nums.some(isEven);
if (someEven) {
print("some numbers are even");
}
else {
print("no numbers are even");
}
nums = [1,3,5,7,9];
someEven = nums.some(isEven);
if (someEven) {
print("some numbers are even");
}
else {
print("no numbers are even");
}
//该程序的输出为:
some numbers are even
no numbers are even

reduce() 方法接受一个函数,返回一个值。该方法会从一个累加值开始,不断对累加值和数组中的后续元素调用该函数,直到数组中的最后一个元素,最后返回得到的累加值。

 function add(runningTotal, currentValue) {
    return runningTotal + currentValue;
}
var nums = [1,2,3,4,5,6,7,8,9,10];
var sum = nums.reduce(add);
console.log(sum); // 显示 55

生成新数组的迭代器方法
map() 和 filter()
map() 返回一个新的数组,该数组的元素是对原有元素应用某个函数得到的结果

function curve(grade) {
return grade += 5;
}
var grades = [77, 65, 81, 92, 83];
var newgrades = grades.map(curve);
consoe.log(newgrades); // 82, 70, 86, 97, 88

对一个字符串数组使用 map() 方法的例子:

function first(word) {
    return word[0];
}
var words = ["for","your","information"];
var acronym = words.map(first);
print(acronym.join("")); // 显示 "fyi"

filter(),传入一个返回值为布尔类型的函数,当对数组中的所有元素应用该函数,结果均为 true 时,该方法并不返回 true,而是返回一个新数组,该数组包含应用该函数后结果为 true 的元素。

function isEven(num) {
    return num % 2 == 0;
}
function isOdd(num) {
    return num % 2 != 0;
}
var nums = [];
for (var i = 0; i < 20; ++i) {
    nums[i] = i+1;
}
var evens = nums.filter(isEven);
console.log("Even numbers: ");
console.log(evens);
var odds = nums.filter(isOdd);
console.log("Odd numbers: ");
console.log(odds);
//该程序的执行结果如下:
Even numbers:
2,4,6,8,10,12,14,16,18,20
Odd numbers:
1,3,5,7,9,11,13,15,17,19

还可以使用 filter() 方法过滤字符串数组,下面这个例子过滤掉了那些不包含
“cie”的单词

function afterc(str) {
if (str.indexOf("cie") > -1) {
return true;
}
return false;
}
var words = ["recieve","deceive","percieve","deceit","concieve"];
var misspelled = words.filter(afterc);
console.log(misspelled); // 显示 recieve,percieve,concieve
二维和多维数组 1.创建二维数组
Array.matrix = function(numrows, numcols, initial) {
var arr = [];
for (var i = 0; i < numrows; ++i) {
var columns = [];
for (var j = 0; j < numcols; ++j) {
columns[j] = initial;
}
arr[i] = columns;
}
return arr;
}
2.处理二维数组的元素

处理二维数组中的元素,有两种最基本的方式:按列访问和按行访问

//得到该学生的平均成绩
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, 78],[76, 82, 81],[91, 94, 89]];
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;
print("Test " + parseInt(col+1) + " average: " +average.toFixed(2));
total = 0;
average = 0.0;
}
//该程序的输出为:
Test 1 average: 85.33
Test 2 average: 84.33
Test 3 average: 82.67
3.参差不齐的数组
//为了给个示例,假设数组 grades 中,每个学生成绩记录的个数是不一样的,不用修改代码,依然可以正确计算出正确的平均分:
var grades = [[89, 77],[76, 82, 81],[91, 94, 89, 99]];
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;
print("Student " + parseInt(row+1) + " average: " + average.toFixed(2));
total = 0;
average = 0.0;
}
//注意第一名同学只有两门课的成绩,而第二名同学有三门课的成绩,第三名同学有四门课的成绩。因为程序在内层的 for 循环中计算了每个数组的长度,即使数组中每一行的长度不一,程序依然不会出什么问题。该段程序的输出为:
Student 1 average: 83.00
Student 2 average: 79.67
Student 3 average: 93.25
对象数组
function Point(x,y) {
this.x = x;
this.y = y;
}
function displayPts(arr) {
for (var i = 0; i < arr.length; ++i) {
print(arr[i].x + ", " + arr[i].y);
}
}
var p1 = new Point(1,2);
var p2 = new Point(3,5);
var p3 = new Point(2,8);
var p4 = new Point(4,4);
var points = [p1,p2,p3,p4];
for (var i = 0; i < points.length; ++i) {
print("Point " + parseInt(i+1) + ": " + points[i].x + ", " + points[i].y);
}
var p5 = new Point(12,-3);
points.push(p5);
print("After push: ");
displayPts(points);
points.shift();
print("After shift: ");
displayPts(points)
对象中的数组
function weekTemps() {
this.dataStore = [];
this.add = add;
this.average = average;
}
function add(temp) {
this.dataStore.push(temp);
}
function average() {
var total = 0;
for (var i = 0; i < this.dataStore.length; ++i) {
total += this.dataStore[i];
}
return total / this.dataStore.length;
}
var thisWeek = new weekTemps();
thisWeek.add(52);
thisWeek.add(55);
thisWeek.add(61);
thisWeek.add(65);
thisWeek.add(55);
thisWeek.add(50);
thisWeek.add(52);
thisWeek.add(49);
print(thisWeek.average()); // 显示 54.875

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/93757.html

相关文章

  • JS数据结构算法_排序和搜索算法

    摘要:上一篇数据结构与算法树写在前面这是学习数据结构与算法的最后一篇博客,也是在面试中常常会被问到的一部分内容排序和搜索。 上一篇:JS数据结构与算法_树 写在前面 这是《学习JavaScript数据结构与算法》的最后一篇博客,也是在面试中常常会被问到的一部分内容:排序和搜索。在这篇博客之前,我每每看到排序头就是大的,心里想着类似冒泡排序,两层遍历啪啪啪就完事了,然后再也无心去深入研究排序相...

    姘搁『 评论0 收藏0
  • 唠叨一下js对象哈希表那些事

    摘要:的扩展知识对于哈希表来说,最重要的莫过于生成哈希串的哈希算法和处理冲突的策略了。由于链表的查找需要遍历,如果我们将链表换成树或者哈希表结构,那么就能大幅提高冲突元素的查找效率。 最近在整理数据结构和算法相关的知识,小茄专门在github上开了个repo https://github.com/qieguo2016...,后续内容也会更新到这里,欢迎围观加星星! js对象 js中的对象是基...

    Nosee 评论0 收藏0
  • Deep in JS - 收藏集 - 掘金

    摘要:今天同学去面试,做了两道面试题全部做错了,发过来给道典型的面试题前端掘金在界中,开发人员的需求量一直居高不下。 排序算法 -- JavaScript 标准参考教程(alpha) - 前端 - 掘金来自《JavaScript 标准参考教程(alpha)》,by 阮一峰 目录 冒泡排序 简介 算法实现 选择排序 简介 算法实现 ... 图例详解那道 setTimeout 与循环闭包的经典面...

    enali 评论0 收藏0
  • 算法》第一章学习笔记js实现

    摘要:算法第一章学习笔记实现更多内容目标总结本书主要内容,相应算法使用来模仿实现在计算机科学领域,我们用算法这个词来描述一种有限确定有效的并适合用计算机程序来实现的解决问题的方法。 《算法》第一章学习笔记js实现 更多内容 目标:总结本书主要内容,相应算法使用js来模仿实现 在计算机科学领域,我们用算法这个词来描述一种有限、确定、有效的并适合用计算机程序来实现的解决问题的方法。我们关注的大多...

    baishancloud 评论0 收藏0
  • 算法》第一章学习笔记js实现

    摘要:算法第一章学习笔记实现更多内容目标总结本书主要内容,相应算法使用来模仿实现在计算机科学领域,我们用算法这个词来描述一种有限确定有效的并适合用计算机程序来实现的解决问题的方法。 《算法》第一章学习笔记js实现 更多内容 目标:总结本书主要内容,相应算法使用js来模仿实现 在计算机科学领域,我们用算法这个词来描述一种有限、确定、有效的并适合用计算机程序来实现的解决问题的方法。我们关注的大多...

    K_B_Z 评论0 收藏0
  • 算法》第一章学习笔记js实现

    摘要:算法第一章学习笔记实现更多内容目标总结本书主要内容,相应算法使用来模仿实现在计算机科学领域,我们用算法这个词来描述一种有限确定有效的并适合用计算机程序来实现的解决问题的方法。 《算法》第一章学习笔记js实现 更多内容 目标:总结本书主要内容,相应算法使用js来模仿实现 在计算机科学领域,我们用算法这个词来描述一种有限、确定、有效的并适合用计算机程序来实现的解决问题的方法。我们关注的大多...

    qingshanli1988 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<