js用到的算法

1.对象数组中，对象中有对象，数组根据对象中的对象打平

[{indexValueMap: { '68443': 0, '68457': 0 },rowName1: '固定收益类',rowName2: '交易类',rowName3: '次级'},{indexValueMap: { '68443': 0, '68457': 0 },rowName1: '固定收益类',rowName2: '交易类',rowName3: '中期'},{indexValueMap: { '68443': 0, '68457': 0 },rowName1: '权益类',rowName2: '',rowName3: 'A股'},{indexValueMap: { '68443': 0, '68457': 0 },rowName1: '权益类',rowName2: '',rowName3: '港股'}
]
[{ '68443': 0, rowName1: '固定收益类', rowName2: '交易类', rowName3: '次级' },{ '68457': 0, rowName1: '固定收益类', rowName2: '交易类', rowName3: '次级' },{ '68443': 0, rowName1: '固定收益类', rowName2: '交易类', rowName3: '中期' },{ '68457': 0, rowName1: '固定收益类', rowName2: '交易类', rowName3: '中期' },{ '68443': 0, rowName1: '权益类', rowName2: '', rowName3: 'A股' },{ '68457': 0, rowName1: '权益类', rowName2: '', rowName3: 'A股' },{ '68443': 0, rowName1: '权益类', rowName2: '', rowName3: '港股' },{ '68457': 0, rowName1: '权益类', rowName2: '', rowName3: '港股' }
]

方法：使用JavaScript的数组方法 .reduce() 来解决这个问题。.reduce() 方法在数组中的每个元素上执行一个reducer函数，并返回一个单一的输出值。

这段代码首先将原始数组array中的每一项curr中的indexValueMap的键值对作为对象推入累积器数组acc中。然后将每一项的其他属性rowName1, rowName2, rowName3添加到这个对象中。最后返回累积器数组，得到的结果就是你希望得到的形式。

let array = [  // ...你的原始数组  
];  let result = array.reduce((acc, curr) => {  for (let key in curr.indexValueMap) {  acc.push({  [key]: curr.indexValueMap[key],  rowName1: curr.rowName1,  rowName2: curr.rowName2,  rowName3: curr.rowName3,  });  }  return acc;  
}, []);  console.log(result);

function flattenArray(arr: any) {let result: any = [];arr.forEach((obj: any) => {let indexValueMap = obj.indexValueMap;let newObj = { ...obj }delete newObj.indexValueMaplet newArr = []for (let key in indexValueMap) {let tempObj = JSON.parse(JSON.stringify(newObj))tempObj[key] = indexValueMap[key]newArr.push(tempObj)}result.push(newArr)})result = result.flat(1)return result;
}

2.树形结构数组，其中层级不一定，获取数组中最大的层级

这个问题的解决需要一个深度优先遍历（DFS）的算法。

getMaxLevel函数会遍历给定的数据数组，并使用深度优先搜索找出最大的层级。它在遍历每个节点时都会检查是否存在children属性，如果存在，则层级加一，并对每个子节点进行同样的处理。在遍历过程中，它会持续更新最大的层级数。最后，它会返回最大的层级数。

需要注意的是，这个函数假设给定的数据数组的结构是一致的，即每个对象都有labelName、children和indexValueMap属性，且children是一个对象数组。如果数据结构可能有所不同，你可能需要添加一些错误处理代码。

function getMaxLevel(data) {  let maxLevel = 0;  function dfs(node, level) {  if (node.children) {  level++;  for (let child of node.children) {  dfs(child, level);  }  }  maxLevel = Math.max(maxLevel, level);  }  for (let item of data) {  dfs(item, 0);  }  return maxLevel;  
}  let data = [/* Your data */];  
console.log(getMaxLevel(data));

3.对象数组中，去除key值包含某个字符串的元素

 let flatArr = getFlattenArr(arr, 'indexMap')

//根据indexValueMao展开表格前去掉多余数据
function getFlattenArr(arr: any, delKey: any) {arr.map((obj: any) => {const keys = Object.keys(obj);keys.forEach((k) => {if (k.startsWith(delKey)) {delete obj[k]}})return obj});return arr
}

4.通过两个栈实现一个队列

栈和队列是两种常见的数据结构。栈遵循 LIFO（后进先出）原则，而队列遵循 FIFO（先进先出）原则。可以通过两个栈来实现一个队列。

class Queue {  constructor() {  this.stack1 = [];  this.stack2 = [];  }  enqueue(element) {  this.stack1.push(element);  }  dequeue() {  if (this.stack2.length === 0) {  while (this.stack1.length > 0) {  this.stack2.push(this.stack1.pop());  }  }  return this.stack2.pop();  }  
}

