Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 35b49d0

Browse files
feat: add 8 leetcode about binary tree
1 parent 7e9e20f commit 35b49d0

9 files changed

+691
-0
lines changed

‎leetcode/1302.deepest-leaves-sum.ts

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
/*
2+
* @lc app=leetcode id=1302 lang=typescript
3+
*
4+
* [1302] Deepest Leaves Sum
5+
*/
6+
7+
// @lc code=start
8+
/**
9+
* Definition for a binary tree node.
10+
* class TreeNode {
11+
* val: number
12+
* left: TreeNode | null
13+
* right: TreeNode | null
14+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
15+
* this.val = (val===undefined ? 0 : val)
16+
* this.left = (left===undefined ? null : left)
17+
* this.right = (right===undefined ? null : right)
18+
* }
19+
* }
20+
*/
21+
22+
/**
23+
* @description: 迭代实现层序遍历
24+
* @param {TreeNode} root
25+
* @return {number}
26+
*/
27+
function deepestLeavesSum(root: TreeNode | null): number {
28+
const queues = [root];
29+
const ans: number[] = [];
30+
31+
// 迭代的方式实现层序遍历
32+
while (queues.length) {
33+
let len = queues.length;
34+
let sum = 0;
35+
36+
// 直接累加所有层的和
37+
while (len--) {
38+
const node = queues.shift();
39+
if (node.val) sum += node.val;
40+
node.left && queues.push(node.left);
41+
node.right && queues.push(node.right);
42+
}
43+
44+
ans.push(sum);
45+
}
46+
47+
// 返回最后一个
48+
return ans.pop() as number;
49+
}
50+
// @lc code=end
Lines changed: 108 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,108 @@
1+
/*
2+
* @lc app=leetcode id=173 lang=typescript
3+
*
4+
* [173] Binary Search Tree Iterator
5+
*/
6+
7+
// @lc code=start
8+
/**
9+
* Definition for a binary tree node.
10+
* class TreeNode {
11+
* val: number
12+
* left: TreeNode | null
13+
* right: TreeNode | null
14+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
15+
* this.val = (val===undefined ? 0 : val)
16+
* this.left = (left===undefined ? null : left)
17+
* this.right = (right===undefined ? null : right)
18+
* }
19+
* }
20+
*/
21+
22+
/**
23+
* @description: 直接维护一个栈,保存迭代所对应的节点
24+
*/
25+
class BSTIterator {
26+
private node: TreeNode;
27+
private stack: TreeNode[];
28+
29+
constructor(root: TreeNode | null) {
30+
this.node = root;
31+
this.stack = [];
32+
}
33+
34+
public next(): number {
35+
while (this.node) {
36+
this.stack.push(this.node);
37+
this.node = this.node.left;
38+
}
39+
40+
const cur = this.stack.pop();
41+
this.node = cur.right;
42+
43+
return cur.val;
44+
}
45+
46+
public hasNext(): boolean {
47+
return this.node !== null || !!this.stack.length;
48+
}
49+
}
50+
51+
class BSTIterator2 {
52+
private iterator: number[];
53+
private index: number;
54+
55+
constructor(root: TreeNode | null) {
56+
this.index = -1;
57+
this.iterator = this.buildIterator(root);
58+
}
59+
60+
/**
61+
* @description: 根据二叉搜索树的中序遍历构建顺序数组
62+
* @param {TreeNode} root
63+
* @return {number[]}
64+
*/
65+
private buildIterator(root: TreeNode | null): number[] {
66+
if (root === null) return [];
67+
68+
const stack: TreeNode[] = [];
69+
const iterator: number[] = [];
70+
let node: TreeNode = root;
71+
72+
while (stack.length || node) {
73+
while (node) {
74+
stack.push(node);
75+
node = node.left;
76+
}
77+
const current = stack.pop();
78+
iterator.push(current.val);
79+
node = current.right;
80+
}
81+
82+
return iterator;
83+
}
84+
85+
/**
86+
* @description: 返回下一个节点的值
87+
* @return {number}
88+
*/
89+
public next(): number {
90+
return this.iterator[++this.index];
91+
}
92+
93+
/**
94+
* @description: 检测是否还有下一个节点
95+
* @return {boolean}
96+
*/
97+
hasNext(): boolean {
98+
return this.index < this.iterator.length - 1;
99+
}
100+
}
101+
102+
/**
103+
* Your BSTIterator object will be instantiated and called as such:
104+
* var obj = new BSTIterator(root)
105+
* var param_1 = obj.next()
106+
* var param_2 = obj.hasNext()
107+
*/
108+
// @lc code=end
Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,66 @@
1+
/*
2+
* @lc app=leetcode id=235 lang=typescript
3+
*
4+
* [235] Lowest Common Ancestor of a Binary Search Tree
5+
*/
6+
7+
// @lc code=start
8+
/**
9+
* Definition for a binary tree node.
10+
* class TreeNode {
11+
* val: number
12+
* left: TreeNode | null
13+
* right: TreeNode | null
14+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
15+
* this.val = (val===undefined ? 0 : val)
16+
* this.left = (left===undefined ? null : left)
17+
* this.right = (right===undefined ? null : right)
18+
* }
19+
* }
20+
*/
21+
22+
/**
23+
* @description: 使用循环遍历两次节点得到路径,再根据路径去查找
24+
* @param {TreeNode} root
25+
* @param {TreeNode} p
26+
* @param {TreeNode} q
27+
* @return {TreeNode}
28+
*/
29+
function lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {
30+
if (root === null) return root;
31+
/**
32+
* @description: 循环遍历得到查找值的父节点路径
33+
* @param {TreeNode} node
34+
* @param {number} val
35+
* @return {TreeNode[]}
36+
*/
37+
function getPath(node: TreeNode, val: number): TreeNode[] {
38+
const path: TreeNode[] = [];
39+
while (node.val !== val) {
40+
path.push(node);
41+
if (node.val > val) {
42+
node = node.left;
43+
} else {
44+
node = node.right;
45+
}
46+
}
47+
path.push(node);
48+
49+
return path;
50+
}
51+
52+
const pathP = getPath(root, p.val);
53+
const pathQ = getPath(root, q.val);
54+
55+
// 从后往前遍历,也就是对应节点向上找对应的父节点
56+
for (let i = pathP.length - 1; i >= 0; i--) {
57+
const pNode = pathP[i];
58+
for (let j = pathQ.length - 1; j >= 0; j--) {
59+
const qNode = pathQ[j];
60+
if (pNode.val === qNode.val) return qNode;
61+
}
62+
}
63+
64+
return root;
65+
}
66+
// @lc code=end

