层次遍历
使用BFS进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点,因为在开始遍历一层的节点时,当前队列中的节点数就是当前层的节点数,只要控制遍历这么多节点数,就能保证这次遍历的都是当前层的节点。
一棵树每层节点的平均数
637. Average of Levels in Binary Tree (Easy)
class Solution {
public List<Double> averageOfLevels(TreeNode root) {
List<Double> list = new ArrayList<>();
if (null == root) {
return list;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
int size = queue.size();
double aver = 1 / (size * 1.0);
double sum = 0;
while (size > 0) {
TreeNode node = queue.poll();
sum += node.val;
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
size--;
}
list.add(sum * aver);
}
return list;
}
}
得到左下角的节点
513. Find Bottom Left Tree Value (Easy)
Input:
1
/ \
2 3
/ / \
4 5 6
/
7
Output:
7
class Solution {
public int findBottomLeftValue(TreeNode root) {
int height = maxDepth(root);
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
int h = 0, result = -1;
boolean isEnd = false;
while (!queue.isEmpty()) {
h++;
if (h == height) {
isEnd = true;
}
int size = queue.size();
while (size > 0) {
TreeNode node = queue.poll();
if (isEnd && size == queue.size() + 1) {
result = node.val;
break;
}
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
size--;
}
if (isEnd) {
break;
}
}
return result;
}
public int maxDepth(TreeNode root) {
if (null == root) {
return 0;
}
if (null == root.left && null == root.right) {
return 1;
}
int left = maxDepth(root.left) + 1;
int right = maxDepth(root.right) + 1;
return left < right ? right : left;
}
}
前中后序遍历
1
/ \
2 3
/ \ \
4 5 6
- 层次遍历顺序:[1 2 3 4 5 6]
- 前序遍历顺序:[1 2 4 5 3 6]
- 中序遍历顺序:[4 2 5 1 3 6]
- 后序遍历顺序:[4 5 2 6 3 1]
层次遍历使用 BFS 实现,利用的就是 BFS 一层一层遍历的特性;而前序、中序、后序遍历利用了 DFS 实现。
前序、中序、后序遍只是在对节点访问的顺序有一点不同,其它都相同。
① 前序
void dfs(TreeNode root) {
visit(root);
dfs(root.left);
dfs(root.right);
}
② 中序
void dfs(TreeNode root) {
dfs(root.left);
visit(root);
dfs(root.right);
}
③ 后序
void dfs(TreeNode root) {
dfs(root.left);
dfs(root.right);
visit(root);
}
非递归实现二叉树的前序遍历
144. Binary Tree Preorder Traversal (Medium)
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
if (null == root) {
return list;
}
Stack<TreeNode> stack = new Stack<>();
stack.add(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
list.add(node.val);
if (node.right != null) {
stack.add(node.right);
}
if (node.left != null) {
stack.add(node.left);
}
}
return list;
}
}
非递归实现二叉树的后序遍历
145. Binary Tree Postorder Traversal (Hard)
前序遍历为 root -> left -> right,后序遍历为 left -> right -> root。可以修改前序遍历成为 root -> right -> left,那么这个顺序就和后序遍历正好相反。
class Solution {
public List<Integer> postorderTraversal(TreeNode root) { //left->right->root
List<Integer> list = new ArrayList<>();
if (null == root) {
return list;
}
Stack<TreeNode> stack = new Stack<>();
stack.add(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
list.add(node.val);
if (node.left != null) {
stack.add(node.left);
}
if (node.right != null) {
stack.add(node.right);
}
}
Collections.reverse(list);
return list;
}
}
非递归实现二叉树的中序遍历
94. Binary Tree Inorder Traversal (Medium)
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
if (null == root) {
return list;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
while (cur != null || !stack.isEmpty()) {
while (cur != null) {
stack.add(cur);
cur = cur.left;
}
TreeNode node = stack.pop();
list.add(node.val);
cur = node.right;
}
return list;
}
}
Trie
Trie,又称前缀树或字典树,用于判断字符串是否存在或者是否具有某种字符串前缀。
实现一个 Trie
208. Implement Trie (Prefix Tree) (Medium)
class Trie { // Method1
private class Node {
Node[] childs = new Node[26];
boolean isLeaf;
}
private Node root = new Node();
public Trie() {
}
public void insert(String word) {
insert(word, root);
}
private void insert(String word, Node node) {
if (node == null) return;
if (word.length() == 0) {
node.isLeaf = true;
return;
}
int index = indexForChar(word.charAt(0));
if (node.childs[index] == null) {
node.childs[index] = new Node();
}
insert(word.substring(1), node.childs[index]);
}
public boolean search(String word) {
return search(word, root);
}
private boolean search(String word, Node node) {
if (node == null) return false;
if (word.length() == 0) return node.isLeaf;
int index = indexForChar(word.charAt(0));
return search(word.substring(1), node.childs[index]);
}
public boolean startsWith(String prefix) {
return startWith(prefix, root);
}
private boolean startWith(String prefix, Node node) {
if (node == null) return false;
if (prefix.length() == 0) return true;
int index = indexForChar(prefix.charAt(0));
return startWith(prefix.substring(1), node.childs[index]);
}
private int indexForChar(char c) {
return c - 'a';
}
}
class TrieNode { // Method2
Map<Character, TrieNode> subNodes = new HashMap<>();
boolean isEnd = false;
public TrieNode() {
}
}
class Trie {
TrieNode root = new TrieNode();
/** Initialize your data structure here. */
public Trie() {
}
/** Inserts a word into the trie. */
public void insert(String word) {
if (null == word || 0 == word.length()) {
return ;
}
TrieNode temp = root;
for (int i = 0; i < word.length(); i++) {
char c = word.charAt(i);
TrieNode node = temp.subNodes.get(c);
if (null == node) {
node = new TrieNode();
temp.subNodes.put(c, node);
}
temp = node;
if (i == word.length() - 1) {
temp.isEnd = true;
}
}
}
/** Returns if the word is in the trie. */
public boolean search(String word) {
if (null == word || 0 == word.length()) {
return false;
}
boolean find = false;
TrieNode temp = root;
for (int i = 0; i < word.length(); i++) {
char c = word.charAt(i);
TrieNode node = temp.subNodes.get(c);
if (null == node) {
break;
}
temp = node;
if (i == word.length() - 1 && temp.isEnd) {
find = true;
}
}
return find;
}
/** Returns if there is any word in the trie that starts with the given prefix. */
public boolean startsWith(String prefix) {
if (null == prefix || 0 == prefix.length()) {
return false;
}
boolean find = true;
TrieNode temp = root;
for (int i = 0; i < prefix.length(); i++) {
char c = prefix.charAt(i);
TrieNode node = temp.subNodes.get(c);
if (null == node) {
find = false;
break;
}
temp = node;
}
return find;
}
}
实现一个 Trie,用来求前缀和
Input: insert("apple", 3), Output: Null
Input: sum("ap"), Output: 3
Input: insert("app", 2), Output: Null
Input: sum("ap"), Output: 5
class Trie {
Map<Character, Trie> subNodes = new HashMap<>();
int value = 0;
public Trie() {
this.value = 0;
}
}
class MapSum {
Trie root = new Trie();
Set<String> set = new HashSet<>();
/** Initialize your data structure here. */
public MapSum() {
}
public void insert(String key, int val) {
if (null == key || 0 == key.length()) {
return ;
}
boolean exist = false;
if (!set.contains(key)) {
set.add(key);
} else {
exist = true;
}
Trie temp = root;
for (int i = 0; i < key.length(); i++) {
char c = key.charAt(i);
Trie node = temp.subNodes.get(c);
if (null == node) {
node = new Trie();
temp.subNodes.put(c, node);
}
temp = node;
if (exist) {
temp.value = val;
} else {
temp.value += val;
}
}
}
public int sum(String prefix) {
if (null == prefix || 0 == prefix.length()) {
return 0;
}
Trie temp = root;
int result = 0;
for (int i = 0; i < prefix.length(); i++) {
char c = prefix.charAt(i);
Trie node = temp.subNodes.get(c);
if (null == node) {
break;
}
temp = node;
if (i == prefix.length() - 1) {
result = temp.value;
break;
}
}
return result;
}
}