1. 两个链表的第一个重合节点
给定两个单链表的头节点 headA 和 headB ,请找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null 。
分析:
首先像个用哈希表来实现,但效率低
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
Set<ListNode> set = new HashSet<>();
ListNode node = headA;
while (node != null){
set.add(node);
node = node.next;
}
node = headB;
while (node != null){
if (set.contains(node)) return node;
node = node.next;
}
return null;
}
}
想要实现O(1)的空间复杂度,可以使用双指针来做。定义两个指针A和B分别初始化为headA和headB,当A和B不为null时:A=A.next,B=B.next;A为null令其等于headB,B为null令其等于headA。A=B时跳出循环。
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if (headA == null || headB == null) return null;
ListNode p1 = headA, p2 = headB;
while (p1 != p2){
p1 = p1==null?headB:p1.next;
p2 = p2==null?headA:p2.next;
}
return p1;
}
}
2. 链表中环的入口节点
给定一个链表,返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环,则返回 null。
分析:
首先想到的还是哈希表:
public class Solution {
public ListNode detectCycle(ListNode head) {
Set<ListNode> set = new HashSet<>();
ListNode node = head;
while (node != null){
if (!set.contains(node)) {
set.add(node);
node = node.next;
}
else return node;
}
return null;
}
}
想要实现O(1)空间使用快慢指针:
使用两个指针,fast 与 slow。它们起始都位于链表的头部。随后,slow 指针每次向后移动一个位置,而 fast 指针向后移动两个位置。如果链表中存在环,则fast 指针最终将再次与 slow 指针在环中相遇。
当发现 slow 与 fast 相遇时,我们再额外使用一个指针 ptr。起始它指向链表头部;随后,它和 slow 每次向后移动一个位置。最终,它们会在入环点相遇。
public class Solution {
public ListNode detectCycle(ListNode head) {
if (head == null) {
return null;
}
ListNode slow = head, fast = head;
while (fast != null) {
slow = slow.next;
if (fast.next != null) {
fast = fast.next.next;
} else {
return null;
}
if (fast == slow) {
ListNode ptr = head;
while (ptr != slow) {
ptr = ptr.next;
slow = slow.next;
}
return ptr;
}
}
return null;
}
}
3. 删除链表中倒数第n个节点
给定一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。
分析:
快慢指针。设置一个辅助头节点,方便删除操作,简化代码,将辅助头结点.next 指向 head。
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode head1 = new ListNode(0);
head1.next = head;
ListNode pre = null, cur = head1;
for (int i = 1; i < n; i++) {
cur = cur.next;
}
ListNode node = head1;
while (cur.next != null){
cur = cur.next;
pre = node;
node = node.next;
}
pre.next = node.next;
return head1.next;
}
}
4. 回文子字符串的个数
给定一个字符串 s ,请计算这个字符串中有多少个回文子字符串。
具有不同开始位置或结束位置的子串,即使是由相同的字符组成,也会被视作不同的子串。
分析:
遍历字符串,对每个字符,都看作回文的中心,向两端延申进行判断直到非回文。回文的中心可能是一个字符,也可能是两个字符。注意双指针可能越界。
class Solution {
public int countSubstrings(String s) {
if (null == s || s.length()==0) {
return 0;
}
int res = 0;
for (int i = 0; i < s.length(); i++) {
res += isPalindrome(s, i, i);
res += isPalindrome(s, i, i+1);
}
return res;
}
public int isPalindrome(String s, int start, int end) {
int count = 0;
while (start>=0 && end<s.length() && s.charAt(start) == s.charAt(end)) {
count++;
start--;
end++;
}
return count;
}
}
5. 最大层内元素和
给你一个二叉树的根节点 root。设根节点位于二叉树的第 1 层,而根节点的子节点位于第 2 层,依此类推。
请返回层内元素之和最大的那几层(可能只有一层)的层号,并返回其中最小的那个。
分析:
层次遍历,遍历每一层时计算节点值之和。
class Solution {
public int maxLevelSum(TreeNode root) {
if (root==null) return 0;
Deque<TreeNode> queue = new LinkedList<>();
int level = 0, maxSum = Integer.MIN_VALUE, res = 0;
queue.addLast(root);
while (!queue.isEmpty()){
int size = queue.size();
level++;
int sum = 0;
while (size>0){
TreeNode node = queue.pollFirst();
sum += node.val;
if (node.right!=null) queue.addLast(node.right);
if (node.left!=null) queue.addLast(node.left);
size--;
}
if (sum > maxSum){
res=level;
maxSum = sum;
}
}
return res;
}
}