代码随想录刷题笔记-Day09

最新推荐文章于 2024-06-05 23:42:25 发布
最新推荐文章于 2024-06-05 23:42:25 发布
阅读量934 收藏 22
点赞数 19
分类专栏： 代码随想录 文章标签： 笔记 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53711959/article/details/135771864
版权

1. 移除元素

27. 移除元素icon-default.png?t=N7T8https://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;
	}
}

2. 反转字符串

344. 反转字符串icon-default.png?t=N7T8https://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;
		}
	}
}

3. 替换数字

54. 替换数字icon-default.png?t=N7T8https://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);
	}
}

4. 反转字符串里面的单词

151. 反转字符串中的单词icon-default.png?t=N7T8https://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;
	}
}

5. 反转链表

206. 反转链表icon-default.png?t=N7T8https://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;
	}
}

6. 删除链表的倒数第N个节点

19.删除链表的倒数第N个节点备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://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;
    }
}

7. 链表相交

面试题 02.07. 链表相交icon-default.png?t=N7T8https://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;
	}

8. 环形链表II

给定一个链表的头节点  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;
    }
}

9. 三数之和

15. 三数之和备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://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<List<Integer>> threeSum(int[] nums) {

        List<List<Integer>> 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;
    }
}

10. 四数之和

18. 四数之和icon-default.png?t=N7T8https://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<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> 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;
    }
}

枯树老斑鸠
关注
  • 19
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
代码随想录刷题打卡day02
04-18
代码随想录刷题打卡day02
代码随想录+刷题笔记记录
03-22
本文主要介绍代码随想录的刷题笔记记录，方便读者更好地利用该网站进行学习。 ## 刷题笔记记录的作用 刷题笔记记录是代码随想录提供的一个功能，用于记录用户在刷题过程中的解题思路和方法。它可以帮助用户更好地...
代码随想录刷题笔记-Day12
qq_53711959的博客
01-27 498
144. 二叉树的前序遍历94. 二叉树的中序遍历145. 二叉树的后续遍历二叉树的深度优先遍历，是一个递归式的算法，对于递归，需要注意的就是每次递归的返回值，以及每次递归需要的参数，以及中止条件和进入递归的判断逻辑。
代码随想录刷题笔记-Day11
qq_53711959的博客
01-25 989
150. 逆波兰表达式求值给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。请你计算该表达式。返回一个表示表达式值的整数。
代码随想录刷题笔记-Day25
qq_53711959的博客
02-28 588
131. 分割回文串给你一个字符串s，请你将s分割成一些子串，使每个子串都是。返回s所有可能的分割方案。是正着读和反着读都一样的字符串。
代码随想录刷题笔记-Day17
qq_53711959的博客
02-16 1119
112. 路径总和给你二叉树的根节点 root 和一个表示目标和的整数 targetSum。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum。如果存在，返回 true；否则，返回 false。叶子节点 是指没有子节点的节点。
代码随想录刷题笔记-Day18
qq_53711959的博客
02-17 952
617. 合并二叉树给你两棵二叉树： root1 和 root2。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。返回合并后的二叉树。注意: 合并过程必须从两个树的根节点开始。
代码随想录刷题笔记-Day31
qq_53711959的博客
03-07 616
455. 分发饼干假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j]。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。
代码随想录刷题笔记-Day21
qq_53711959的博客
02-20 536
1.二叉搜索树中的插入操作 701. 二叉搜索树中的插入操作https://leetcode.cn/problems/insert-into-a-binary-search-tree/给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。 示例 1：
代码随想录刷题笔记-Day08
qq_53711959的博客
01-22 983
55. 右旋字符串pid=1065字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。例如，对于输入字符串 "abcdefg" 和整数 2，函数应该将其转换为 "fgabcde"。
代码随想录刷题笔记-Day14
qq_53711959的博客
01-29 739
101. 对称二叉树给你一个二叉树的根节点 root ， 检查它是否轴对称。
代码随想录-八股文 pdf
04-25
代码随想录-八股文 pdf
代码随想录-大厂八股文-面试
04-25
代码随想录-大厂八股文-面试
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
操作系统教材第6版——个人笔记3
最新发布
学徒心
06-05 732
这段笔记主要介绍了处理器相关内容，包括处理器与寄存器（如用户程序可见寄存器、控制与状态寄存器等及相关概念）、指令与处理器模式（机器指令、指令执行过程、特权与非特权指令、处理器模式及其切换等）；还阐述了中断管理，涵盖中断的概念（包括狭义中断、异常与系统异常等）、中断源（如处理器硬件故障、程序性、自愿性、I/O 及外部中断事件等）以及中断系统（包括其构成、中断响应处理与指令执行周期、中断装置及中断响应过程等
专属编程笔记
u014397365的博客
06-01 1039
在软件开发中，Utils（或Utilities）目录通常用于存放一些。这些工具类或函数为整个应用程序或多个模块提供便利的功能支持，使得代码更加模块化、易于维护和重用。UtilsUtils目录的设计目的在于避免代码重复，并确保在整个项目中以一致的方式处理共通任务。这样做可以提高开发效率，降低维护成本，并确保代码的整洁性和可读性。
Vue3实战笔记（52）—Vue 3封装持仓分析饼图
山花的博客
05-30 667
接上文，封装持仓分析饼图。封装好几个组件，用于后续开发。把忧愁煮成茶，让它在心间慢慢沉淀，剩下的，便是清甜的回味。
pytorch学习笔记5
drarad的博客
06-02 1360
前向钩子（forward hook）在模块的前向传播开始时触发，前向后钩子（forward pre-hook）在前向传播之前触发，反向钩子（backward hook）在反向传播过程中触发。总结来说，钩子提供了一种在 PyTorch 模型的执行过程中插入自定义代码的方法，使得用户可以灵活地调试、监控和扩展模型的功能。作用: 这是一个内部的 C 语言指针，指向张量在底层库（通常是 C++ 实现的 PyTorch 核心）中的具体数据结构。这些钩子可以在张量的梯度计算之前或之后执行自定义的操作。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值