二叉树 -- 判断两个二叉树是否相同
输入： p = [1,2,3], q = [1,2,3]
输出： true
var isSameTree = (p, q) =>{
let falg = false
if(Array.isArray(q) && Array.isArray(p)){
q.map((item,index)=>{
if( item === 'null' ){
if(q[index] == p){
falg = true
}
}else{
if(q.toString() === p.toString()){
falg = true
}
}
})
}else{
falg = false
}
return falg
}
console.log(isSameTree([1,2,3],[1,2,3]))
或者超级牛👃的JSON.stringify()
JSON.stringify(q) === JSON.stringify(p)
二叉树 -- 判断是否对称
输入： root = [1,2,2,3,4,4,3]
输出： true
// 层级 1 2 3 4 5 6 ...
// 每一个层级的节点数量 1 2 4 8 16 32 ...
// 各个层级的节点总数 1 3 7 15 31 63 ...
// 二叉树的层级树和总数的规律 Math.pow(2,level) - 1 = 总数
// 开方算法 Math.pow(81,1/4) == 3 Math.pow(9,1/2) == 9
// 这里直接用递归替代开方 （ 没有考虑性能优化）
var isSymmetric = function(root) {
let levelNum = 1
if(root.length === 1){
return true
}
if(root.length % 2 == 0){
return false
}
let listTree = [];
for(let i = 1; i<root.length ;i = i*2){
if( i == `${root.length/2 +0.5}`){
levelNum = i
break
}
//取出二叉树每一层级的节点数 （以数组形式添加）
listTree.push(root.slice(2*i-1, 2*(2*i-1)+1))
//slice左到右依次的参数 1 3 \ 3 7 \ 7 15 \ 15 31
//level层级 1 2 4 8
console.log(listTree)
}
function findTree(listTree){
let falg = true
for(let i= 0;i<listTree.length;i++){
//每一层级取左节点 和 取右节点 0,1 1,2 0,2 2,4
let left = listTree[i].slice(0, listTree[i].length/2)
let right = listTree[i].slice(listTree[i].length/2,listTree[i].length)
console.log(left,right,listTree[i].length)
if(JSON.stringify(left) !== JSON.stringify(right.reverse())){
falg = false
}
}
return falg
}
return findTree(listTree)
};
console.log(isSymmetric([1,2,2,null,3,null,3]))
// 二叉树深度 -- 递归开方 因为 2的level次方-1 等于 树节点的总数
function maxDepth(list){
let deep = list.length +1
let level = 1;
function deepLen(deeplen){
// deeplen8 level1 deeplen4 level2 deeplen2 level3
if(deeplen/2 !== 1 ){
level ++
return deepLen(deeplen/2)
}else{
return level
}
}
return deepLen(deep)
}
console.log(maxDepth([3,9,20,null,null,15,7]))
//时间复杂度 空间复杂度
// 递归
// function fun(n=1) {
// let k = 10;
// console.log(n)
// if (n == k) {
// return n;
// } else {
// return fun(++n)
// }
// }
// console.log(fun())
// let arr = [
// {id: 1, name: '部门1', pid: 0},
// {id: 2, name: '部门2', pid: 1},
// {id: 3, name: '部门3', pid: 1},
// {id: 4, name: '部门4', pid: 3},
// {id: 5, name: '部门5', pid: 4},
// ]
// 输出
// y = [
// {
// "id": 1,
// "name": "部门1",
// "pid": 0,
// "children": [
// {
// "id": 2,
// "name": "部门2",
// "pid": 1,
// "children": []
// },
// {
// "id": 3,
// "name": "部门3",
// "pid": 1,
// "children": [
// // 结果 ,,,
// ]
// }
// ]
// }
// ]
// function arrayToTree(items) {
// const result = []; // 存放结果集
// const itemMap = {}; //
// for (const item of items) {
// const id = item.id;
// const pid = item.pid;
// if (!itemMap[id]) {
// itemMap[id] = {
// children: [],
// }
// }
// itemMap[id] = {
// ...item,
// children: itemMap[id]['children']
// }
// const treeItem = itemMap[id];
// if (pid === 0) {
// result.push(treeItem);
// } else {
// if (!itemMap[pid]) {
// itemMap[pid] = {
// children: [],
// }
// }
// itemMap[pid].children.push(treeItem)
// }
// }
// return result;
//递归
// const result = []; // 存放结果集
// function pushResult(result,arr,pid){
// for (const item of arr) {
// if (item.pid === pid) {
// const newItem = {...item, children: []};
// result.push(newItem);
// pushResult(newItem.children,arr, item.id);
// }
// }
// }
// pushResult(result,arr,pid=0)
// return result
// }
// console.log( arrayToTree(arr))
// var num = prompt("判断输入一个值")
// // 质数 只能被1和 自身整除的数
// if( num === 'undefind'){
// return false
// }else{
// var falg = true
// for(var i = 2;i<num;i++){
// if(num%i === 0){
// falg = true
// }
// }
// if(falg === true){
// alert(i + "是整数")
// }
// }
//
最长子回文串与回文子串数
输入一个字符串，求出其中最长的回文子串。回文子串的含义是：正着看和倒着看是相同 假如输入edfabbebba
/**
* @param {string} s
* @return {string}
*/
var longestPalindrome = function(s) {
let len = s.length;
let result;
let i,j,L;
let dp=Array(len).fill(0).map(x=>Array(len).fill(0));
//console.log(dp);
if(len<=1){
return s
}
// 只有一个字符的情况是回文
for(i = 0;i<len;i++){
dp[i][i] = 1
result = s[i]
}
// // L是i和j之间的间隔数（因为间隔数从小到大渐增，所以大的间隔数总能包含小的间隔数）
// // i j
// // abcdcba.length = L 所以 L = j-i+1; => j = i+L-1;
// for ( L = 2; L <= len; L++) {
// // 从0开始
// for ( i = 0; i <= len - L; i++) {
// j = i + L - 1;
// if(L == 2 && s[i] == s[j]) {
// dp[i][j] = 1;
// result = s.slice(i, i + L);
// }else if(s[i] == s[j] && dp[i + 1][j - 1] == 1) {
// dp[i][j] = 1
// result = s.slice(i, i + L);
// }
// }
// }
// //console.log(result);
// return result;
// };
-------- 下面不是了 -------
// requestAnimationFrame 比起 setTimeout、setInterval的优势主要有两点：
// 1、requestAnimationFrame 会把每一帧中的所有DOM操作集中起来，在一次重绘或回流中就完成，并且重绘或回流的时间间隔紧紧跟随浏览器的刷新频率，一般来说，这个频率为每秒60帧。
// 2、在隐藏或不可见的元素中，requestAnimationFrame将不会进行重绘或回流，这当然就意味着更少的的cpu，gpu和内存使用量。
// function getJSONP(url, callback) {
// if (!url) { // url为空，则退出
// return;
// }
// // 随机生成工具函数的函数名
// var fnName = '_JSONP'+ parseInt(Math.random()*100);
// // 将这个没有赋值的函数名变成getJSONP的属性，因为函数名是以字符串形式提交，因此此处更改之后url中提交的形式为cb=getJSONP._JSONPXX。XX为两个随机生成的数字
// var jsonp_attr = 'getJSONP.' + fnName;
// // 判断url地址中是否含有'?'
// // 百度服务器JSONP回调函数key属性是'cb'，为配合下边链接，这里用'cb=',实际情况根据服务器提供的接口更改
// if (url.indexOf('?') === -1) {
// url += '?cb=' + jsonp_attr;
// }
// else{
// url += '&cb=' + jsonp_attr;
// }
// // 动态创建script标签
// var script = document.createElement('script');
// // 为script标签src属性赋值
// script.src = url;
// // 定义工具函数，并将工具函数赋给getJSONP的属性fnName
// getJSONP[fnName] = function (data) {
// try {
// // 跨域成功，通过回调函数，处理数据
// callback && callback(data);
// } catch (error) {
// //
// }
// finally{
// // 数据处理完成后，删除工具函数，以及实现跨域用的动态生成的script标签
// delete getJSONP[fnName];
// script.parentNode.removeChild(script);
// }
// }
// // 将动态生成的script标签添加到DOM，这一步发出跨域请求
// document.getElementsByTagName('head')[0].appendChild(script);
// }
// // 使用封装好的getJSONP函数
// // 获取在百度搜索栏输入"iPhone"时，自动完成功能返回的数据，注意将原来链接中回调删除
// getJSONP('https://grnx.api.storeapi.net/api/94/219?format=json&time=255513&appid=13112&sign=da90c3c6ad0ca91c5631dd3fcfd94a82', function (data) {
// console.log(data);
// });
// // const url = 'https://c.y.qq.com/musichall/fcgi-bin/fcg_yqqhomepagerecommend.fcg';
// const url = 'https://grnx.api.storeapi.net/api/94/219?format=json&time=255513&appid=13112&sign=da90c3c6ad0ca91c5631dd3fcfd94a82'
// const opts = {}
// // const opts = {
// // data: {
// // g_tk: 1928093487,
// // inCharset: 'utf-8',
// // outCharset: 'utf-8',
// // notice: 0,
// // format: 'jsonp',
// // platform: 'h5',
// // uin: 0,
// // needNewCode: 1
// // },
// // // QQ音乐接口Jsonp字段
// // param: 'jsonpCallback'
// // }
// // jsonp(url, opts)
// // .then(res => {
// // console.log(res);
// // })
// // .catch(ex => {
// // console.log(ex);
// // })
// 数组扁平化
// let arr = [ 1,2,-2,[2],[6,[-8,[-9]]]]
// let result = []
// function falt(arr){
// arr.map((item)=>{
// if(Array.isArray(item)){
// result.concat(falt(item))
// }else{
// result.push(item)
// }
// })
// return result
// }
// console.log(falt(arr))
</script>