‎leetcode/450.delete-node-in-a-bst.js

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,78 @@
1+
/*
2+
* @lc app=leetcode id=450 lang=javascript
3+
*
4+
* [450] Delete Node in a BST
5+
*/
6+
7+
// @lc code=start
8+
/**
9+
* Definition for a binary tree node.
10+
* function TreeNode(val, left, right) {
11+
* this.val = (val===undefined ? 0 : val)
12+
* this.left = (left===undefined ? null : left)
13+
* this.right = (right===undefined ? null : right)
14+
* }
15+
*/
16+
/**
17+
* 递归的方式删除节点
18+
* @param {TreeNode} root
19+
* @param {number} key
20+
* @return {TreeNode}
21+
*/
22+
var deleteNode = function (root, key) {
23+
/**
24+
* @description: 在右子树中查找最小值
25+
* @param {TreeNode} node
26+
* @return {number}
27+
*/
28+
function successor(node) {
29+
node = node.right;
30+
while (node.left !== null) node = node.left;
31+
return node.val;
32+
}
33+
/**
34+
* @description: 在左子树中查找最大值
35+
* @param {TreeNode} node
36+
* @return {number}
37+
*/
38+
function preDecessor(node) {
39+
node = node.left;
40+
while (node.right !== null) node = node.right;
41+
return node.val;
42+
}
43+
44+
/**
45+
* @description: 删除对应节点
46+
* @param {TreeNode} node
47+
* @param {number} key
48+
* @return {TreeNode}
49+
*/
50+
function deleteYourNode(node, key) {
51+
if (node === null) {
52+
return node;
53+
}
54+
// 比当前节点值更大,就更新右子树
55+
if (key > node.val) {
56+
node.right = deleteYourNode(node.right, key);
57+
// 比当前节点值更小,就更新左子树
58+
} else if (key < node.val) {
59+
node.left = deleteYourNode(node.left, key);
60+
} else {
61+
if (node.left === null && node.right === null) {
62+
node = null;
63+
} else if (node.right !== null) {
64+
// !把右子树中的最小值替换到当前节点的值,并且删除右子树中的最小值
65+
node.val = successor(node);
66+
node.right = deleteYourNode(node.right, node.val);
67+
} else {
68+
// !把左子树中的最大值替换到当前节点的值,并且删除左子树中的最大值
69+
node.val = preDecessor(node);
70+
node.left = deleteYourNode(node.left, node.val);
71+
}
72+
}
73+
return node;
74+
}
75+
76+
return deleteYourNode(root, key);
77+
};
78+
// @lc code=end

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /