LeetCode 1104. 二叉树寻路/103. 二叉树的锯齿形层序遍历/ 171. Excel表列序号/ 987. 二叉树的垂序遍历

Posted Zephyr丶J

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了LeetCode 1104. 二叉树寻路/103. 二叉树的锯齿形层序遍历/ 171. Excel表列序号/ 987. 二叉树的垂序遍历相关的知识,希望对你有一定的参考价值。

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);
    }
}

以上是关于LeetCode 1104. 二叉树寻路/103. 二叉树的锯齿形层序遍历/ 171. Excel表列序号/ 987. 二叉树的垂序遍历的主要内容,如果未能解决你的问题,请参考以下文章

LeetCode 1104 二叉树寻路[数学 二叉树 位运算] HERODING的LeetCode之路

[M二叉树] lc1104. 二叉树寻路(思维+找规律+数学)

数学1104. 二叉树寻路(中等)

1104. 二叉树寻路

1104. 二叉树寻路

满二叉树的性质题--二叉树寻路