js算法和数据结构

js数组操作

增删

//增
arr.push(3); //尾部添加(参数不能是数组)
arr[arr.length]=4; //尾部添加
arr.unshift(0); //头部添加
arr.splice();  //在指定位置增加
//删
delete arr[2]; //删除指定变为undefine
arr.length-=1; //移除尾部元素
arr.pop(); //移除尾部元素
arr.shift(); //移除头部元素
arr.splice(); //删除指定几个元素(或删+增)

arr.indexOf(2,-1); //

数组方法

//转化
arr.join();//数组转化为字符串并指定分隔符(默认为,)
str.split(''); //字符串转化为数组
//排序(逆序,升序,降序)
arr.reverse();//将数组逆序
arr.sort(); //数组元素为字母及字符串升序排序
arr.sort(function(a,b){return a-b;}); //数组元素为数字的升序排序
arr.sort(function(a,b){return b-a;}); //数组元素为数字的降序排序
arr.sort(function(a,b){return a.age-b.age;}); //数组元素为对象的升序排序
//合并
arr.concat([[1,2],3])//数组合并(原数组未被改变，数组拉平一次)
//遍历
arr.forEach(function(x,index,a){
    console.log(x+'|'+index+'|'+a===arr) //获取键值对
});
for(v in arr){//} //获取键名
for(v of arr){//} //获取键值
//映射
arr.map(function(x){
    return x+10  //映射到每一个元素并返回(原数组不会改变)
});
//过滤
arr.filter(function(x,index){
    return index%3===0||x>8 //返回符合条件的元素
});
//拼接(删除,插入,替换)
arr.splice(1,2) //从index为1开始删除2个元素并拼接剩下的元素
arr.splice(1,1,'a','b') //删除>插入>拼接
//判断
arr.every(function(x){
    return x>5  //判断是否有元素大于5,返回ture/false
})
arr.some(function(x){
    return x===5  //判断是否有元素等于5,返回ture/false
})
//检索
arr.indexOf(1,2); //从索引值为2开始查找返回第一个值为1的元素的索引，没有匹配值则返回-1
arr.lastIndexOf(1,2) //从索引值为2开始查找返回最后一个值为1的元素的索引
//截取
arr.slice(2,-1);//返回指定首尾数组片段(原数组不修改)
//判断是否为数组
Array.isArray(arr);
arr indexOf Array;
({}).toString.apply(arr)===[Object Array];
arr.constructor===Array;

ES6数组方法

1.Array.from

将部署了Interator接口的数据结构转化为数组

//NodeList
let ps=document.querySelectAll('p'); //NodeList集合(返回的是类似数组的对象)
Array.from(ps).filter(p => {
    return p.textContent.length>100
});  
//argument
() => {
    const args = Array.from(arguments) //2.将函数内部的argument对象转化为数组
}
//有length属性的对象
Array.from({length:3}) //[undefine,undefine,undefine]
//字符串
Array.from('hello');
//Set
let nameSet=new Set(['a','b']);
Array.from(nameSet);

进行数组循环处理

Array.from([1,2,3],x=>x*x)

2....用作转换为数组的操作

//1.arguments转化为数组
() => {
   const args = [...arguments]
}
//2.NodeList转化为数组
[...deocument.QuerySelectorAll('p')]

算法题

反转字符串 

let arr=s.split(''); //转为数组
let arr2=arr.reverse(); //数组反转
let str=arr2.join(''); //数组转为字符串

lat str=s.split('').reverse().join('');

 

数据结构和算法

数据结构

//栈

//队列

//链表

//集合
类似于数组，但成员值不重复，ES6中Set就是类似集合的数据结构
//字典

//散列

//树

//图

算法

n较小：插入排序，选择排序

n较小且初始状态基本有序时：插入排序

初始状态基本有序：插入排序，冒泡排序，快速排序

n较大：堆排序，快速排序，归并排序

n较大且初始状态基本有序时：快速排序（性能好）

n较大且稳定：归并排序

 

排序算法

选择排序 

选择排序：

function selectionSort(arr){
    let indexMin;
    for(i=0;i<arr.length-1;i++){
        indexMin=i
        for(j=i;j<arr.length;j++){
            if(arr[indexMin]>arr[j]){
                indexMin=j
            }
        }
        if(i!==indexMin){
            let tem=arr[i];
            arr[i]=arr[indexMin];
            arr[indexMin]=tem
        }
        
    }
    return arr;
}
arr1=[3,2,1,5,4];
selectionSort(arr1);
console.log(arr)

 插入排序：和前面的一一对比

function insertionSort(arr){
  for(i=1;i<arr.length;i++){
    let temp=arr[i];
    let j=i;
    while( j>0&&arr[j-1]>temp){
      arr[j]=arr[j-1];
      j--
    }
    arr[j]=temp;
  }
  return arr;
}

arr1=[2,3,1,4,5]; //数据
insertionSort(arr1); //调用
console.log(arr1); //检测

//归并排序

//快速排序

冒泡排序

冒泡排序：每一轮循环从第一个数开始，相邻元素两两相比，小的数放前面（交换/不交换），一轮循环确定一个数

function bubbleSort(arr){
	for(i=1;i<arr.length;i++){
		for(j=0;j<arr.length-i;j++){
        if(arr[j]>arr[j+1]){
        	let temp=arr[j];
        	arr[j]=arr[j+1];
        	arr[j+1]=temp;
        }
		}
	}
	return arr
}
arr1=[];
bubbleSort(arr1);
console.log(arr1)

归并排序

快速排序 

2.搜索算法

//顺序搜索

//二分搜索

3.其他

//贪心算法

//动态规划