快乐的大儿童附体

leetcode链接在这里/* * @lc app=leetcode.cn id=53 lang=java * * [53] 最大子序和 */// @lc code=startclass Solution { public int maxSubArray(int[] nums) { if(nums.length == 0){ return 0; } /*int sum = 0; int max

题目在这里双指针法+ hashset：hashset 存储无需元素，最适合不过了用一个指针start指向每次子串开始的位置，向后去计算。每次start向后移动1.import java.util.HashSet;/* * @lc app=leetcode.cn id=3 lang=java * * [3] 无重复字符的最长子串 */// @lc code=startclass Solution { public int lengthOfLongestSubstring.

题目链接在这里解法1class Solution { public int removeElement(int[] nums, int val) { int j = 0; for(int i = 0; i < nums.length; i++){ if(nums[i] != val){ nums[j++] = nums[i]; } } return

这个是公共子序列（本次题目的链接在这里），子序列中的重复字母可以不连续。上一个文章是求最长公共子串的长度（最长公共子串的链接在这里），子串要求必须是连续的。注意最长公共子串的时候，取出公共部分的首尾下标即可，但是本次的下标是离散分布的，只能用stringbuffer去存储。这里采用回溯的方式（应该是属于回溯的思想）去找回字符串。注意边界。i和j 是从1开始的。状态转移方程的推导过程大概如下状态转移方程如下：代码如下import java.util.*;public class

题目题目链接在这里思路的视频链接在这里思路大概是这样：状态转移方程为注意：new int的初始值为0，不用专门初始化下标是从1开始的import java.util.*;public class Solution { /** * longest common substring * @param str1 string字符串 the string * @param str2 string字符串 the string * @ret

题目链接在这里思路：将数组中每个位置上的累加起来就是总的水量首先求容器边界,然后使用双指针,分别从两边往中间扫描,当左边的高度小于右边的高度时,左指针++,如果此时当前位置的高度小于容器的边界高度,这个位置上方有水,进行水量累加。反之，则右指针向左扫描-1import java.util.*;public class Solution { /** * max water * @param arr int整型一维数组 the array * @

题目链接在此思路如下需要注意的点：取最短的那一列的长度作为循环条件substring( n , m] 是半开区间，不包含m方法不好，虽然实现了，但只得了这个结果。import java.util.*;public class Solution { /** * * @param strs string字符串一维数组 * @return string字符串 */ public String longestCommonPrefi.

链接在这里动态规划，真难啊题目注意的点：循环面值arr的时候，i是从0开始的；循环dp[j]的时候，直接从面值开始循环就行，不然的话还需要判断是否小于面值。import java.util.*;public class Solution { /** * 最少货币数 * @param arr int整型一维数组 the array * @param aim int整型 the target * @return int整型 */

题目链接在这里这题看起来就像是动态规划，但不会找状态…还是中规中矩写吧思路：找到数组中当前的最小值，res为max(res，当前值减去最小值)import java.util.*;public class Solution { /** * * @param prices int整型一维数组 * @return int整型 */ public int maxProfit (int[] prices) { if(price

题目在这里之字形打印二叉树，最容易想到的就是层次遍历了，以下是实现。缺点时间复杂度和空间复杂度都很高，不知道怎么优化。import java.util.ArrayList;import java.util.LinkedList;/*public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) {

题目给定一个链表，请判断该链表是否为回文结构。思路使用快慢指针，快指针的速度为慢指针的两倍，当快指针到达链表尾部时，慢指针到达中间位置（结点个数为奇数时，慢指针在正中间，为偶数时，慢指针在右侧的第一个），将慢指针之后的部分进行反转（当节点数为奇数时，将节点的下个节点以及之后的部分进行反转），再与前半部分进行比较。import java.util.*;/* * public class ListNode { * int val; * ListNode next = null; *

题目链接题目简介题目：最长回文子串描述：对于一个字符串，请设计一个高效算法，计算其中最长回文子串的长度。给定字符串A以及它的长度n，请返回最长回文子串的长度。示例1：输入：“abc1234321ab”,12，返回值：7解题方法有两种一、暴力解题1. 知识点public String substring(int beginIndex, int endIndex)beginIndex – 起始索引（包括）, 索引从 0 开始。endIndex – 结束索引（不包括）。2. 需要注意

题目在这里传送门要解决的首要问题就是用什么存储产生的数据第二个问题是是处理进位。思路：从字符串尾部计算结果，存如StringBuffer，依次拼接。import java.util.*;public class Solution { /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * 计算两个数之和 * @param s string字符串 表示第一个整数 * @param t string字符串 表示第二

题目链接描述给定一个链表，删除链表的倒数第 nn 个节点并返回链表的头指针例如，给出的链表为: 1→2→3→4→5,n=2.删除了链表的倒数第 nn 个节点之后,链表变为1→2→3→5.备注：题目保证 n 一定是有效的请给出请给出时间复杂度为O(n) 的算法以前写过一个输出倒数第n个节点的，思想都是类似的，都是使用快慢指针，链接在这里以前写的import java.util.*;/* * public class ListNode { * int val; * Lis

题目链接在这里，题目题目表述：描述给定一个数组arr，返回arr的最长无重复元素子数组的长度，无重复指的是所有数字都不相同。子数组是连续的，比如[1,3,5,7,9]的子数组有[1,3]，[3,5,7]等等，但是[1,3,7]不是子数组示例1，输入：[2,3,4,5]，返回值：4示例2，输入：[2,2,3,4,3]，返回值：3说明：[2,3,4]是最长子数组示例3，输入：[9]，返回值：1示例4，输入：[1,2,3,1,2,3,2,2]，返回值：3说明：最长子数组为[1,2,3]这题

上链接这里将给出的链表中的节点每\ k k 个一组翻转，返回翻转后的链表如果链表中的节点数不是\ k k 的倍数，将最后剩下的节点保持原样你不能更改节点中的值，只能更改节点本身。要求空间复杂度 \ O(1) O(1)例如：给定的链表是1\to2\to3\to4\to51→2→3→4→5对于 \ k = 2 k=2, 你应该返回 2\to 1\to 4\to 3\to 52→1→4→3→5对于 \ k = 3 k=3, 你应该返回 3\to2 \to1 \to 4\to 53→2→1→4→5

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。思路：动态规划用f(n)表示青蛙跳上n阶台阶的跳法数，设定f(0) = 1;当n = 1 时，只有一种跳的方式，一阶跳，f(1) = 1当n = 2 时，有两种跳的方式，一阶跳和两阶跳，f(2) = f(1) + f(0) = 2当n = 3 时，有三种跳的方式，第一次跳出一阶后，后面还有f(3-1)中跳法； 第一次跳出二阶后，后面还有f(3-2)中跳法；第一次跳出三阶后，后面还有f(3-3)中跳法

思想比较简单，队列先进先出，我们要实现两个操作，进队和出队；手里有2个栈，名为s1，s2。那么进队的时候：只从进s1，即s1.push即可；出队的时候：只从s2出。如果s2有元素的话，出栈即可；如果没有的话，令s1全部元素出栈，放入s2，返回s2.pop；具体实现如下：import java.util.Stack;public class Solution { Stack<Integer> s1 = new Stack<Integer>();

面小米算法岗的时候写过一次，当时用的C，现在用Java写一下。思路：用栈来实现。构造栈，把根节点入栈。循环栈中的元素，出栈一个节点(第一次出的是根节点)，输出data，如果有左孩子的话，左孩子进栈；有孩子同理。 private class Node{ int data; Node lc; Node rc; public Node(int data){ this.data = data;

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。思路：用hashmap存一下这些数key为数，value为次数。有的话+1，没有的话赋值为1.遍历hashmap，如果value*2大于arr.length，则返回即可。import java.util.HashMap;import java.util.Map;public class

思路；必须有两个初始值，不然后面没法计算，所以0,1这两个跑不掉。后面的话注意循环时的边界就行，i<=n的。如果写成<，那么n=2for循环不会运行。public class Solution { public int Fibonacci(int n) { if(n == 0 || n == 1){ return n; } int a = 0; int b = 1; int re

求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。两种做法，一种是直接通过公式算，一种是通过&&来实现if条件判断，并递归计算结果。public class Solution { public int Sum_Solution(int n) { // return (int)(Math.pow(n,2)+n)>>1; int s.

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。思路：查找不是问题，时间复杂度才是。暴力查找时间复杂度为O(nm),不考虑;只考虑两种，一种是二分O(nlogm)，一种是O(n+m)public class Solution { public boolean Find(int target, int [][] array) { i.

给定一个整数数组 nums，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。示例:输入: [-2,1,-3,4,-1,2,1,-5,4],输出: 6思路：上来就暴力，不行的。考虑用一个maxsum记录最大值，用sum，记录每次相加后的和，得到sum后，如果sum>maxsum,则maxsum = sum，否则什么都不做（什么都不做）。如果sum小于零，说明新加的这个数太小了，拖累了前面的所有值，sum清零重来。public class MaxSub..

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。思路，原始数组为有序数组，考虑用二分。普通的二分思路为，给定递增数组，给定target，循环条件为low<high，比较mid和target的值大小，如果mid>target,则high=mid-1；如果mid.

八大排序里面经常让写的两个就是快排和冒泡，面试经常会遇到，mark一下。冒泡，两个两个比较，前一个大于后一个，则把大的挪到后面，第一趟有n个元素，需要比较n-1次；第二趟n-1个元素，比较n-2次。所以，内层循环是length-i 再-1。public static void main(String[] args){ int[] arr = {1,5,3,8,4,9,5,5,6,7,2,88,54,666,47}; for(int i = 0; i < arr.length; i++..

晚上看博客的时候想起了一道考研时候的题，三次反转实现字符串翻转(记为A)，比如输入abcdefg -> efgabcd。准备复习一下，结果找到了更有意思的一道题(记为B)，输入输出为： I love you-> you love me。以上两道题思路，实现翻转有两步，1是确定翻转的begin和end位置，2是给定begin和end位置实现翻转。对于A题来说，需要额外给定一个位置k，而后做三次反转：swap(arr, 0, arr.length-1);swap(arr, 0, k);s..

二叉树的层次遍历，层次遍历就相当于一层一层的遍历，先是根节点，再是根节点的左孩子，右孩子。再试左孩子，左孩子的左孩子...可以用队列来实现，这里用的是LinkedList，因为LinkedList可以轻松实现对列和栈的操作。构造一个队列，根节点入队。循环整个队列，出队，并输出。（这里出队可以用pop，也可以用poll）判断有没有左孩子，有的话入队。判断有没有右孩子，有的话入队。package com.hisen.code;import java.util.LinkedList;

思路：遍历整个链表，维护两个节点pre和next，node.next每次都指向pre，然后这三个点同时向后移动。public static Node reverseList(Node node){ Node pre = null; Node next = null; while(node != null){ next = node.next; node.next = pre; pre = node; node =

字面意思，看起来很简单的一件事，最先想到的就是powerWithExponend里面写的情况，以为这就完了。看别人代码的时候才发现这么多问题没有考虑到，先是equal的重定义，后是exponent的取值的三种情况，在后面是base是否取零的两种情况。还是太年轻！public class Solution { public double powerWithExponend(double base,int exponent){ double res = 1.0; .

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。思路：假设有n个台阶,res种跳法，n=1 res = 1; n=2,res=2; n=3.res =3; n=4,res =5; 排列组合一个一个试过了。明显是个斐波那契数列，这里i从3开始。public class Solution { public int JumpFloor(int target) { if (target == 1 || t...

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。用hashset存一下元素，hashset不允许重复，重复则添加失败。遍历每个元素，向hashset中添加元素，如果添加失败的话，说明里面已经有一个相同的值了，就把hashset这个值删掉。最后hashset中剩下的，就是只出现一次的数。注意这里需要转成int。//num1,num2分别为长度为1的数组。传出参数//将num1[0],num2[0]设置为返回结果import java.util.S.

给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。思路：用hashmap存一下，key为数值，value也是数值。下面代码没有跑，不一定bug free。public int[] twoSum(int[] nums, int target){ Map<Integer, Integer> map = new HashMap<Integer, Integer>(); f...

有一种偷懒的方式：倒序输出数组代码如下：# include &lt;stdio.h&gt;# include &lt;stdlib.h&gt;# include &lt;string.h&gt;int main(void){ int m = 0; char *a = (char *)malloc(sizeof(char)); while(scanf("%s",a)!...

给定一个英文字符串,请写一段代码找出这个字符串中首先出现三次的那个英文字符使用两种语言C++，AC了# include &lt;iostream&gt;# include &lt;string&gt;using namespace std;int main(){ string str; int arr[256] = {0}; getline(cin,str); ...

题目：输入任意（用户，成绩）序列，可以获得成绩从高到低或从低到高的排列,相同成绩都按先录入排列在前的规则处理。示例：jack70peter96Tom70smith67从高到低成绩peter96jack70Tom70smith67从低到高smith6...

有若干张邮票，要求从中选取最少的邮票张数凑成一个给定的总值。     如，有1分，3分，3分，3分，4分五张邮票，要求凑成10分，则使用3张邮票：3分、3分、4分即可。# include &lt;stdio.h&gt;# define INF 10000 int min(int a, int b){ return (a &gt;b ) ? b : a;} int minS...

两个方法。第一个思路：使用hashset，不停往里面加结点，冲突的话，说明有环路。/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}*/import java.util.HashSet;public class Solution { public ListNode EntryNodeOfL

原题不长这样，但我想求一下全排列。输入输出示例如下：主要采用回溯法，第一次使用，见注释吧。勉强能看明白，说不出来，方法太巧了。import java.util.*;public class Test { public static void main(String[] args) { int[] nums = {1,2,3}; List<List<Integer>> myres = permute(nums);

链表去重，没什么好讲的，主要思路就是判下一个结点是否为空，不为空就判值是否和当前结点相等。本来剑指offer上写的是去除重复元素，且重复元素不保留。但本人觉得没必要，就只做了去重，重复元素保留了。注意以下代码剑指offer是不AC的。/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}*/pub