feat: 添加基础数据结构 二叉树

Author: yi-ge

.vscode/settings.json

@@ -31,6 +31,7 @@
     "PAHNAPLSIIGYIR",
     "PAYPALISHIRING",
     "PINALSIGYAHRPI",
+    "postorder",
     "powx",
     "preorder",
     "Prinme",

README.md

@@ -27,6 +27,9 @@ TypeScript / JavaScript 基础算法、数据结构练习，包含 LeetCode 或
 
 ## 基础数据结构
 
+- [二叉树深度优先遍历|前序遍历|中序遍历|后序遍历](src/tree/dfs.ts)
+- [二叉树广度优先遍历|层序遍历](src/tree/bfs.ts)
+
 ## 算法题
 
 ### 字符串

src/list/reverse-linked-list.ts

@@ -4,16 +4,14 @@
 
 import ListNode from "../lib/ListNode"
 
-
 export function reverseList (head: ListNode | null): ListNode | null {
-  let pre = null
-  let cur = head
-  while (cur !== null) {
-    let next = cur.next
-    cur.next = pre
-    pre = cur
-    cur = next
+  let first = null
+  let second = head
+  while (second !== null) {
+    let third = second.next
+    second.next = first
+    first = second
+    second = third
   }
-
-  return pre
+  return first
 }

src/tree/TreeNode.ts

@@ -0,0 +1,10 @@
+export class TreeNode {
+  val: number
+  left: TreeNode | null
+  right: TreeNode | null
+  constructor (val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+    this.val = (val === undefined ? 0 : val)
+    this.left = (left === undefined ? null : left)
+    this.right = (right === undefined ? null : right)
+  }
+}

src/tree/bfs.ts

@@ -0,0 +1,20 @@
+import { TreeNode } from "./TreeNode"
+
+export const bfs = (node: TreeNode): number[] => {
+  const res = []
+  const queue = [] // 队列
+  queue.push(node)
+  while (queue.length > 0) {
+    node = queue.shift() as TreeNode // 逻辑上此处一定存在值
+    res.push(node.val)
+
+    if (node.left) {
+      queue.push(node.left)
+    }
+
+    if (node.right) {
+      queue.push(node.right)
+    }
+  }
+  return res
+}

src/tree/dfs.ts

@@ -0,0 +1,84 @@
+import { TreeNode } from "./TreeNode"
+
+// const printTree = (node) => {
+//   if (node === null) return
+//   console.log(node.val)
+//   printTree(node.left)
+//   printTree(node.right)
+// }
+// 前序遍历递归法
+export const preorder = (node: TreeNode | null): number[] => {
+  if (node === null) return []
+  return [node.val, ...preorder(node.left), ...preorder(node.right)]
+}
+
+// 中序遍历递归法
+export const inorder = (node: TreeNode | null): number[] => {
+  if (node === null) return []
+  return [...inorder(node.left), node.val, ...inorder(node.right)]
+}
+
+// 后序遍历递归法
+export const postorder = (node: TreeNode | null): number[] => {
+  if (node === null) return []
+  return [...postorder(node.left), ...postorder(node.right), node.val]
+}
+
+// 前序遍历循环法
+export const preorderCycle = (node: TreeNode | null): number[] => {
+  const res = []
+  const stack = []
+  stack.push(node)
+  while (stack.length > 0) {
+    node = stack.pop() as TreeNode
+    res.push(node.val)
+
+    if (node?.right) {
+      stack.push(node.right)
+    }
+
+    if (node?.left) {
+      stack.push(node.left)
+    }
+  }
+  return res
+}
+
+// 中序遍历循环法
+export const inorderCycle = (node: TreeNode | null): number[] => {
+  const res: number[] = []
+  const stack = []
+  while (node !== null || stack.length) {
+    if (node !== null) {
+      stack.push(node)
+      node = node.left
+    } else {
+      node = stack.pop() as TreeNode
+      res.push(node.val)
+
+      node = node.right
+    }
+
+  }
+  return res
+}
+
+// 后序遍历循环法
+export const postorderCycle = (node: TreeNode | null): number[] => {
+  const res = []
+  const stack = []
+  stack.push(node)
+  while (stack.length > 0) {
+    node = stack.pop() as TreeNode
+    res.unshift(node.val)
+
+    if (node?.left) {
+      stack.push(node.left)
+    }
+
+    if (node?.right) {
+      stack.push(node.right)
+    }
+  }
+  return res
+}

test/tree/bfs.test.ts

@@ -0,0 +1,33 @@
+import { bfs } from '../../src/tree/bfs'
+import { TreeNode } from '../../src/tree/TreeNode'
+
+// * 为了方便查看整个Tree的定义方式。建议通过常规方法创建整棵树
+const tree: TreeNode = {
+  val: 1,
+  left: {
+    val: 2,
+    left: {
+      val: 4,
+      left: null,
+      right: null
+    },
+    right: {
+      val: 5,
+      left: null,
+      right: null
+    }
+  },
+  right: {
+    val: 3,
+    left: {
+      val: 6,
+      left: null,
+      right: null
+    },
+    right: null
+  }
+}
+
+test('二叉树广度优先遍历', () => {
+  expect(bfs(tree)).toEqual([1, 2, 3, 4, 5, 6])
+})

test/tree/dfs.test.ts

@@ -0,0 +1,56 @@
+import { preorderCycle, inorderCycle, postorderCycle } from './../../src/tree/dfs'
+import { preorder, inorder, postorder } from '../../src/tree/dfs'
+import { TreeNode } from '../../src/tree/TreeNode'
+
+// * 为了方便查看整个Tree的定义方式。建议通过常规方法创建整棵树
+const tree: TreeNode = {
+  val: 1,
+  left: {
+    val: 2,
+    left: {
+      val: 4,
+      left: null,
+      right: null
+    },
+    right: {
+      val: 5,
+      left: null,
+      right: null
+    }
+  },
+  right: {
+    val: 3,
+    left: {
+      val: 6,
+      left: null,
+      right: null
+    },
+    right: null
+  }
+}
+
+describe('二叉树深度优先遍历', () => {
+  test('前序遍历递归', () => {
+    expect(preorder(tree)).toEqual([1, 2, 4, 5, 3, 6])
+  })
+
+  test('中序遍历递归', () => {
+    expect(inorder(tree)).toEqual([4, 2, 5, 1, 6, 3])
+  })
+
+  test('后序遍历递归', () => {
+    expect(postorder(tree)).toEqual([4, 5, 2, 6, 3, 1])
+  })
+
+  test('前序遍历循环法', () => {
+    expect(preorderCycle(tree)).toEqual([1, 2, 4, 5, 3, 6])
+  })
+
+  test('中序遍历循环法', () => {
+    expect(inorderCycle(tree)).toEqual([4, 2, 5, 1, 6, 3])
+  })
+
+  test('后序遍历循环法', () => {
+    expect(postorderCycle(tree)).toEqual([4, 5, 2, 6, 3, 1])
+  })
+})