Day5.二叉树相关

二叉树的层序遍历/广度优先遍历

循环解法思路

先输出的父节点会先输出子节点

先进先出-用一个队列来辅助处理。

1. 初始化：将根节点放入队列
2. 循环条件：队列不为空
3. 循环操作：将队首元素的左右节点分别放入队列，将队首元素取出

实现

function levelTravel(obj) {
  let arr = []
  let result = []
  // 初始化进入循环的条件
  arr[0] = obj
  // 循环的条件
  while (arr.length > 0) {
    if (arr[0].left) {
      arr.push(arr[0].left)
    }
    if (arr[0].right) {
      arr.push(arr[0].right)
    }
    let head = arr.shift()
    result.push(head.value)
  }
  return result
}
let o = {
  value: 3,
  left: {
    value: 1,
    left: {
      value: 4,
    },
  },
  right: {
    value: 5,
  },
}
const arr = levelTravel(o)
console.log(arr)

二叉树的深度优先遍历

递归解法思路

1. 公式：深度遍历一棵树=遍历自己+遍历左子树+遍历右子树
2. 递归条件：当前节点不不为空

实现：

let result = []
function DFS(obj) {
  if (!obj) {
    return result
  } else {
    result.push(obj.value)
    DFS(obj.left)
    DFS(obj.right)
  }
}
let o = {
  value: 3,
  left: {
    value: 1,
    left: {
      value: 4,
    },
  },
  right: {
    value: 5,
  },
}
DFS(o)
console.log(result)

循环解法思路

递归的调用实际上是实现了一个栈，栈是后进先出的结构，所以先把右子树压入栈，然后是左子树

function DFS(obj) {
  let arr = []
  let result = []
  // 初始化进入循环
  arr[0] = obj
  let top
  // 循环的条件
  while (arr.length > 0) {
    top = arr.pop()
    result.push(top.value)
    if (top.right) {
      arr.push(top.right)
    }
    if (top.left) {
      arr.push(top.left)
    }
  }
  return result
}
let o = {
  value: 3,
  left: {
    value: 1,
    left: {
      value: 4,
    },
  },
  right: {
    value: 5,
  },
}
const arr = DFS(o)
console.log(arr)

相关题目

树的左视图

给出一个树，写出一个算法得到它的左视图

思路

给出左视图即每一层的第一个元素，即层序遍历，并且要保存遍历时的层数。

层数的获得要在辅助队列时确定：节点的层数时父节点的层数+1

代码实现:

function leftView(obj) {
  // 辅助队列
  let assistQueue = []
  let count = 1
  assistQueue[0] = { node: obj, layer: count }
  // 层序遍历结果
  let result = []
  // 左视图的值
  let leftViewer = []
  while (assistQueue.length !== 0) {
    let head = assistQueue.shift()
    if (head.node.left) {
      assistQueue.push({ node: head.node.left, layer: head.layer + 1 })
    }
    if (head.node.right) {
      assistQueue.push({ node: head.node.right, layer: head.layer + 1 })
    }
    result.push(head)
  }
  let currentCount = 0
  for (let i = 0; i < result.length; i++) {
    if (result[i].layer > currentCount) {
      leftViewer.push(result[i].node.value)
      currentCount++
    }
  }
  return leftViewer
}
let o = {
  value: 3,
  left: {
    value: 1,
    left: {
      value: 4,
    },
  },
  right: {
    value: 5,
    left: {
      value: 7,
      left: {
        value: 6,
      },
    },
  },
}
const arr = leftView(o)
console.log(arr)