Javascript数据结构和算法

一.数组

1.添加元素

• 向数组开头添加元素

 // unshift()方法
 const numbers = [1,2,3]
 numbers.unshift(0)
 console.log(numbers) //[0,1,2,3]

• 向数组末尾添加元素

 // push()方法

2.删除元素

• 删除数组末尾元素

 // pop()方法
 let numbers = [1,2,3,4,5]
 numbers.pop()
 console.log(numbers) //[1,2,3,4]

pop()和push()方法组合，可以模拟实现栈结构出栈和进栈

• 删除数组开头元素

 // shit()
 let numbers = [1,2,3,4,5]
 numbers.shift()
 console.log(numbers) //[2,3,4,5]

shift()和unshift()方法组合，可以模拟实现基本的队列结构

3.在任意位置添加和删除元素

 // splice()方法
 //splice(start,deleteCount,item1,item2,itemN)
 let numbers = [1,2,3,4,5,6]
 numbers.splice(0,1) //[2,3,4,5,6]
 numbers.splice(2,2) //[1,2,5,6]
 numbers.splice(2,0,5,6) //[1,2,5,6,3,4,5,6]

4.二维数组和多维数组

javascript没有矩阵，只能嵌套数组模拟

 let numbers =[
     [1,2,3],
     [4,5,6],
     [7,8,9]
 ]

5.数组的一些常用方法

• concat

 //concat(value0, value1, /* … ,*/ valueN) 创建了一个新的数组
 let arr1 = [1,2,3,4]
 let arr2 = [5,6,7,8]
 let arr3 = arr1.concat(arr2)
 //输出arr3为[1,2,3,4,5,6,7,8]

• filter

 //filter(callbackFn, thisArg)
 //callbackFn 为数组中的每个元素执行的函数。它应该返回一个真值以将元素保留在结果数组中，否则返回一个假值
 //thisArg 执行 callbackFn 时用作 this 的值
 let arr1 = [1,2,3,4,5,6,7,8]
 let arr2 = arr1.filter(number=>number>4)
 //输出arr2为[5,6,7,8]

• every

 //every(callbackFn, thisArg)
 //callbackFn 为数组中的每个元素执行的函数。它应该返回一个真值以指示元素通过测试，否则返回一个假值
 //thisArg 执行 callbackFn 时用作 this 的值
 let checkNumber = (number)=>number<10
 let arr = [1,2,3,4,5,6,7,8]
 console.log(arr.every(checkNumber)) //true

• forEach

 //forEach(callbackFn, thisArg)
 //callbackFn 为数组中每个元素执行的函数。并会丢弃它的返回值
 //thisArg 执行 callbackFn 时用作 this 的值
 let arr = [1,2,3]
 arr.forEach(element=>console.log(element))
 //输出1
 //输出2
 //输出3

• join

 //join(separator)
 let arr = ['a','b','c','d']
 let str = arr.join() //'a,b,c,d'
 let str = arr.join('') //'abcd'

• indexOf

 //indexOf(searchElement, fromIndex)
 //searchElement 数组中要查找的元素
 //fromIndex 开始搜索的索引（从零开始），会转换为整数
 let arr = ['apple','banana','orange','strawberry']
 let fruit = 'banana'
 let fruitInArr = arr.indexOf(fruit) // 1
 let fruitInArr1 = arr.indexOf(fruit,2) // -1

• lastIndexOf

 //lastIndexOf(searchElement, fromIndex)
 //searchElement 数组中要查找的元素
 //fromIndex 以 0 起始的索引，表明反向搜索的起始位置，会被转换为整数。
 let arr = ['apple','banana','orange','strawberry','apple']
 let fruit = 'apple'
 let fruitInArr = arr.lastIndexOf(fruit) // 4

• map

 //map(callbackFn, thisArg)
 //callbackFn 为数组中的每个元素执行的函数。它的返回值作为一个元素被添加为新数组中
 //thisArg 执行 callbackFn 时用作 this 的值
 let arr = [
     {id:102,value:'apple'}, {id:103,value:'banana'}, {id:104,value:'orange'},     
     {id:105,value:'strawberry'}, {id:106,value:'pear'}, {id:107,value:'cherry'}
 ]
 let arr1 = arr.map(item=>{
     return item.id
 }) //[102,103,104,105,106,107]
 let arr2 = arr.map(item=>{
     return item.id%3==0
 }) //[true,false,false,true,false,false]
 let arr3 = arr.map(item=>{
     if(item.id%3 == 0){
         return item
     }
 }) //[{id:102,value:'apple'},undefined,undefined,{id:105,value:'strawberry'},undefined,undefined]
 const arrFn = () => {
   let arr4 = [];
   arr.map(item => {
     if (item.id % 3 == 0) {
       arr4.push(item);
     }
   });
   return arr4;
 }; //[{id:102,value:'apple'},{id:105,value:'strawberry'}]

• reverse

颠倒数组中元素的顺序

 //reverse() reverse() 方法就地反转数组中的元素，并返回同一数组的引用
 let arr = ['one','two','three']
 let arr1 = arr.reverse() // ['three','two','one']
 console.log(arr) // ['three','two','one']

• slice

 /**
 *slice(start, end)
 *start 提取起始处的索引（从 0 开始)
 *如果索引是负数，则从数组末尾开始计算——如果 start < 0，则使用 start + array.length
 *如果 start < -array.length 或者省略了 start，则使用 0
 *如果 start >= array.length，则不提取任何元素
 *end 提取终止处的索引（从 0 开始），会转换为整数。slice() 会提取到但不包括 end 的位置
 *如果索引是负数，则从数组末尾开始计算——如果 end < 0，则使用 end + array.length
 *如果 end < -array.length，则使用 0
 *如果 end >= array.length 或者省略了 end，则使用 array.length，提取所有元素直到末尾
 *如果 end 在规范化后小于或等于 start，则不提取任何元素
 */
 ​
 let arr = ['apple','banana','orange','strawberry','apple','pear']
 let arr1 = arr.slice(2) //['orange','strawberry','apple','pear']
 let arr2 = arr.slice(2,3) //['orange']
 let arr3 = arr.slice(-1) //['pear']
 let arr4 = arr.slice(2,-1) // ['orange','strawberry','apple']
 let arr5 = arr.slice() //['apple', 'banana', 'orange', 'strawberry', 'apple', 'pear']

• some

对数组中的每个元素运行给定的函数，如果任一元素返回true，则返回true

 //some() 方法测试数组中是否至少有一个元素通过了由提供的函数实现的测试。如果在数组中找到一个元素使得提供的函数返回 true，则返回   true；否则返回 false。它不会修改数组。
 let arr = [1,2,3,4,5]
 const even = (element)=>element % 2 === 0
 let isEven = arr.some(even) // true