SHLYYY

然后B为A左子树的根，C为B的左子树的根，C的左右子树都为#，D为B的右子树，E为D的左子树的根，E的左子树为空，E的右子树为G，G的左右子树都为空，F为D的右子树的根，F的左右子树都为空。在CreateTree构建二叉树中，因为要对先序字符串进行遍历，所以需要传入先序序列，在构建的过程中使用递归遍历，为了保持只想先序字符串的索引一致，还需要遍历的索引i，并使用引用传递。如果该字符不为#，则创建该结点，遍历指针后移，然后构建该结点的左子树，构建该结点的右子树。如果遇到#，则返回空，并且遍历指针要后移。

检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。否则，返回 false。输入：root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。输入：root = [3,4,5,1,2], subRoot = [4,1,2]root树的每个结点都要与subRoot进行比较，两个是相同的树就可以。

在具体判断对称的问题上，假设根的左子树为leftRoot，根的右子树为rightRoot，如果leftRoot和rightRoot值相同，然后往下判断。leftRoot的左子树与rightRoot的右子树应该满足对称的条件，leftRoot的右子树与rightRoot的左子树应该满足对称的条件。从根节点开始，判断其左右子树的对称情况，用递归的写法，可以类似相同的树的写法。输入：root = [1,2,2,null,3,null,3]输入：root = [1,2,2,3,4,4,3]

然后转换为递归问题，p的左子树与q的左子树，p的右子树与q的右子树都要是相同的树。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。输入：p = [1,2], q = [1,null,2]输入：p = [1,2,3], q = [1,2,3]输入：p = [1,2,1], q = [1,1,2]如果有一个为空，另一个不为空，则返回false。如果p，q对应的值不相等，则返回false。如果p，q都是空树，则返回true。

总结：1.在外层接口不方便递归时，将递归过程封装成子函数的思想可以借鉴。这让我想到了远古的回忆，在利用短路表达式判断一个数是否是素数的递归实现中，也是将递归的代码封装成一个子函数。2.第二个注意点就是索引值的传递，我们需要传递指针，保证函数内部使用的指针指向的值同步更新。return;} ++(* pn);

只有给定的树是单值二叉树时，才返回 true；否则返回 false。先判断根结点是否是一棵单值二叉树：根结点的左右子节点进行值比较。如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。递归判断根的左子树和右子树是否同时为单值二叉树。输入：[1,1,1,1,1,null,1]输入：[2,2,2,5,2]

int front;int rear;int k;int * a;

ST pushst;ST popst;} MyQueue;

Queue q1;Queue q2;} MyStack;

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。2.如果字符是右括号，则出栈与右括号匹配。不匹配return false。最后如果栈不为空，说明还有左括号未匹配。每个右括号都有一个对应的相同类型的左括号。左括号必须用相同类型的右括号闭合。输入：s = “()[]{}”左括号必须以正确的顺序闭合。1.如果字符是左括号，则入栈。输入：s = “()”输入：s = “(]”

新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。2.根据原节点的random，处理复制节点的random，复制节点的random为原节点的random的next。输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]输出：[[3,null],[3,0],[3,null]]输出：[[1,1],[2,1]]

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。快慢指针在环中相遇，把相遇点变成原链表的尾结点，相遇点的下一个结点变为新链表的头结点，这样求环的入口点问题，就变成了找两个链表的交点问题了。给定一个链表的头节点 head ，返回链表开始入环的第一个节点。由上可知，我们使用两个指针，一个指针从相遇点走，一个指针从链表头开始走，他们必定会在入口点相遇。解释：链表中没有环。

对于环形链表，我们不仅需要检查是否有环，还需要找到环的入口点，查看另一文：【找环形链表的入口点】

换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。所以让长的链表指针先走，先走两个链表长度的差值，然后两个指针同时走，可以同时走到交点。

对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。测试样例：1->2->2->1。给定一个链表的头指针。

关于带头结点的单链表，这种方法在上面【合并两个有序链表】中我们也使用了其思想。使用带头结点的单链表会简化我们插入时的代码逻辑。

双指针、快慢指针，YYDS。

虽然两个方法的思想很简单，但代码实现过程中还是比较难写，没有很强的逻辑思路。

这种使用带头结点的单链表的方法简化代码的思想，在【链表分割】中我们再次使用。好像有两个链表的联动，并且有头插时，使用带头结点的单链表会简化我们插入时的代码逻辑。因此带头结点的单链表尾插时代码会统一，不用对链表为空进行单独处理。

双指针的快慢指针真的好用。此外本题需要记住实现过程，因为下面的刷题过程中，在判断链表的回文结构中会用到找中间节点的函数。

再次回顾单链表实现时，尾插的细节分析，注意尾插时需要考虑链表为空的情况。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2。输入：nums = [0,0,1,1,1,2,2,3,3,4]输出：5, nums = [0,1,2,3,4]

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3。合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。输入：nums1 = [0], m = 0, nums2 = [1], n = 1。输入：nums1 = [1], m = 1, nums2 = [], n = 0。解释：需要合并 [1,2,3] 和 [2,5,6]。解释：需要合并的数组是 [] 和 [1]。输出：[1,2,2,3,5,6]

例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。如果右指针指向的元素不等于 val，它一定是输出数组的一个元素，我们就将右指针指向的元素复制到左指针位置，然后将左右指针同时右移；输入：nums = [0,1,2,2,3,0,4,2], val = 2。元素的顺序可以改变。输入：nums = [3,2,2,3], val = 3。

让数组的size个数与[0, size-1]共size个数异或，得到的结果再与size异或，最终得到的便是[0, size]中缺的那个整数。排序，依次查找，如果下一个数不是上一个数加1，则上一个数加1就是消失的数字。)，即便使用更为高效的排序算法，总体时间复杂度不是O(n)。)，遍历数组时间复杂度为O(n)，总体时间复杂度为O(n。这里的排序使用的是简单的冒泡排序时间复杂度O(n。输入：[9,6,4,2,3,5,7,0,1]两个相同的数异或为0：x ^ x = 0。输入：[3,0,1]

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。输入: nums = [1,2,3,4,5,6,7], k = 3。向右轮转 1 步: [7,1,2,3,4,5,6]向右轮转 2 步: [6,7,1,2,3,4,5]向右轮转 3 步: [5,6,7,1,2,3,4]2.原数组前 size-k 个数移到新空间的后面。3.原数组最后 k 个数移到新空间的前面。输出: [5,6,7,1,2,3,4]3.将保存的最后一个数放到第一个位置。数组每次右旋一个数，右旋k次。