while() 是一个函数，而不是一个语句。它用于在满足某个条件的情况下反复执行代码块。

while() 函数的语法如下：

while (condition) {  // code to be executed while the condition is true  
}

在这个语法中，condition 是一个表达式，它会在每次循环迭代之前进行评估。如果 condition 的值为 true，则执行循环体内的代码；否则，循环会终止。

5.二叉树中，有三种常见的遍历方式：前序遍历、中序遍历和后序遍历。

1. 前序遍历 (Preorder Traversal)

在前序遍历中，首先访问根节点，然后递归地访问左子树，最后访问右子树。

function preorderTraversal(root) {  const result = [];  function helper(node) {  if (node === null) return;  result.push(node.value); // 访问根节点  helper(node.left);       // 递归访问左子树  helper(node.right);      // 递归访问右子树  }  helper(root);  return result;  
}

1. 中序遍历 (Inorder Traversal)

在中序遍历中，首先递归地访问左子树，然后访问根节点，最后递归地访问右子树。

function inorderTraversal(root) {  const result = [];  function helper(node) {  if (node === null) return;  helper(node.left);       // 递归访问左子树  result.push(node.value);  // 访问根节点  helper(node.right);       // 递归访问右子树  }  helper(root);  return result;  
}

1. 后序遍历 (Postorder Traversal)

在后序遍历中，首先递归地访问左子树，然后递归地访问右子树，最后访问根节点。

function postorderTraversal(root) {  const result = [];  function helper(node) {  if (node === null) return;  helper(node.left);       // 递归访问左子树  helper(node.right);       // 递归访问右子树  result.push(node.value);  // 访问根节点  }  helper(root);  return result;  
}

前序：1245367

中序：4251637

后序：4526731

四大算法：分治、回溯、贪心、动规

分治法是一种将问题划分为小规模子问题的算法设计策略。分治法通过将问题划分为更小的部分，然后分别解决这些子问题，最后将这些子问题的解合并以得到原始问题的解。分治法的主要步骤包括：分解、解决、合并。

一个著名的使用分治法设计的算法是快速排序。在快速排序中，我们选择一个基准元素，然后将数组划分为两个子数组：一个包含所有小于基准的元素，另一个包含所有大于或等于基准的元素。然后我们对这两个子数组递归地应用快速排序。

回溯法是一种通过探索所有可能的候选解来找出所有的解的算法。回溯算法会检查每一步决策是否正确，并“回溯”或撤销先前的决策，然后继续探索其他可能的决策。这种算法通常用于解决组合优化问题，如八皇后问题、图的着色问题、旅行商问题等。

一个典型的回溯算法的实现通常包括：一个递归函数，该函数通过调用自身来处理子问题，以及一个“剪枝”函数，该函数用于排除那些不可能是最优解的候选解。

ex1:回溯法-归并排序

Math.floor() 是JavaScript的一个内置函数，用于返回小于或等于一个给定数字的最大整数。换句话说，它向下取整。

Math.floor(3.7); // 返回 3  
Math.floor(3.8); // 返回 3  
Math.floor(-3.7); // 返回 -4  
Math.floor(-3.8); // 返回 -4

  function mergeSort(arr){ if(arr.length === 1) return arrconst midIdx = Math.floor(arr.length /2) return merge(mergeSort(arr.slice(0,midIdx)), mergeSort(arr.slice(midIdx)))}// [1,3,5,7]--[2,4,6,8,9]function merge(leftArr, rightArr) {let temp = []while(leftArr.length>0 && rightArr.length>0){if(leftArr[0]<rightArr[0]){temp.push(leftArr.shift())}else{temp.push(rightArr.shift())}} return temp.concat(leftArr).concat(rightArr) }let arr = [1,8,3,9,5,4,6,2,7]console.log(mergeSort(arr)) //[1,2,3,4,5,6,7,8,9]

function mergeSort(arr) {  // 如果数组只有一个元素，直接返回  if (arr.length <= 1) {  return arr;  }  // 将数组分成两部分，分别进行递归排序  const mid = Math.floor(arr.length / 2);  const left = arr.slice(0, mid);  const right = arr.slice(mid);  return merge(mergeSort(left), mergeSort(right));  
}  function merge(left, right) {  // 合并两个有序数组  const result = [];  let i = 0;  let j = 0;  while (i < left.length && j < right.length) {  if (left[i] < right[j]) {  result.push(left[i]);  i++;  } else {  result.push(right[j]);  j++;  }  }  // 将剩余元素添加到结果数组中  while (i < left.length) {  result.push(left[i]);  i++;  }  while (j < right.length) {  result.push(right[j]);  j++;  }  return result;  
}

ex2:分治-求平方根

ex3:分治-快排