zhang_han666的博客

题目：NC33 合并两个排序的链表思路：递归思路：递归函数返回的是合并后的链表；若两个节点有空，则返回另一个节点；递归函数要做的是，比较当前两个节点的值，较小的节点的下一个继续参与递归，返回这个较小的节点。代码：/*public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}*/public class Sol

题目：NC61 两数之和思路：借助map，存储数字和对应的下标。便利一遍数组：判断map中是否出现当前数字的另一半，如果出现，说明找到结果；否则把当前数组和下标存入map。代码：import java.util.*;public class Solution { /** * * @param numbers int整型一维数组 * @param target int整型 * @return int整型一维数组 */ pu

题目：NC15 求二叉树的层序遍历思路：广搜：借助队列实现树的广搜。深搜：递归，传入树的深度。代码：BFSimport java.util.*;/* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */public class Solution { /** * * @param root TreeN

题目： 平衡二叉树思路： dfs深搜递归函数返回深度，判断左右子树的深度差是否大于1。代码：public class Solution { public boolean result = true; public boolean IsBalanced_Solution(TreeNode root) { dfs(root); return result; } public int dfs (TreeNode root) {

题目：环形链表的约瑟夫问题思路：代码：import java.util.*;public class Solution { /** * * @param n int整型 * @param m int整型 * @return int整型 */ public int ysf (int n, int m) { // write code here if (n < 1 || m < 1)

题目：树的直径思路： dfs。首先，从任意一个节点开始深搜，找到权重最大的一条路径的末尾节点；从该节点开始，深搜，找到权重最大的路径即为所求。主要的点：图的表示权重的存储：不可以用二维矩阵，内存会溢出。深搜避免找回父节点代码：import java.util.*;/* * public class Interval { * int start; * int end; * } */public class Solution { /** *

题目：删除有序链表中重复出现的元素思路：双指针。一个指针a负责串起来不重复的元素，一个指针b负责寻找不重复的元素。如果下一个节点的值与当前节点值相等，那么移动指针b到下一个不相等的节点；否则把当前节点串到a指针。代码：import java.util.*;/* * public class ListNode { * int val; * ListNode next = null; * } */public class Solution { /**

题目：字符串变形思路：从后往前遍历字符串：遇到字符，把它大小写转变后插到一个StringBuilder的头部，实现单词序不变；遇到空格，说明一个单词被找到了，把存单词的StringBuilder和遇到的空格加入结果集，清空该缓存。代码：import java.util.*;public class Solution { public String trans(String s, int n) { // write code here char[]

题目：最长公共前缀思路1：排序所有字符串排序，然后只需找到第一个和最后一个元素的公共前缀。思路2：分治代码1：import java.util.*;public class Solution { /** * * @param strs string字符串一维数组 * @return string字符串 */ public String longestCommonPrefix (String[] strs) { //

题目：滑动窗口最大值思路：双端队列。队列的两端均可以删除元素。我们需要确保队列中的元素是递减的，这样每次可以从队列头部拿到滑动窗口的最大值。同时，随着窗口的移动，我们需要在队列里删除不在窗口的元素，因此，在队列里，我们保存的是元素的下标。遍历数组中的元素，重复以下过程：从队列尾部删除比当前元素小的所有元素；当前元素入队列；如果队列头部元素不在窗口内，删除它（队列中存的是索引）；如果滑动窗口已经形成，把队头元素加入结果集。代码：import java.util.*;public c

题目：二叉树最大深度思路：dfs或者bfs代码：import java.util.*;/* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */public class Solution { /** * * @param root TreeNode类 * @return int整型

题目：最近公共祖先思路1：在某个节点小找是否包含某个子节点很容易，所以我们可以对所有节点，判断是否包含给定的两个节点，取最近的即可。这个方法可以AC，但其实，两个递归做了很多重复的运算。思路2：其实，祖先节点只有如下三种情况两个节点分别在祖先节点两侧；a节点就是他们的祖先，b节点在a的左子树或右子树；b节点就是他们的祖先，a节点在b的左子树或右子树；我们从头深搜二叉树，如果root节点为空， 或者当前root节点等于两个节点其中一个，就返回当前节点root；递归对root左子树、r

题目：验证IP地址思路：对字符串基础的操作。代码：import java.util.*;public class Solution { /** * 验证IP地址 * @param IP string字符串 一个IP地址字符串 * @return string字符串 */ public String solve (String IP) { // write code here if (IP.contains(

题目：输出二叉树的右视图思路：递归简历二叉树，然后借助队列广搜，找到每层最右的节点。代码：import java.util.*;class TreeNode { int val; TreeNode left; TreeNode right; public TreeNode (int v) { this.val = v; this.left = null; this.right = null; }}publ

题目：字符串转化为整数思路：去除前后空格；若字符串为空，返回0；判断是否有符号；逐个读取字符转化为数字对于越界的判断：res * 10 + cur > Integer.MIN_VALUE 即为越界，移项后：res > ((Integer.MAX_VALUE - cur) / 10)代码：import java.util.*;public class Solution { /** * * @param str string字符串

题目： 合并区间思路：首先，对区间按照起点排序。然后逐个比较右端点是否可以合并。代码：/** * Definition for an interval. * public class Interval { * int start; * int end; * Interval() { start = 0; end = 0; } * Interval(int s, int e) { start = s; end = e; } * } */import j

题目：岛屿数量思路：深搜。从头遍历矩阵，如果遇到一个1，解加1，然后深搜把这个1相连的1全部置为0。注意：深搜要搜上下左右四个方向，不能只搜索右和下，因为有可能出现“ɔ”这种形状的岛屿，只搜索右方和下方不能覆盖这种情况。代码：import java.util.*;public class Solution { /** * 判断岛屿数量 * @param grid char字符型二维数组 * @return int整型 */ priva

题目：最小编辑代价思路：动态规划。leetcode类似的题目，三个操作的代价都是1，把问题抽象为三种情况：对a删除、对b删除、替换；而这道题三种操作的代价不同，而且只能对一个字符串修改，所以把问题抽象成：对a删除、对a插入、替换。转移方程如下：如果s1[i] == s2[j]，则 dp[i][j] = dp[i - 1][j - 1]。即，如果当前字符相等，那么此时不需要额外操作；如果s1[i] != s2[j]，则 dp[i][j] = Math.min(Math.min(dp[i][j - 1

题目：反转数字思路：可以全部反转之后判断是否越界；反转的过程中判断越界：如果越界，那么最高位会被丢掉，此时，整除10后与前一次的结果不同。代码：import java.util.*;public class Solution { /** * * @param x int整型 * @return int整型 */ public int reverse (int x) { // write code here

题目：反转字符串思路：调用API；转成char数组，然后两两交换。代码：import java.util.*;public class Solution { /** * 反转字符串 * @param str string字符串 * @return string字符串 */ public String solve (String str) { // write code here return new

题目：最长公共子序列思路：动态规划。dp[i][j]表示s1以i结尾，s2以j结尾的公共子序列长度，递推公式：如果str1[i] == str2[j]，则 dp[i][j] = dp[i - 1][j - 1] + 1如果str1[i] != str2[j]，则 dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1])有了这个dp数组，我们反推公共序列。从dp数组的右下角开始：如果两个字符相等，加入结果，然后下一步位置是左上角；如果两个字符不相等，那

题目：最长公共子串思路：动态规划dp[i][j]表示str1以i结尾，str2以j结尾的最长公共子串的个数，递推公式：如果str1[i] == str2[j]，则 dp[i][j] = dp[i - 1][j - 1] + 1如果str1[i] != str2[j]，则 dp[i][j] = 0有了这个dp数组，如何得到具体子串呢？我们在更新dp数组时，维护一个最大长度和最大子串的最终位置，每得到一个更长的子串，就更新最大长度和此时的位置，最后，用结尾的位置减去长度就可以得到子串的起始位置。

题目：设计getMin功能的栈思路：两个栈，一个是正常功能，一个存当前最小值。代码：import java.util.*;public class Solution { /** * return a array which include all ans for op3 * @param op int整型二维数组 operator * @return int整型一维数组 */ public int[] getMinStack (int[]

题目：两个链表的第一个公共节点思路：双指针。链表a、b的长度之和是一定的，两个指针分别指向两个链表头，同时后移，若移到链表尾就指向另一链表的表头。这样，二者必会相等。注意若没有相交，则二者同时到达对方链表尾部为空。代码：/*public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}*/public class Solu

题目：不相邻最大子序列和思路：动态规划。dp[i]为数组中以下标i结尾的最大子序列和，很显然，dp[i]要么是array[i]本身，要么是dp[i - 1]，要么是array[i] + dp[i - 2]。所以转移方程：dp[i] = Math.max(Math.max(array[i], dp[i - 1]), dp[i - 2] + array[i])代码：import java.util.*;public class Solution { /** * 代码中的类名、

题目：最长递增子序列思路：首先，动态规划可以解决。定义dp[i]为以i结尾的数组的最长递增子序列的长度，对于i之前的位置j，如果数组i处的值大于j，那么dp[i]可以在dp[j]的基础上加1。我们遍历i之前的位置，取最大值。得到dp数组后，其中的最大值就是最长递增子序列的长度，如何得到序列呢？反向遍历dp数组即可。例如：arr：[2, 1, 5, 3, 6, 4, 8, 9, 7]dp：[1, 1, 2, 2, 3, 3, 4, 5, 4]我们倒叙遍历dp，挨个找。找第5个位置：9找第4个

题目：数组中相加和为0的三元组思路：三指针。数组排序；遍历数组，设当前位置为cur，用两个指针left、right分别指向cur的下一个位置和数组最后一个位置，判断这三个数之和与0的大小：如果三数之和等于0，那么加入结果集，left右移直到不重复的数，right左移直到不重复；如果三数之和小于0，left右移一步；如果三数之和大于0，right左移一步。重复上述过程。去重：若cur的值与cur-1的值相等，就跳过；找到解时，移动left与right时，遇见重复的值也跳过。代码：i

题目：两数之和思路：哈希。建立一个哈希表，键是数组中的数组，值是该数的索引。然后我们就可以遍历数组，查找解是否存在。如果是建哈希表与遍历分开，那么会存在一个问题：如果一个数刚好出现2次并且target是该数的2倍，例8，2，3，2，9：target = 4。此时第一个2的索引会被覆盖。所以，我们建哈希表与查询结果在同一个循环内进行：拿到一个数num，我们先判断target-num是否在表里，如果在，那么找到答案，返回；如果不在，我们就把num及其索引存到表里。这样避免了有重复的问题。代码：imp

题目：合并区间思路：首先，对所有区间按照第一个数升序排列；把第一个区间放入结果集，接着遍历剩下的元素：如果当前遍历的元素的左值，大于结果集最后一个元素的右值，那么二者必然不能合并，把当前元素加入结果集；否则，二者可以合并，右值取二者右值更大的一个即可。代码：import java.util.*;/** * Definition for an interval. * public class Interval { * int start; * int end; *

题目：缺失数字思路：数组有序，所以判断索引与值不一样的索引就是缺失值。异或。若索引与值一致，则异或为0；由于索引不会取到n，所以n要额外参与异或。代码：import java.util.*;public class Solution { /** * 找缺失数字 * @param a int整型一维数组 给定的数字串 * @return int整型 */ public int solve (int[] a) { //

题目：找到字符串的最长无重复字符子串思路：滑动窗口。用两个指针记录滑动窗口的大小，用一个集合判断是否重复。如果没有重复就扩大窗口；有重复就记录此时最大长度，然后缩小窗口直到没有重复。重复以上过程。代码：集合实现import java.util.*;public class Solution { /** * * @param arr int整型一维数组 the array * @return int整型 */ public int max

题目：有重复数字的二分查找思路：二分。如果有重复，需要返回第一个出现的位置，所以当找到一个索引时，我们不停止，而是把它存下来。然后移动右指针，逼近左侧继续寻找。代码：import java.util.*;public class Solution { /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * 如果目标值存在返回下标，否则返回 -1 * @param nums int整型一维数组 *

题目：二叉树镜像思路：递归。递归函数返回的是已经镜像好的树；递归函数要做的是交换已经镜像好的左右子树。代码：import java.util.*;/* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * public TreeNode(int val) { * this.val = val; * } * } */p

题目：判断二叉树是否为搜索二叉树和完全二叉树思路：判断搜索二叉树：递归。递归函数返回是否是搜索二叉树；递归函数内部需要完成左子树、根、右子树的大小对比。判断完全二叉树：算法摘自百度百科。代码：import java.util.*;/* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */public class Solutio

题目：二叉树的之字形遍历思路：借助队列。队列实现层序遍历，然后反转奇数行。代码：import java.util.*;/* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */public class Solution { /** * * @param root TreeNode类 * @

题目：实现二叉树先序，中序，后序遍历思路：递归。本来我的想法是写三个递归函数分别实现，但其实一个递归函数就足够了。代码：import java.util.*;/* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */public class Solution { /** * * @param root

题目：二叉树根节点到叶子节点的和为定值思路：回溯代码：import java.util.*;/* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */public class Solution { /** * * @param root TreeNode类 * @param sum int整

题目：合并两个有序数组思路：三指针。把两个数组整合到其中一个数组A里，A有足够的空间可以容纳，因此可以借助未使用的那部分空间，从后往前整合两个数组。用三个指针，初始时，两个指向分别两个数组的最后一个元素，另一个cur指向A数组当前应该放数字的位置，即m+n-1；比较数组的两个元素，把大的数字挪到cur位置，相应指针前移。代码：public class Solution { public void merge(int A[], int m, int B[], int n) {

题目：括号匹配思路：栈代码：import java.util.*;public class Solution { /** * * @param s string字符串 * @return bool布尔型 */ public boolean isValid (String s) { // write code here Stack<Character> stack = new Stack<

题目：最小的K个数思路：最大堆最大堆是指，堆顶元素是堆中所有元素最大的一个，可以用优先队列实现这一数据结构，需要注意的是，对于基本数据类型，java默认优先队列升序，即相当于一个最小堆，所以我们需要重写cmopare()方法。先把数组前K个数放进堆里，剩余元素分别与堆顶元素比较，若小于堆顶元素，则弹出堆顶元素，把该元素放进堆里。其实冒泡排序也可以完成。冒泡排序每次可以找出一个最小值，这样外层循环K次即可得到答案。代码：import java.util.*;public class Solut