weixin_44428467的博客

/** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */import java.util.*;public class Solution { public void reorderL.

请实现有重复数字的升序数组的二分查找给定一个 元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的第一个出现的target，如果目标值存在返回下标，否则返回 -1。import java.util.*;public class Solution { /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * 如果目标值存在返回下标，否则返回 -1 * @param n

import java.util.*;/* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */public class Solution { /** * * @param root TreeNode类 * @param sum int整型 * @return bool布尔型 .

假定你知道某只股票每一天价格的变动。你最多可以同时持有一只股票。但你可以无限次的交易（买进和卖出均无手续费）。请设计一个函数，计算你所能获得的最大收益。import java.util.*;public class Solution { /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * 计算最大收益 * @param prices int整型一维数组 股票每一天的价格 * @return int整型

给定数组arr，arr中所有的值都为正整数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个aim，代表要找的钱数，求组成aim的最少货币数。如果无解，请返回-1.import java.util.*;public class Solution { /** * 最少货币数 * @param arr int整型一维数组 the array * @param aim int整型 the target * @return int

统计一个数字在升序数组中出现的次数。public class Solution { public int GetNumberOfK(int [] array , int k) { int left=0; int right=array.length; int l=0,r=0; while(left<right){ int mid=(left+right)/2; if(array[

已知两颗二叉树，将它们合并成一颗二叉树。合并规则是：都存在的结点，就将结点值加起来，否则空的位置就由另一个树的结点来代替。例如：import java.util.*;/* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */public class Solution { /** * * @param t1

现在有一个只包含数字的字符串，将该字符串转化成IP地址的形式，返回所有可能的情况。例如：给出的字符串为"25525522135",返回[“255.255.22.135”, “255.255.221.35”]. (顺序没有关系)IP地址：IP地址是一个32位的二进制数，通常被分割为4个“8位二进制数”（也就是4个字节）。IP地址通常用“点分十进制”表示成（a.b.c.d）的形式，其中，a,b,c,d都是0~255之间的十进制整数。例：点分十进IP地址（100.4.5.6），实际上是32位二进制数。

已知int一个有序矩阵mat，同时给定矩阵的大小n和m以及需要查找的元素x，且矩阵的行和列都是从小到大有序的。设计查找算法返回所查找元素的二元数组，代表该元素的行号和列号(均从零开始)。保证元素互异。import java.util.*;public class Solution { public int[] findElement(int[][] mat, int n, int m, int x) { // write code here int i=0;

给定一棵二叉树，已知其中的节点没有重复值，请判断该二叉树是否为搜索二叉树和完全二叉树。二叉搜索树：树为空或者左节点的值小于根节点，右节点的值大于根节点，并且左右子树都是二叉搜索树。错误写法： public boolean Sou(TreeNode root){ if(root==null) return true; int leftVal = root.left == null ? Integer.MIN_VALUE : root.left.v

给定两个有序数组arr1和arr2，已知两个数组的长度都为N，求两个数组中所有数的上中位数。上中位数：假设递增序列长度为n，若n为奇数，则上中位数为第n/2+1个数；否则为第n/2个数[要求]时间复杂度为O(logN)，额外空间复杂度为O(1)采用类似双指针的方法。int p1=0,p2=0,mid=0; for(int i=0;i<arr1.length;i++){ if(arr1[p1]<=arr2[p2]){ mid=arr1

给出一组区间，请合并所有重叠的区间。请保证合并后的区间按区间起点升序排列。先对Interval进行排序升序排序而后比较 两个区间的pre.end和next.start的大小，决定新区间的左右边界。/** * Definition for an interval. * public class Interval { * int start; * int end; * Interval() { start = 0; end = 0; } * Interval(

给出一个升序排序的链表，删除链表中的所有重复出现的元素，只保留原链表中只出现一次的元素。import java.util.*;/* * public class ListNode { * int val; * ListNode next = null; * } */public class Solution { /** * * @param head ListNode类 * @return ListNode类 */ p

最大数：给定一个数组由一些非负整数组成，现需要将他们进行排列并拼接，使得最后的结果最大，返回值需要是string类型 否则可能会溢出。30，304的排列为：3043030，301的排列为30301，对于两个数字，可以比较他们排列之后的ASSCAL值。选择阿斯克码值大的排在前面。import java.util.*;public class Solution { /** * 最大数 * @param nums int整型一维数组 * @return s

数据的流向成为IO流，输入叫读取数据，输出叫写出数据。输入流：从其他设备读取到内存中输出流：将内存中的数据写到其他设备中以字节为单位，读写数据，叫字节流，字节输入流InputStream，字节输出流 OutputStream以字符为单位，读写数据，叫字符流。字符输入流：...

给定一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。要求算法时间复杂度必须是O(n)。示例 1:输入: [3, 2, 1]输出: 1解释: 第三大的数是 1.示例 2:输入: [1, 2]输出: 2解释: 第三大的数不存在, 所以返回最大的数 2 .示例 3:输入: [2, 2, 3, 1]输出: 1解释: 注意，要求返回第三大的数，是指第三大且唯一出现的数。存在两个值为2的数，它们都排第二来源：力扣（LeetCode）链接：https://leetco

统计位数为偶数的数字代码：class Solution { public int findNumbers(int[] nums) { int count=0; for (int i=0;i<nums.length;i++){ String s=String.valueOf(nums[i]); if (s.length()%2==0) count+=1; } .

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。你可以假设数组中无重复元素。采用二分查找法。class Solution { public int searchInsert(int[] nums, int target) { int left=0; int right=nums.length-1; int mid=(left+right)/2; while

从最后开始遍历，直到遇到空格。class Solution { public int lengthOfLastWord(String s) { if (s.length()==0) return 0; int count=0; for (int i = s.length()-1; i >=0 ; i--) { if (s.charAt(i)==' ' && count!=0).

class Solution { public int findMaxConsecutiveOnes(int[] nums) { int max=0; int count=0; for (int i = 0; i <nums.length; i++) { if (nums[i]==1) count+=1; else{ if (coun.

将数组分成和相等的三个部分给你一个整数数组 A，只有可以将其划分为三个和相等的非空部分时才返回 true，否则返回 false。形式上，如果可以找出索引 i+1 < j 且满足 A[0] + A[1] + … + A[i] == A[i+1] + A[i+2] + … + A[j-1] == A[j] + A[j-1] + … + A[A.length - 1] 就可以将数组三等分。示例 1：输入：[0,2,1,-6,6,-7,9,1,2,0,1]输出：true解释：0 + 2 + 1.

按奇偶排序数组给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。你可以返回满足此条件的任何数组作为答案。示例：输入：[3,1,2,4]输出：[2,4,3,1]输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。代码：class Solution { public int[] sortArrayByParity(int[] A) { int[] as=new int[A.length]; .

今天学习了Java基础之fiel类构造方法：public fiel(String Pathname)public fiel(String Parent, String Child)public fiel(fiel Parent, String child)Fiel fiel=new Fiel(“String Path”)常用的方法fiel.getName() 返回文件或者目录名称...

var Queue=function(){ this.item=[]; } //加入元素 Queue.prototype.push=function(element){ this.item.push(element); } //删除队头元素 Queue.prototype.remove=function(){ return this.item.shift(); } //查看队首元素 Queue.prototype.LOOK=fun

合并两个有序链表题解：依次比较两个链表的节点，较小者插入，同时指向下一节点，当其中一个到链尾时，将另一个剩下的节点全部插入新链表尾部。/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListN.

206.反转一个单链表。创建一个栈存储链表元素，进栈在出栈，存入新建的链表。import java.util.Stack;public class ConvertLianbiao { public static void main(String[] args) { ListNode a=new ListNode(2); ListNode b=new ListNode(4); b.next=new ListNode(3); a.n

编写一个程序，找到两个单链表相交的起始节点。解法一：双指针法，当长度不相同时，遍历到尾部时，指针移到另一个链表的头部，最终会相遇在相交点。若长度相同时，首次遍历时，边遍历便比较是否相等，相等则结束，不相等且两个链表都到达过尾部，则重新比较，接下来的遍历是否相等。/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNod

有一堆石头，每块石头的重量都是正整数。每一回合，从中选出两块 最重的 石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 0。class Solution { public int lastStoneWeight(int[

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，能够偷窃到的最高金额。题解：第一个房间和最后一个房间只能选择一个偷。所以将这个问题转换成两个打家劫舍1的问题，调用两次动态规划，分别是有房间1没有最后一个房间，和没有房间1有最后一个房

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。解题思路：使用动态规划算法，相邻的房间不能同时被偷。当有i个房间时，此时被偷的金额最大为，当前房间的金额+前i-2个房间的被偷的最大金额。或者第i个房间不偷，直接为第i-1个房间最大的值。dp[i]=max{a

给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。说明：拆分时可以重复使用字典中的单词。你可以假设字典中没有重复的单词。解题思路：使用动态规划。其中dp[i]是s[0,i-1]能够被拆分为字典中出现的若干单词。我们需要枚举 s[0…i-1]s[0…i−1] 中的分割点 j，看 s[0…j-1]组成的字符串 s1 默认 j = 0 s1为空串）和 s[j…i-1]组成的字符串 s2​是否都合法，如果两个字符串均合

在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物解题思路：使用动态规划的思想。当前(i,j)位置最大的价值只能是当前位置礼物的价值+左边位置(i,j-1)礼物的最大价值 或者 当前位置礼物的价值+上边位置(i-1,j)的最大价值，选择最大的作为最终价值。由于第一行或者第一列，只能由左边或者上边到达，所有需要单

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。你有注意到翻转后的整数可能溢出吗？因为给出的是32位整数，则其数值范围为[−2^{31}, 2^{31} − 1]。翻转可能会导致溢出，如果反转后的结果会溢出就返回 0。import java.util.*;public class Solution { /** * * @param x int整型 * @return int整型 */ public int re

从0,1,2,…,n这n+1个数中选择n个数，找出这n个数中缺失的那个数，要求O(n)尽可能小。import java.util.*;public class Solution { /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * 找缺失数字 * @param a int整型一维数组 给定的数字串 * @return int整型 */ public int solve (int[

给定一个仅包含数字\ 0-9 0−9 的二叉树，每一条从根节点到叶子节点的路径都可以用一个数字表示。例如根节点到叶子节点的一条路径是1\to 2\to 31→2→3,那么这条路径就用\ 123 123 来代替。找出根节点到叶子节点的所有路径表示的数字之和思想：利用树的前序遍历。public class SumofTree { public static void main(String[] args) { TreeNode root=new TreeNode(1);

给定一个链表，请判断该链表是否为回文结构。利用快慢指针，快指针的速度是慢指针速度的两倍，当快指针到达链表尾部的时候，慢指针到达链表的中部，同时将慢指针的值进栈，特别注意，如果链表的长度是奇数时，在比较之前要调整一次慢指针的位置。public class Solution { /** * * @param head ListNode类 the head * @return bool布尔型 */ public boolean isPail (List

输入一棵二叉树，判断该二叉树是否是平衡二叉树。条件遍历根节点的左右子树，如果左子树或者右子树有一个不是平衡二叉树，则整棵树都不是平衡二叉树。public class Solution { public boolean IsBalanced_Solution(TreeNode root) { return getDeep(root)!=-1; } public int getDeep(TreeNode root){

给定一个二叉树和一个值\ sum sum，请找出所有的根节点到叶子节点的节点值之和等于\ sum sum 的路径，例如：深度优先搜索+回溯法，最后要减去加上的节点的值，并且返回到上一届迪纳的位置。 public ArrayList<ArrayList<Integer>> pathSum (TreeNode root, int sum) { // write code here ArrayList<ArrayList<Intege

假定你知道某只股票每一天价格的变动。你最多可以同时持有一只股票。但你最多只能进行两次交易（一次买进和一次卖出记为一次交易。买进和卖出均无手续费）。请设计一个函数，计算你所能获得的最大收益。import java.util.*;public class Solution { /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * 两次交易所能获得的最大收益 * @param prices int整型一维数组 股票每一天的价格

import java.util.*;public class Solution { /** * max water * @param arr int整型一维数组 the array * @return long长整型 */ public long maxWater (int[] arr) { // write code here if(arr==null||arr.length==0) r