第二周晨考自测2.0

1.冒泡排序

冒泡排序是数组解构中的常见排序算法之一。规则如下：先遍历数组，让相邻的两个数据进行比较，如果前一个比后一个大，那么就把这两个数据交换位置，经过一轮遍历之后，最大的那个数字就排在数组最后的索引位置，然后进行第二次遍历，按照相同的规则，最终将第二大的数字排在倒数第二的索引位置，同理，经过多次排序，最终将数组按照从小到大的顺序进行展示（认为规定是正向冒泡还是反向冒泡，反向冒泡最终可以从大往小的顺序排序）

代码实现：

1.  
   for(var j=0;j<arr.length; j ){
2.  
   for(var i=0;i<arr.length;i ){
3.  
   if(arr[i]>arr[i 1]){
4.  
   var tmp=arr[i]
5.  
   arr[i]=arr[i 1]
6.  
   arr[i 1]=tmp
7.  
   }}}

代码优化思路：

当进行第一次遍历时，假设数组的长度为9，那么排列8次就可以得到最大值，所以在外层的循环可以优化为arr.length-1

在第一次遍历结束后，已经找到了最大值并排列在最后的位置，那么我们在第二次循环遍历时，就不需要对比最后一个的最大值，同理，第三次不需要对比最后两个已经拍好的最大值等等。就会呈现一个规律：内循环的遍历次数是外循环遍历次数-1，比如外层为j，那么内层就减少j-1.故内层循环中的结束条件可以优化为：arr.length-1-j

故优化后的代码：

1.  
   for(var j=0;j<arr.length-1; j ){
2.  
   for(var i=0;i<arr.length-1-j;i ){
3.  
   if(arr[i]>arr[i 1]){
4.  
   var tmp=arr[i]
5.  
   arr[i]=arr[i 1]
6.  
   arr[i 1]=tmp
7.  
   }}}

2.选择排序

3.数组常用方法

（1）arr.push()  从数组的末尾添加数据

（2）arr.pop()从数组的末尾删除数据

（3）arr.unshift()从数组的头部添加数据

（4）arr.shift()从数组的头部删除数据

（5）arr.splice(开始索引，删除个数，替换的数据1，替换的数据2...) 删除并替换数组中的数据

（6）arr.slice（开始索引，结束索引）包前不包后（包括开始索引，不包括结束索引），截取数组

（7）arr.reverse()反转数组

（8）arr.concat()拼接数组

（9）arr.join()将数组转换成字符串，并用括号中的内容进行拼接

（10）arr.indexOf(数据，开始索引)查找数组，从指定索引开始   （正序）

（11）arr.lastIndexOf(数据，开始索引)查找数组，从指定索引开始（逆序）

（12）arr.sort()排序数组，默认以ASCII编码的方式进行排序

（13）arr.sort(a,b){return a-b}以递增的方式进行排序

（14）arr.sort(a,b){return b-a}以递减的方式进行排序

（15）arr.forEach(function(item,index,arr){})遍历数组

item:数组中的每一项

index:数组中的每一项的索引

arr:原数组

（16）arr.map(function(item,index,arr){return }) 映射数组，以return的形式

（17）arr.filter(function（item,index,arr）{return})过滤数组，将满足条件的数据以一个新数组的形式返回

（18）arr.some(function(item,index,arr){return})过滤数组，返回结果为布尔值，只要一个条件为真则为真，全部为假则为假

（19）arr.every(function(item,index,arr){return})过滤数组，返回结果为布尔值，只要一个条件为假则为假，全部为真则为真

（20）arr.find(function（item,index,arr）{return})过滤数组，将满足条件的第一个数据返回

（21）arr.findIndex(function(item,index,arr){return})过滤数组，将满足条件的第一个数据的索引返回

（22）arr.reduce(function(prev,item,index,arr){return},初始值)累加数组

4.数组去重

（1）排序让相同的元素挨着，通过遍历删除相同的

arr.sort(function(a,b){ return a-b})             for(var i=0;i<arr.length-1;i  ){//判断当前的元素和后面的元素是否相等 如果相等就删除掉  if(arr[i]===arr[i 1]){arr.splice(i,1) //防止塌陷  i--}}

（2）利用双重for循环来实现

//循环遍历原数组   for(var i=0; i<arr.length-1; i ){//再次循环 让前面的元素和后面的元素再次比较 for(var j=i 1; j<arr.length-1; j ){ if(arr[i]===arr[j]){//如果后面还有相同的数字就删除掉   arr.splice(j,1)  //防止坍塌  j--}}}

（3）接祖一个新数组以及数组的indexOf方法来实现

var newArr=[] for(var i=0;i<arr.length-1;i ){//判断新数组有没有原数组中的数据，如果没有就添加进去if(newArr.indexOf(arr[i])===-1){//添加元素到新数组中 newArr.push(arr[i])}}

（4）借助forEach来实现

arr.forEach(function(item){if (newArr.indexOf(item===-1){newArr.push(item)})})

（5）直接判断元素数组，检测当前元素后面有没有相同的元素，有就删除掉

for (var i=0;i<arr.length; i ){//拿到后面元素的索引  var index=arr.indexOf(arr[i],i 1)  //判断后面的元素是不是还有相同的  if(index! == -1){//说明后面还有  arr.splice(i, 1)  //放置塌陷  i--}}

（6）借助一个对象的特性来实现，因为对象里面的键名不能重复

for(var i=0; i<arr.length; i ){ var item=arr[i] // item 就是数组内的每一个数据   //把item当做key添加到对象内   obj[item]='随便数据'}  //准备一个新的数组  var newArr=[]  //循环遍历对象  for( var k in obj){// 把每一个 k添加到 newArr里面 newArr.push(k-0)}

（7）借助Set构造函数

// Set是ES6里面的一个数据类型  //功能：Set对象是值的集合，你可以按照插入的顺序迭代它的元素。  Set中的元素只会出现一次，即Set中的元素是唯一的   var arr1=new Set(arr)   //返回的是个对象的结构    //把对象转化成数组 var arr2=Array.from(arr1)   

（8）通过ES6的扩展运算符来实现

var arr1=new Set(arr)  //通过ES6的一个新语法扩展运算符来实现  var result=[...arr1]  

这篇好文章是转载于：学新通技术网