算法面试题

leetcode中141. 环形链表

标记法
给遍历过的节点打记号，如果遍历过程中遇到有记号的说明已环🤓
 

const hasCycle = function(head) {
  while (head) {
    if (head.tag) {
      return true;
    }
    head.tag = true;
    head = head.next;
  }
  return false;
};

每个被访问过的节点都保存于数组中，在每次访问一个节点的时候与数组内已访问的节点比对，若已经存在，则有环
若最终访问完链表退出循环，则说明无环 

var hasCycle = function(head) {
    let arry = [];
    while(head){
        if(arry.includes(head)) return true;
        else {
            arry.push(head);
            head = head.next;
        }
    }
    return false;
};

将数组转成树结构

const arr = [
    {id: 1, name: '部门A', parentId:0},
    {id: 2, name: '部门B', parentId:1},
    {id: 3, name: '部门C', parentId:1},
    {id: 4, name: '部门D', parentId:2},
    {id: 5, name: '部门E', parentId:2},
    {id: 6, name: '部门F', parentId:3},
]
function covert(arr) {
    let mapTree = new Map;
    let root = null;
    for(let item of arr) {
        let {id, parentId, name} = item;
        let treeNode = {id, name} // 地址不变 但是内容会变
        mapTree.set(id, treeNode); 
        let parentNode = mapTree.get(parentId)
        if(parentNode) {
            if(!parentNode.children) parentNode.children = [];
            parentNode.children.push(treeNode)
        }
        if(parentId == 0) {   
            root = treeNode
        }
    }
    return root
}

 将树转成数组结构（注意结果要求是广度还是深度的）

let tree = [
    {
      id: "1",
      name: "节点1",
      children: [
        {
          id: "1-1",
          name: "节点1-1",
        },
      ],
    },
    {
      id: "2",
      name: "节点2",
      children: [
        {
          id: "2-1",
          name: "节点2-1",
        },
        {
          id: "2-2",
          name: "节点2-2",
          children: [
            {
              id: "2-2-1",
              name: "节点2-2-1",
            },
          ],
        },
      ],
    },
    {
      id: "3",
      name: "节点3",
    },
  ];
// 深度优先遍历 比较简单
function covert(arr, newArr = []) {
  for(let obj of arr) {
    newArr.push({ id: obj.id, name: obj.name });
    if (obj.children) {
        covert(obj.children, newArr);
      }
  }
  return newArr;
}
console.log(covert(tree));


// 广度优先遍历 复杂一些
var arr = [];
function covert(data) {
  for (var i = 0; i < data.length; i++) {
    arr.push({id: data[i].id , name: data[i].name});
    if (data[i].children) {
      data.push(...data[i].children); // 入队 这个方法很巧妙
    }
  }
  return arr;
}
console.log(covert(tree))