数据结构和算法十七

jiulingcode

已于 2023-02-14 17:32:54 修改

阅读量227

点赞数

文章标签：算法二叉树队列

于 2021-05-04 00:30:06 首次发布

本文链接：https://blog.csdn.net/weixin_44211905/article/details/116334774

版权

剑指 Offer 37. 序列化二叉树

题目：请实现两个函数，分别用来序列化和反序列化二叉树。
示例:
你可以将以下二叉树：

序列化为 “[1,2,3,null,null,4,5]”

解题思路：
通常使用的前序、中序、后序、层序遍历记录的二叉树的信息不完整，即唯一的输出序列可能对应着多种二叉树可能性。题目要求的序列化和反序列化是可逆操作。因此，序列化的字符串应携带完整的二叉树信息。
观察题目示例，序列化的字符串实际上是二叉树的 “层序遍历”（BFS）结果，本文也采用层序遍历。
为完整表示二叉树，考虑将叶节点下的 null 也记录。在此基础上，对于列表中任意某节点 node ，其左子节点 node.left 和右子节点 node.right 在序列中的位置都是唯一确定的。如下图所示：

在这里插入图片描述
上图规律可总结为下表：

node.val	node 的索引	node.left 的索引	node.right 的索引
1	0	1	2
2	1	3	4
3	2	5	6
4	5	7	8
5	6	9	10
设 m为列表区间[0,n]中的null节点个数，则可总结出根节点、左子节点、右子节点的列表索引的递推公式：
node.val	node 的列表索引	node.left的列表索引**	node.right 的列表索引**
------------	---------------------	--------------------------	---------------------------
！=null	n	2(n−m)+1	2(n−m)+2
=null	n	无	无

序列化使用层序遍历实现。反序列化通过以上递推公式反推各节点在序列中的索引，进而实现。

序列化 Serialize ：
借助队列，对二叉树做层序遍历，并将越过叶节点的 null 也打印出来。

/*算法流程：
1、特例处理：若root为空，则直接返回空列表 "[]"；
2、初始化：队列queue（包含根节点root）；序列化列表res；
3、层序遍历：当queue为空时跳出；
	（1）节点出队，记为node ；
	（2）若node不为空：① 打印字符串 node.val ，② 将左、右子节点加入queue；
	（3）否则（若node为空）：打印字符串"null"；
4、返回值：拼接列表，用 ',' 隔开，首尾添加中括号；
复杂度分析：
	时间复杂度O(N)：N为二叉树的节点数，层序遍历需要访问所有节点，最差情况下需要访问N+1个null，总体复杂度为O(2N+1)=O(N)。
	空间复杂度O(N)：最差情况下，队列queue同时存储(N+1)/2个节点（或N+1个null），使用O(N)；列表res使用 O(N) 。
*/

反序列化 Deserialize ：
基于本文开始推出的 node , node.left , node.right 在序列化列表中的位置关系，可实现反序列化。
利用队列按层构建二叉树，借助一个指针 i 指向节点 node 的左、右子节点，每构建一个 node 的左、右子节点，指针 i 就向右移动1位。

/*算法流程：
1、特例处理： 若 data 为空，直接返回 null ；
2、初始化： 序列化列表 vals （先去掉首尾中括号，再用逗号隔开），指针 i = 1 ，根节点 root （值为 vals[0] ），队列 queue（包含 root ）；
3、按层构建： 当 queue 为空时跳出；
	（1）节点出队，记为 node ；
	（2）构建 node 的左子节点：node.left 的值为 vals[i] ，并将 node.left 入队；
	（3）执行 i += 1 ；
	（4）构建 node 的右子节点：node.left 的值为 vals[i] ，并将 node.left 入队；
	（5）执行 i += 1 ；
4、返回值： 返回根节点 root 即可；
复杂度分析：
	时间复杂度O(N)：N为二叉树的节点数，按层构建二叉树需要遍历整个vals，其长度最大为2N+1。
	空间复杂度O(N)：最差情况下，队列queue同时存储 (N + 1)/2个节点，因此使用O(N)额外空间。
*/

public class Method{
    public String serialize(TreeNode root) {
        if(root == null) return "[]";
        StringBuilder res = new StringBuilder("[");
        Queue<TreeNode> queue = new LinkedList<>() {{ add(root); }};
        while(!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if(node != null) {
                res.append(node.val + ",");
                queue.add(node.left);
                queue.add(node.right);
            }
            else res.append("null,");
        }
        res.deleteCharAt(res.length() - 1);
        res.append("]");
        return res.toString();
    }

