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中改变遍历的方向以减少计算量还是很有意思的。
原文地址:https://www.cnblogs.com/f91og/p/8709546.html