LeetCode解题报告——Convert Sorted List to Binary Search Tree & Populating Next Right Pointers in Each
Posted f91og
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了LeetCode解题报告——Convert Sorted List to Binary Search Tree & Populating Next Right Pointers in Each相关的知识,希望对你有一定的参考价值。
1. Convert Sorted List to Binary Search Tree
Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.
For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
Example:
Given the sorted linked list: [-10,-3,0,5,9], One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST: 0 / -3 9 / / -10 5
思路:对于树有关的问题还是首先想到用递归来解决,找到中间,那么左边是左子树,右边是右子树,以此递归即可。这个过程难点是找到中间的个链表节点,以及每次递归时确定左右子树的起始范围。
public class Solution {
public TreeNode sortedListToBST(ListNode head) {
if(head==null) return null;
return toBST(head,null);
}
public TreeNode toBST(ListNode head, ListNode tail) { //每次递归时左右子树的起始,也就是链表中要取的头和尾
ListNode slow = head;
ListNode fast = head;
if(head==tail) return null;
while(fast!=tail&&fast.next!=tail) { //这里很有意思,fast每次往后移动二步,slow每次往后移动一步,fast到达倒数第二个节点时,slow正好走到链表中间部分
fast = fast.next.next;
slow = slow.next;
}
TreeNode thead = new TreeNode(slow.val); //取当前的中间节点作为根节点
thead.left = toBST(head,slow); //对当前根节点的左边链表部分作左子树递归
thead.right = toBST(slow.next,tail); //对当前根节点的右边链表部分作右子树递归
return thead;
}
}
2. Populating Next Right Pointers in Each Node
Given a binary tree
struct TreeLinkNode { TreeLinkNode *left; TreeLinkNode *right; TreeLinkNode *next; }
Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL
.
Initially, all next pointers are set to NULL
.
Note:
- You may only use constant extra space.
- You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent has two children).
For example,
Given the following perfect binary tree,
1 / 2 3 / \ / 4 5 6 7
After calling your function, the tree should look like:
1 -> NULL / 2 -> 3 -> NULL / \ / 4->5->6->7 -> NULL
思路:本来想通过层次便利来解题,因为隔了好久没有做算法题,突然还是有点手生。还是看了discuss一下,有一种比较简单的解法,还是从上往下一层层的来,对于当点节点cur,如果它有左子节点,那么按照题目的意思它必有右子节点,那么左子节点的next指向的是父节点的右子节点,对于这个右子节点来说,如果它的父节点的next不是null的话,那么这个右子节点的next指向的应该是它父节点的next节点的左子节点。这样从上往下循环即可。
public class Solution {
public void connect(TreeLinkNode root) {
TreeLinkNode level_start=root;
while(level_start!=null){
TreeLinkNode cur=level_start;
while(cur!=null){
if(cur.left!=null) cur.left.next=cur.right;
if(cur.right!=null && cur.next!=null) cur.right.next=cur.next.left;
cur=cur.next;
}
level_start=level_start.left;
}
}
}
上面的算法只对满二叉树的情形下有效,那么如果二叉树是任意的二叉树时又该怎么解题呢?比如说
Given the following binary tree,
1 / 2 3 / \ 4 5 7
After calling your function, the tree should look like:
1 -> NULL / 2 -> 3 -> NULL / \ 4-> 5 -> 7 -> NULL
解法和上题类似,还是一层层的从左往右遍历,对于当前层次上的节点cur,考虑其左右子节点的情况,这个过程需要一个prev来记录上一个链接中的上一个节点是什么,以及下一层的第一节点以便后续便利。
public class Solution {
//based on level order traversal
public void connect(TreeLinkNode root) {
TreeLinkNode head = null; //head of the next level
TreeLinkNode prev = null; //the leading node on the next level
TreeLinkNode cur = root; //current node of current level
while (cur != null) {
while (cur != null) { //iterate on the current level
//left child
if (cur.left != null) {
if (prev != null) {
prev.next = cur.left; // 如果左子节点不是空且前一个节点不是空,直接链接,如果前一个节点是空,由于cur是从左到右便利的,下层第一个不是空的子节点便是下层的第一个节点
} else {
head = cur.left;
}
prev = cur.left; // 将链接好的节点置为prev节点
}
//right child
if (cur.right != null) {
if (prev != null) {
prev.next = cur.right;
} else {
head = cur.right;
}
prev = cur.right;
}
//move to next node
cur = cur.next;
}
//move to next level
cur = head;
head = null;
prev = null;
}
}
}
3. Word Ladder
Given two words (beginWord and endWord), and a dictionary‘s word list, find the length of shortest transformation sequence from beginWord to endWord, such that:
- Only one letter can be changed at a time.
- Each transformed word must exist in the word list. Note that beginWord is not a transformed word.
Note:
- Return 0 if there is no such transformation sequence.
- All words have the same length.
- All words contain only lowercase alphabetic characters.
- You may assume no duplicates in the word list.
- You may assume beginWord and endWord are non-empty and are not the same.
Example 1:
Input: beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"] Output: 5 Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog", return its length 5.
Example 2:
Input: beginWord = "hit" endWord = "cog" wordList = ["hot","dot","dog","lot","log"] Output: 0 Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
思路:可以使用BFS来解决这题,对于beginWord,和它临接的边是它在wordList中所能transform到的单词,这是第一层,那么第二层就是第一层所能transform到的所有单词,所以是个典型的BFS问题。试了下一般的BFS,如果从开始单词一层层的往外找,结果会超时,所以采取两端同时BFS,即从beginWord和endWord两端开始BFS。
public class Solution {
public int ladderLength(String beginWord, String endWord, Set<String> wordList) {
if(!wordList.contains(endWord)) return 0;
Set<String> beginSet = new HashSet<String>(), endSet = new HashSet<String>();
int len = 1;
HashSet<String> visited = new HashSet<String>();
beginSet.add(beginWord);
endSet.add(endWord);
// 如果从beginWord到endWord的BFS或者从endWord到beginWord的BFS过程中有哪一层是空的话,则表明beginWord到endWord走不通
while (!beginSet.isEmpty() && !endSet.isEmpty()) {
if (beginSet.size() > endSet.size()) { // BFS从beginWord到endWord,交换BFS方向是为了减少计算次数
Set<String> set = beginSet;
beginSet = endSet;
endSet = set; // 这里交换beginSet和endSet来实现BFS方向的改变
}
Set<String> temp = new HashSet<String>();
for (String word : beginSet) {
char[] chs = word.toCharArray();
for (int i = 0; i < chs.length; i++) {
for (char c = ‘a‘; c <= ‘z‘; c++) {
char old = chs[i];
chs[i] = c;
String target = String.valueOf(chs);
if (endSet.contains(target)) { // 两端BFS过程中,如果相遇则直接返回BFS深度,还要加1才是题目要求的
return len + 1;
}
if (!visited.contains(target) && wordList.contains(target)) {
temp.add(target);
visited.add(target);
}
chs[i] = old;
}
}
}
beginSet = temp;
len++;
}
return 0;
}
}
这里的 two-end BFS,以及BFS中改变遍历的方向以减少计算量还是很有意思的。
以上是关于LeetCode解题报告——Convert Sorted List to Binary Search Tree & Populating Next Right Pointers in Each的主要内容,如果未能解决你的问题,请参考以下文章
LeetCode --- 1317. Convert Integer to the Sum of Two No-Zero Integers 解题报告
LeetCode解题报告——Convert Sorted List to Binary Search Tree & Populating Next Right Pointers in Each
LeetCode --- 1576. Replace All ?‘s to Avoid Consecutive Repeating Characters 解题报告
LeetCode --- 1576. Replace All ?‘s to Avoid Consecutive Repeating Characters 解题报告