Carmelo_Z的博客

public class Solution { // you need treat n as an unsigned value //所以方法中参数类型如果是int，最大能接受是0+31个1，也就是2147483647，假如输入2147483648，转化时就会溢出，变成32个1(补码)，-2 //解决办法是对传入的n进行修改，不修改方法定义本身的参数int与返回值int，而是在方法内部放一个

public class Solution { //解法一：利用一个辅助数组可以要求，但不是很好，题目要求空间复杂度是O(1)的 public void rotate(int[] nums, int k) { //题目要求：Rotate an array of n elements to the right by k steps. //先处理k的值，鲁棒性

public class Solution { // you need treat n as an unsigned value //所以方法中参数类型如果是int，最大能接受是0+31个1，也就是2147483647，假如输入2147483648，转化时就会溢出，变成32个1(补码)，-2 //解决办法是对传入的n进行修改，不修改方法定义本身的参数int与返回值int，而是在方法内部放一个

/*The idea is: 1.The ZERO comes from 10. 2.The 10 comes from 2 x 5 3.And we need to account for all the products of 5 and 2. likes 4×5 = 20 ... 4.So, if we take all the numbers with 5

public class Solution { public int titleToNumber(String s) { //即把二十六进制数转化为10进制数 int res = 0; for(int i = 0; i < s.length(); i++){ res = res * 26 + s.charAt(i) - 'A' +

public class Solution { public int majorityElement(int[] nums) { //解法一：利用Map来统计数组中的元素的出现次数 int res = 0; Map map = new HashMap<>(); for(int i = 0; i < nums.length; i++)

public class Solution { public String convertToTitle(int n) { //即把一个十进制数转化为二十六进制数，思路同把十进制数转化为二进制数 StringBuilder res = new StringBuilder(); char temp; while(n != 0){

public class Solution { public int[] twoSum(int[] numbers, int target) { //还是采用之前TwoSum的解法，可以有O(N*N)，或者O(N)+Map //但这里提到了给定的数组是按升序排列的，那么是否可以利用这个来找到更好的解法？ int[] res = new int[2];

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */public

public class MinStack { /** initialize your data structure here. */ private TreeMap min; private LinkedList stack; public MinStack() { min = new TreeMap<>(); stack = new LinkedLi

class ListNode { int val; ListNode next; ListNode(int x) { val = x; next = null; }}class Solution { public boolean hasCycle(ListNode head) {//这个算法是在判断一个list中是否出现循环的数段，与val有关 //而原题是

解法一：使用了额外空间，用map来存public class Solution { public int singleNumber(int[] nums) { Map map = new HashMap<>(); for(int val : nums){ if(map.containsKey(val)){ map.put(va

public class Solution { public boolean isPalindrome(String s) { boolean res = true; Stack stack = new Stack<>(); Queue queue = new LinkedList<>(); s = s.toLowerCase();

class Solution { public int maxProfit(int[] prices) { int res = 0; int low = 0, high = 0; if(prices.length == 0) return 0; high = prices[prices.length - 1];

class Solution { public int maxProfit(int[] prices) { //暴力求解，从后往前找每一个数对应前面的数的差，O（N*N），遇到很长的数据会超时 int res = 0; for(int i = prices.length - 1; i >= 0; i--){ for(int j =

public class Solution { public List getRow(int rowIndex) { List res = new ArrayList<>(); for(int i = 0; i <= rowIndex; i++){ res.add(1); for(int j = 0; j + 1 < i;

public class Solution { public List> generate(int numRows) { List> res = new ArrayList<>(); List level = null; List lastLevel = null; if(numRows == 0) return res;

public class Solution { /* 可以看到下面的解法，正确的解法逻辑是很清晰的，最先想解这题的时候想到每四个房子分为一组， 分别为1+3,2+4,1+4的组合，然后去更新，但是逻辑很不清晰 下面的正确解法中用prevNo，prevYes来模拟了偷盗当前房子可能的情况 */ public int rob(int[] nums) {

public class Solution { public int divedeAndProduct(int n){ int res = 0; while(n != 0){ int temp = n % 10; res += temp * temp; n = n / 10; } //System.out.println(res); return res;

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ /* 本题要求求出给定有序数列的高度平衡二

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

public class Solution { public void merge(int[] nums1, int m, int[] nums2, int n) { //虽然题目要求返回排序的结果是nums1，但是可以新开一个数组，到时候赋值给nums1就行 //要不然直接在nums1上移动修改太麻烦，而且浪费时间 int[] res = new int[n

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */public class Solution { public ListNode dele

public int climbStairs(int n) { /*if(n == 1) return 1; if(n == 2) return 2; return climbStairs(n - 1) + climbStairs(n - 2);*/ //用递归会超时，而且效率低 ArrayList list = ne

二分搜索法求平方根：public class Solution { public int mySqrt(int x) { //既然是寻找一个数的平方根，就属于查找的方式，查找中有二分查找法 //二分查找法求平方根，记住算法，无限逼近 if (x == 0) return 0; int left = 1, right = x, ans

public class Solution { public int reverse(long a) {//题目中提到如果超过32-bit的返回0，想到的解决办法是用long来存，判断结果是否大于Integer.MAX_VALUE或小于Integer.MIN_VALUE long temp = 0; int res = 0; if(a < 0){ a = Ma

public class Solution { public static int Reverse(long a){ long temp = 0; int res = 0; if(a < 0){ a = Math.abs(a); while(a != 0){ temp = temp * 10 + (a % 10); a = a / 10; }

public class Solution { public int romanToInt(String s){ int res = 0; int i = 0; Map map = new HashMap(); map.put('I', 1); map.put('V', 5); map.put('X', 10); map.put('L', 50); map.put

public class Solution { public String longestCommonPrefix(String[] strs){ String res = ""; boolean flag = true; for(int i = 0; flag; i++){ if(strs.length == 0){ flag = false;//处理空串的情况

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */public class Solution { public ListNode addT

public class Solution { public boolean isValid(String s) { boolean res = true; Stack stack = new Stack(); Character ch, chPop; for(int i = 0; i < s.length(); i++){

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */public class Solution { public ListNode merg

import java.util.Arrays;import java.util.Vector;public class Solution { public int removeDuplicates(int[] nums) {//注意题中提到给的数组是排好序的，所以可以一步步往后判断 int res = nums.length; int swap =

/* *算法思路，题目中提到返回除val外的数组元素个数，那么从头遍历数组，设res的初值为数组的长度，遇到val就res--; *同时题目中要求数组的前res个元素不能含有val，而且元素的顺序可以改变 *那么就将遍历时遇到的val放到数组的最后，设一个j,依次从数组的最后往前挪 *放到数组的最后采用交换nums[i]与nums[j]，而且交换后还要判断nums[i]是否是val，所以