算法学习一起学算法～二分查找 leetcode 题目二分查找 35.搜索插入位置(opens new window)

一起学算法～

扁平结构转tree


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 },
];

const getTreeData2 = (tree) => {
  const map = {};
  const res1 = [];
  tree.forEach((item) => {
    map[item.id] = item;
  });
  tree.forEach((item) => {
    // 找到他的父节点
    const parent = map[item.pid];
    if (parent) {
      // 找到父节点，将这个item 放到父节点的children 下面
      (parent.children || (parent.children = [])).push(item);
    } else {
      // 直接放入
      res1.push(item);
    }
  });
  return res1;
};

getTreeData2(arr);

javaScript 中的dfs和bfs

在项目中常常遇到树形的数据结构，然后去找到里面的某一条数据，这里我们常常会使用递归查找，也可以使用深度优先遍历或者广度优先遍历

const trees = {
  name: 'test',
  children: [
    {
      name: '北京',
      children: [
        {
          name: '朝阳群众',
          children: [
            {
              name: '西宁市',
              code: '0521',
            },
          ],
        },
        {
          name: '海淀区',
        },
        {
          name: '昌平区',
        },
      ],
    },
    {
      name: '浙江省',
      children: [
        {
          name: '杭州市',
          code: '0571',
        },
        {
          name: '嘉兴市',
        },
        {
          name: '绍兴市',
        },
        {
          name: '宁波市',
        },
      ],
    },
  ],
};

// 递归
const getNode = (tree, name) => {
  if (tree.name === name) return tree;
  if (!tree.name && !tree.children) return null;
  for (const i in tree.children) {
    const results = getNode(tree.children[i], name);
    if (results) {
      return results;
    }
  }
};

// 深度优先，先进后出（在一个栈里面先按深度依次入栈然后出栈）
const dfsNode = (tree, name) => {
  const stack = [];
  stack.push(tree);
  while (stack.length !== 0) {
    const current = stack.pop();
    if (current.name === name) {
      return current;
    }
    if (current.children && current.children.length !== 0) {
      for (let i = 0; i < current.children.length; i++) {
        stack.push(current.children[i]);
      }
    }
  }
};

// 广度优先，利用队列，先进先出，按照层级进行遍历，将childer 依次放到队列中

const bfsNode = (tree, name) => {
  const queue = [];
  let result = {};
  queue.push(tree);
  while (queue.length !== 0) {
    const current = queue.shift();
    if (current.name === name) {
      result = current;
      break;
    }
    if (current.children && current.children.length !== 0) {
      for (let i = 0; i < current.children.length; i++) {
        queue.push(current.children[i]);
      }
    }
  }
  return result;
};

console.log(getNode(trees, '朝阳群众'));
console.log(dfsNode(trees, '朝阳群众'), '-->dfs');
console.log(bfsNode(trees, '朝阳群众'), '-->bfs');

二分查找

1.数组为有序数组 (生序或者降序) 2.数组中没有重复元素

/**
 *
 *  二分查找
 *  前提条件
 *  1. 数组为有序数组 (生序或者降序)
 *  2. 数组中没有重复元素
 *
 */
let arr = [5, 4, 3, 2, 1];

const search = (target, nums) => {
  let left = 0;
  let right = nums.length - 1;

  while (left <= right) {
    let middle = Math.floor((right + left) / 2);
    if (nums[middle] > target) {
      right = middle - 1; // 升序
      // left = middle + 1;
    } else if (nums[middle] < target) {
      left = middle + 1; // 升序
      // right = middle - 1;
    } else {
      return middle;
    }
  }

  return -1;
};

search(5, arr);

leetcode 题目