1104. 二叉树寻路
2021.7.29 每日一题
题目描述
在一棵无限的二叉树上，每个节点都有两个子节点，树中的节点 逐行 依次按 “之” 字形进行标记。
如下图所示，在奇数行（即，第一行、第三行、第五行……）中，按从左到右的顺序进行标记；
而偶数行（即，第二行、第四行、第六行……）中，按从右到左的顺序进行标记。
给你树上某一个节点的标号 label，请你返回从根节点到该标号为 label 节点的路径，该路径是由途经的节点标号所组成的。
示例 1：
输入：label = 14
输出：[1,3,4,14]
示例 2：
输入：label = 26
输出：[1,2,6,10,26]
提示：
1 <= label <= 10^6
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/path-in-zigzag-labelled-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
我的思路就是之字遍历，然后存储每个节点的父节点，最后从label依次找父节点，加入结果列表，之字遍历用的是双端队列
一提交，超5%，捞了
class Solution {
public List<Integer> pathInZigZagTree(int label) {
//直接之字遍历就行了，然后存储父节点
//想想怎么之字遍历来着，双端队列
Deque<Integer> deque = new LinkedList<>();
Map<Integer, Integer> father = new HashMap<>();
int lavel = 1;
List<Integer> list = new ArrayList<>();
if(label == 1){
list.add(1);
return list;
}
deque.offerLast(1);
int idx = 2;
boolean flag = false;
while(!deque.isEmpty()){
int size = deque.size();
while(size-- > 0){
if(lavel % 2 == 1){
int temp = deque.pollLast();
int t1 = idx++;
int t2 = idx++;
deque.offerFirst(t1);
deque.offerFirst(t2);
father.put(t1, temp);
father.put(t2, temp);
if(t1 == label || t2 == label){
flag = true;
break;
}
}
else{
int temp = deque.pollFirst();
int t1 = idx++;
int t2 = idx++;
deque.offerLast(t1);
deque.offerLast(t2);
father.put(t1, temp);
father.put(t2, temp);
if(t1 == label || t2 == label){
flag = true;
break;
}
}
}
lavel++;
if(flag)
break;
}
list.add(label);
while(father.containsKey(label)){
list.add(father.get(label));
label = father.get(label);
}
Collections.reverse(list);
return list;
}
}
数学方法：
根据完全二叉树的性质，可以得到每一层数值的范围
而相邻层之间的取值顺序是相反的，根据这个特点，依次找父节点
class Solution {
public List<Integer> pathInZigZagTree(int label) {
//找寻数学性质
//第i行的数是2^(i-1) - 2 ^i - 1
//因为每一行和下一行方向是反的，所以如果要找label对应的父节点
//那么首先label / 2，本来应该对应的是label/2这个节点，但是上一行是反过来的，所以对应的是2^(i-1) + 2 ^i - 1 - label / 2
//根据这个规律一直往上，直到1
List<Integer> res = new ArrayList<>();
//首先计算label在第几层
int level = 1;
while((1 << level) - 1 < label){
level++;
}
level--;
res.add(label);
while(level >= 1){
int temp = label / 2;
int left = 1 << (level - 1);
int right = (1 << level) - 1;
label = left + right - temp;
res.add(label);
level--;
}
Collections.reverse(res);
return res;
}
}
103. 二叉树的锯齿形层序遍历
回顾一下之字遍历
题目描述
给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
例如：
给定二叉树 [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回锯齿形层序遍历如下：
[
[3],
[20,9],
[15,7]
]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
只是在存储到deque中的时候改变方向，遍历还是按原来的顺序进行遍历
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
//看了一下答案的，发现更好
//这个思想是，不改变遍历的顺序，只改变存入list中的顺序，就相当于改变了层序遍历的顺序了
class Solution {
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
List<List<Integer>> ans = new LinkedList<List<Integer>>();
if (root == null) {
return ans;
}
Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
nodeQueue.offer(root);
boolean isOrderLeft = true; //如果从左向右遍历，就是true
while (!nodeQueue.isEmpty()) {
Deque<Integer> levelList = new LinkedList<Integer>();
int size = nodeQueue.size();
for (int i = 0; i < size; ++i) {
TreeNode curNode = nodeQueue.poll();
//如果是从左到右遍历的，就把这个值加在末尾
if (isOrderLeft) {
levelList.offerLast(curNode.val);
} else {
levelList.offerFirst(curNode.val);
}
if (curNode.left != null) {
nodeQueue.offer(curNode.left);
}
if (curNode.right != null) {
nodeQueue.offer(curNode.right);
}
}
ans.add(new LinkedList<Integer>(levelList));
isOrderLeft = !isOrderLeft;
}
return ans;
}
}
171. Excel表列序号
2021.7.30 每日一题
题目描述
给定一个Excel表格中的列名称，返回其相应的列序号。
例如，
A -> 1
B -> 2
C -> 3
...
Z -> 26
AA -> 27
AB -> 28
...
示例 1:
输入: “A”
输出: 1
示例 2:
输入: “AB”
输出: 28
示例 3:
输入: “ZY”
输出: 701
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/excel-sheet-column-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
class Solution {
public int titleToNumber(String columnTitle) {
int l = columnTitle.length();
int res = 0;
for(int i = 0; i < l; i++){
res = res * 26 + columnTitle.charAt(i) + 1 - 'A';
}
return res;
}
}
987. 二叉树的垂序遍历
2021.7.31每日一题
题目描述
给你二叉树的根结点 root ，请你设计算法计算二叉树的 垂序遍历 序列。
对位于 (row, col) 的每个结点而言，其左右子结点分别位于 (row + 1, col - 1) 和 (row + 1, col + 1) 。树的根结点位于 (0, 0) 。
二叉树的 垂序遍历 从最左边的列开始直到最右边的列结束，按列索引每一列上的所有结点，形成一个按出现位置从上到下排序的有序列表。如果同行同列上有多个结点，则按结点的值从小到大进行排序。
返回二叉树的 垂序遍历 序列。
示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：[[9],[3,15],[20],[7]]
解释：
列 -1 ：只有结点 9 在此列中。
列 0 ：只有结点 3 和 15 在此列中，按从上到下顺序。
列 1 ：只有结点 20 在此列中。
列 2 ：只有结点 7 在此列中。
示例 2：
输入：root = [1,2,3,4,5,6,7]
输出：[[4],[2],[1,5,6],[3],[7]]
解释：
列 -2 ：只有结点 4 在此列中。
列 -1 ：只有结点 2 在此列中。
列 0 ：结点 1 、5 和 6 都在此列中。
1 在上面，所以它出现在前面。
5 和 6 位置都是 (2, 0) ，所以按值从小到大排序，5 在 6 的前面。
列 1 ：只有结点 3 在此列中。
列 2 ：只有结点 7 在此列中。
示例 3：
输入：root = [1,2,3,4,6,5,7]
输出：[[4],[2],[1,5,6],[3],[7]]
解释：
这个示例实际上与示例 2 完全相同，只是结点 5 和 6 在树中的位置发生了交换。
因为 5 和 6 的位置仍然相同，所以答案保持不变，仍然按值从小到大排序。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/vertical-order-traversal-of-a-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
这个题说实话不算困难，就是先深度优先将节点的下标和值存储起来，然后自定义个比较器，没啥难度
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
class Node{
int row;
int col;
int value;
public Node(int r, int c, int v){
row = r;
col = c;
value = v;
}
}
PriorityQueue<Node> pq;
public List<List<Integer>> verticalTraversal(TreeNode root) {
pq = new PriorityQueue<>(new Comparator<Node>(){
public int compare(Node a, Node b){
if(a.col != b.col){
return a.col - b.col;
}else if(a.row != b.row){
return a.row - b.row;
}else{
return a.value - b.value;
}
}
});
dfs(root, 0, 0);
List<List<Integer>> res = new LinkedList<>();
List<Integer> list = new LinkedList<>();
int pre = pq.peek().col;
list.add(pq.poll().value);
while(!pq.isEmpty()){
while(!pq.isEmpty() && pq.peek().col == pre){
list.add(pq.poll().value);
}
res.add(list);
if(!pq.isEmpty()){
list = new LinkedList<>();
pre = pq.peek().col;
}
}
return res;
}
public void dfs(TreeNode root, int row, int col){
if(root == null){
return;
}
Node node = new Node(row, col, root.val);
pq.offer(node);
dfs(root.left, row + 1, col - 1);
dfs(root.right, row + 1, col + 1);
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
