27. 移除元素https://leetcode.cn/problems/remove-element/
给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1:
输入:nums = [3,2,2,3], val = 3
输出:2, nums = [2,2]
解释:函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。
例如,函数返回的新长度为 2 ,而 nums = [2,2,3,3] 或 nums = [2,2,0,0],也会被视作正确答案。
示例 2:
输入:nums = [0,1,2,2,3,0,4,2], val = 2
输出:5, nums = [0,1,3,0,4]
解释:函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
使用一个指针来记录遇到的val的次数count,遍历过程中,把每一个不为val的数往后移动count个位置,如果遇到val后,就增加count。
class Solution {
public int removeElement(int[] nums, int val) {
int count = 0;
for (int i = 0; i < nums.length; i++) {
if (nums[i] != val) {
nums[i - count] = nums[i];
} else {
count++;
}
}
return nums.length - count;
}
}
344. 反转字符串https://leetcode.cn/problems/reverse-string/
编写一个函数,其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间,你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例 1:
输入:s = ["h","e","l","l","o"]
输出:["o","l","l","e","h"]
示例 2:
输入:s = ["H","a","n","n","a","h"]
输出:["h","a","n","n","a","H"]
对整个流程进行抽象找出共性,也就是第一个和倒数第一个交换,第二个和倒数第二个交换,所以采取双指针。
class Solution {
public void reverseString(char[] s) {
int left = 0;
int right = s.length - 1;
while (left <= right) {
char temp = s[left];
s[left++] = s[right];
s[right--] = temp;
}
}
}
54. 替换数字https://kamacoder.com/problempage.php?pid=1064给定一个字符串 s,它包含小写字母和数字字符,请编写一个函数,将字符串中的字母字符保持不变,而将每个数字字符替换为number。 例如,对于输入字符串 "a1b2c3",函数应该将其转换为 "anumberbnumbercnumber"。
输入描述:输入一个字符串 s,s 仅包含小写字母和数字字符。
输出描述:打印一个新的字符串,其中每个数字字符都被替换为了number
输入示例:
a1b2c3
输出示例:
anumberbnumbercnumber
对于字符串的操作高级一点的反转和追加两种操作,之前是用了追加来解决这个问题,这道题放在双指针的位置是因为C++的字符串可更改,可以不添加一个新的字符串空间进行操作,但是Java的String不可变,始终需要一个StringBuilder来作为新的字符串。不过思路值得思考。追加是从后往前进行追加,需要追加到一个新的数组,采取从后往前,补齐需要的长度,从后往前追加依次替换。
import java.util.Scanner;
class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
StringBuilder sb = new StringBuilder(in.next());
int count = 0;
int left = sb.length() - 1;
for (int i = 0; i < sb.length(); i++) {
if (sb.charAt(i) >= '0' && sb.charAt(i) <= '9') {
count++;
}
}
sb.append(new char[count * 5]);
int right = sb.length() - 1;
while (left >= 0) {
if (Character.isLowerCase(sb.charAt(left))) {
sb.setCharAt(right--, sb.charAt(left--));
} else {
sb.setCharAt(right--, 'r');
sb.setCharAt(right--, 'e');
sb.setCharAt(right--, 'b');
sb.setCharAt(right--, 'm');
sb.setCharAt(right--, 'u');
sb.setCharAt(right--, 'n');
left--;
}
}
System.out.println(sb);
}
}
151. 反转字符串中的单词https://leetcode.cn/problems/reverse-words-in-a-string/
给你一个字符串 s ,请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意:输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中,单词间应当仅用单个空格分隔,且不包含任何额外的空格。
示例 1:
输入:s = "the sky is blue"
输出:"blue is sky the"
示例 2:
输入:s = " hello world "
输出:"world hello"
解释:反转后的字符串中不能存在前导空格和尾随空格。
示例 3:
输入:s = "a good example"
输出:"example good a"
解释:如果两个单词间有多余的空格,反转后的字符串需要将单词间的空格减少到仅有一个。
字符串的操作:遍历,追加,判断字符,反转。
这道题需要做的事情是进行单词的反转,也就是说分割出一个一个的单词后,以单词的形式进行反转。
但是,仔细想想,其实可以依据两次反转完成,整体反转,然后单词反转恢复。
需要注意的是需要提前去除多余的空格。
class Solution {
public String reverseWords(String s) {
StringBuilder sb = removerSpace(s);
reverse(sb, 0, sb.length() - 1);
int left = 0;
for (int i = 1; i < sb.length() - 1; i++) {
if (sb.charAt(i) == ' ') {
reverse(sb, left, i - 1);
left = i + 1;
}
}
reverse(sb, left, sb.length() - 1);
return String.valueOf(sb);
}
public void reverse(StringBuilder sb, int left, int right) {
while (left <= right) {
char temp = sb.charAt(left);
sb.setCharAt(left++, sb.charAt(right));
sb.setCharAt(right--, temp);
}
}
public StringBuilder removerSpace(String s) {
StringBuilder sb = new StringBuilder();
int start = 0;
int end = s.length() - 1;
while (s.charAt(start) == ' ') {
start++;
}
while (s.charAt(end) == ' ') {
end--;
}
for (int i = start; i <= end; i++) {
if (s.charAt(i) == ' ' && s.charAt(i - 1) == ' ') {
continue;
}
sb.append(s.charAt(i));
}
return sb;
}
}
206. 反转链表https://leetcode.cn/problems/reverse-linked-list/给你单链表的头节点
head
,请你反转链表,并返回反转后的链表。
示例 1:
输入:head = [1,2,3,4,5]
输出:[5,4,3,2,1]
示例 2:
输入:head = []
输出:[]
链表的反转问题在于指针指向反转后,链表断裂了,无法找到节点,所以采取双指针。pre指向前一个,cur指向当前。
class Solution {
public ListNode reverseList(ListNode head) {
if (head == null || head.next == null)
return head;
ListNode pre = null;
ListNode cur = head;
while(cur!=null) {
ListNode next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
return pre;
}
}
19.删除链表的倒数第N个节点备战技术面试?力扣提供海量技术面试资源,帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。https://leetcode.cn/problems/remove-nth-node-from-end-of-list/给你一个链表,删除链表的倒数第
n
个结点,并且返回链表的头结点。
使用快慢指针,快指针先出发n个节点,当快指针为空的时候,如果慢指针未出发,说明没有倒数第n个,不操作,如果出发了,就删除慢指针的节点。
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode fakeHead = new ListNode();
fakeHead.next = head;
ListNode fast = fakeHead;
ListNode slow = fakeHead;
for (int i = 0; i < n; i++) {
if (fast == null) {
return head;
}
fast = fast.next;
}
while (fast.next != null) {
fast = fast.next;
slow = slow.next;
}
slow.next = slow.next.next;
return fakeHead.next;
}
}
面试题 02.07. 链表相交https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/给你两个单链表的头节点
headA
和 headB
,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null
。
先进行两个链表的遍历,可以得到较长链表的长度,然后就可以一起遍历,一起到达相交节点进行判断。
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode curA = headA;
ListNode curB = headB;
int lengA = 0, lengB = 0;
while (curA != null) {
curA = curA.next;
lengA++;
}
while (curB != null) {
curB = curB.next;
lengB++;
}
curA = headA;
curB = headB;
if (lengA > lengB) {
for (int i = 0; i < lengA - lengB; i++) {
curA = curA.next;
}
} else {
for (int i = 0; i < lengB - lengA; i++) {
curB = curB.next;
}
}
while (curA != null && curB != null) {
if (curA == curB)
return curA;
else {
curA = curA.next;
curB = curB.next;
}
}
return null;
}
给定一个链表的头节点 head ,返回链表开始入环的第一个节点。 如果链表无环,则返回 null。
如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos 是 -1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例 1:
输入:head = [3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点
解释:链表中有一个环,其尾部连接到第二个节点。
先通过快慢指针判断是否有环,相遇后,此时分别从head和相遇点继续出发再次相遇就是入环点。
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode fast = head;
ListNode slow = head;
while (fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
if (fast == slow) {
ListNode index = head;
while (index != fast) {
index = index.next;
fast = fast.next;
}
return index;
}
}
return null;
}
}
15. 三数之和备战技术面试?力扣提供海量技术面试资源,帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。https://leetcode.cn/problems/3sum/description/
给你一个整数数组 nums ,判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ,同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意:答案中不可以包含重复的三元组。
示例 1:
输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]]
解释:
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意,输出的顺序和三元组的顺序并不重要。
示例 2:
输入:nums = [0,1,1]
输出:[]
解释:唯一可能的三元组和不为 0 。
示例 3:
输入:nums = [0,0,0]
输出:[[0,0,0]]
解释:唯一可能的三元组和为 0 。
要确定三元组,还不能重复,所以需要先进行排序。
三个未知数的逻辑是很混乱和复杂的,所以可以考虑固定一个,在遍历一个数字的过程中去思考另外两个的组成关心。由于本身已经排过序了,就可以根据相加数的大小来控制。采取双指针。
class Solution {
public List> threeSum(int[] nums) {
List> res = new ArrayList<>();
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
if (nums[i] > 0)
return res;
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
int left = i + 1;
int right = nums.length - 1;
while (left < right) {
int sum = nums[i] + nums[left] + nums[right];
if (sum > 0) {
right--;
} else if (sum < 0) {
left++;
} else {
res.add(Arrays.asList(nums[i], nums[left], nums[right]));
left++;
right--;
while (left < right && nums[left] == nums[left - 1])
left++;
while (left < right & nums[right] == nums[right + 1])
right--;
}
}
}
return res;
}
}
18. 四数之和https://leetcode.cn/problems/4sum/
给你一个由 n 个整数组成的数组 nums ,和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] (若两个四元组元素一一对应,则认为两个四元组重复):
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。
和三数之和一样,三个数以及以上的组合特别复杂,所以只能抽出两个,另外两个实验2个for循环嵌套。
class Solution {
public List> fourSum(int[] nums, int target) {
Arrays.sort(nums);
List> res = new ArrayList<>();
for (int i = 0; i < nums.length; i++) {
if (nums[i] > 0 && nums[i] > target) {
return res;
}
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
for (int j = i + 1; j < nums.length; j++) {
if (j > i + 1 && nums[j] == nums[j - 1]) {
continue;
}
int left = j + 1;
int right = nums.length - 1;
while (left < right) {
int sum = nums[i] + nums[j] + nums[left] + nums[right];
if (sum > target) {
right--;
} else if (sum < target) {
left++;
} else {
res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
left++;
right--;
while (left < right && nums[left] == nums[left - 1])
left++;
while (left < right && nums[right] == nums[right + 1])
right--;
}
}
}
}
return res;
}
}