    public TreeNode deserialize(String data) {
        if(data.equals("[]")) return null;
        String[] vals = data.substring(1, data.length() - 1).split(",");
        TreeNode root = new TreeNode(Integer.parseInt(vals[0]));
        Queue<TreeNode> queue = new LinkedList<>() {{ add(root); }};
        int i = 1;
        while(!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if(!vals[i].equals("null")) {
                node.left = new TreeNode(Integer.parseInt(vals[i]));
                queue.add(node.left);
            }
            i++;
            if(!vals[i].equals("null")) {
                node.right = new TreeNode(Integer.parseInt(vals[i]));
                queue.add(node.right);
            }
            i++;
        }
        return root;
    }
}

剑指 Offer 38. 字符串的排列

输入一个字符串，打印出该字符串中字符的所有排列。
你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。
示例:
      输入：s = “abc”
      输出：[“abc”,“acb”,“bac”,“bca”,“cab”,“cba”]
限制：
      1 <= s 的长度 <= 8

解题思路：
对于一个长度为n的字符串（假设字符互不重复），其排列方案数共有：
n×(n−1)×(n−2)…×2×1
排列方案的生成：
根据字符串排列的特点，考虑深度优先搜索所有排列方案。即通过字符交换，先固定第 1 位字符（ n 种情况）、再固定第 2 位字符（ n−1 种情况）、… 、最后固定第 n 位字符（ 1 种情况）

在这里插入图片描述

重复排列方案与剪枝：
当字符串存在重复字符时，排列方案中也存在重复的排列方案。为排除重复方案，需在固定某位字符时，保证 “每种字符只在此位固定一次” ，即遇到重复字符时不交换，直接跳过。从 DFS 角度看，此操作称为 “剪枝” 。

递归解析：
1、终止条件：当 x = len© - 1 时，代表所有位已固定（最后一位只有 1种情况），则将当前组合 c 转化为字符串并加入 res ，并返回；
2、递推参数：当前固定位 x ；
3、递推工作：初始化一个 Set ，用于排除重复的字符；将第 x 位字符与 i∈[x, len©] 字符分别交换，并进入下层递归；
         【1】剪枝：若 c[i] 在 Set 中，代表其是重复字符，因此 “剪枝” ；
         【2】将 c[i] 加入 Set ，以便之后遇到重复字符时剪枝；
         【3】固定字符：将字符 c[i] 和 c[x] 交换，即固定 c[i] 为当前位字符；
         【4】开启下层递归：调用 dfs(x + 1) ，即开始固定第 x + 1 个字符；
         【5】还原交换：将字符 c[i] 和 c[x] 交换（还原之前的交换）；

下图中 list 对应文中的列表 c 。

在这里插入图片描述

复杂度分析：
时间复杂度 O(N!N)：N为字符串 s 的长度；时间复杂度和字符串排列的方案数成线性关系，方案数为N×(N−1)×(N−2)…×2×1 ，即复杂度为O(N!)；字符串拼接操作 join() 使用O(N);因此总体时间复杂度为O(N!N)。
空间复杂度 O(N^2)：全排列的递归深度为N，系统累计使用栈空间大小为O(N)；递归中辅助 Set 累计存储的字符数量最多为 N+(N−1)+…+2+1=(N+1)N/2 ，即占用 O(N^2)的额外空间。

class Method{
    List<String> res = new LinkedList<>();
    char[] c;
    public String[] permutation(String s) {
        c = s.toCharArray();
        dfs(0);
        return res.toArray(new String[res.size()]);
    }
    void dfs(int x) {
        if(x == c.length - 1) {
            res.add(String.valueOf(c));      // 添加排列方案
            return;
        }
        HashSet<Character> set = new HashSet<>();
        for(int i = x; i < c.length; i++) {
            if(set.contains(c[i])) continue; // 重复，因此剪枝
            set.add(c[i]);
            swap(i, x);                      // 交换，将 c[i] 固定在第 x 位
            dfs(x + 1);                      // 开启固定第 x + 1 位字符
            swap(i, x);                      // 恢复交换
        }
    }
    void swap(int a, int b) {
        char tmp = c[a];
        c[a] = c[b];
        c[b] = tmp;
    }
}

总结:

       不知不觉又一天过去了，时间真的是不等人！实在是不好意思哈，各位小伙伴，让大家久等了！又晚更新了，请大家见谅！但是我说过的话就一定会兑现的！就算是再晚也得把博客补上，不负各位浏览我博客的小伙伴！
       在以后的生涯里，不管是继续学习还是从事就业，都得更加努力了，如果自身再不努力就会一直停滞不前，这不是我想拥有的生活！我不喜欢生活在舒适圈中！我更加喜欢具有挑战的生活！
       最后，愿我们都能在各行各业中能够取得不同的成就！能够用自身的所学知识为国家贡献出自己的一份力量！一起加油！