zhanghe_zht的博客

【代码】LeetCode136. 只出现一次的数字。

【代码】LeetCode215. 第k大的数。

【代码】Java 栈和队列实现。

思路：二分查找

步骤：1、从右边开始，找第一个不是顺序增长的位置i；2、从右边开始，找到第一个大于等于nums[i]的nums[j]的位置j；3、交换nums[i]和nums[j]；4、nums[i+1]到末尾的所有数字倒序；class Solution { public void nextPermutation(int[] nums) { int l = nums.length; int i = l - 2; while (i >= 0 &&

思路：递归class Solution { public ListNode swapPairs(ListNode head) { if (head == null || head.next == null){ return head; } ListNode first = head; ListNode second = first.next; ListNode third = second.ne

class Solution { List<String> res = new ArrayList<>(); String nowStr = ""; public List<String> generateParenthesis(int n) { dfs(0, 0, n); return res; } // public void dfs(int open, int close, in

class Solution { public boolean isValid(String s) { int n = s.length(); if (n % 2 == 1) { return false; } Map<Character, Character> pairs = new HashMap<Chara`在这里插入代码片`cter, Character>() {{

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。思路：深度优先搜索public class Solution { private static Map<String, String> numToChar = new HashMap<>(); static { numToChar.put("2", "abc");

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。public class Solution { public int maxArea(int[] height) { int l = 0, r = height.length - 1; int ans = 0; w

class Solution { public String longestPalindrome(String s) { if (s.length() <= 1){return s;} int length = s.length(); int max = 0; int maxi = 0, maxj = 0; int[][] dp = new int[length][length]; for (int

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

给定一个二进制数组 nums 和一个整数 k ，如果可以翻转最多k 个 0 ，则返回 数组中连续 1 的最大个数 。class Solution { public int longestOnes(int[] nums, int k) { int left = 0; int max = 0; for (int right = 0; right < nums.length; right++) { if (nums[right

递归，回溯法public class Solution { List<List<Integer>> res = new ArrayList<>(); List<Integer> path = new ArrayList<>(); public List<List<Integer>> subsets(int[] nums) { dfs(nums, 0); return

public class Solution { public int[][] merge(int[][] intervals) { if (intervals.length == 0) { return new int[0][2]; } // 根据第一个数字排序 Arrays.sort(intervals, new Comparator<int[]>() { @Override

class Solution { public List<Integer> spiralOrder(int[][] matrix) { List<Integer> order = new ArrayList<>(); int rows = matrix.length; // 行数 int columns = matrix[0].length; // 列数 int left = 0, right = c

思路 变种二分查找：找到有序的半个数组，如果target比有序数组第一个数大，比有序数组最后一个数小，则在有序数组里找，否则在另一半无序数组里找class Solution { public int search(int[] nums, int target) { return search(nums, target, 0, nums.length-1); } public int search(int[] nums, int target, int begin

import java.util.Arrays;public class Qsort { public static void main(String[] args) { int[] array = {7,3,12,4,10}; qsort(array, 0, array.length-1); System.out.println(Arrays.toString(array)); } public static void qsor

求一个递增的整数数组中，绝对值最小的数。（数组中可以有正负整数和0，要求复杂度 O(logN)）思路：有序数组，用二分查找。如果一个数大于零，那么要找的数在他左边或者是他本身。如果一个数小于零，那么要找的数在他右边或者是他本身。递归查找。public class Solution { public static int findMinAbsValue(int[] array, int start, int end){ int len = end - start + 1;

class Solution { public int search(int[] nums, int target) { return search(nums,target,0,nums.length-1); } public int search(int[] nums,int target, int start, int end){ if (start == end || start == end - 1){ if (nu

简单思路，时间复杂度：O(n2n^2n2)class Solution { public boolean isBalanced(TreeNode node){ if (node == null){ return true; } int leftH = getHeight(node.left); int rightH = getHeight(node.right); return isBalanc

Leetcode1:两数之和思路：哈希表存储class Solution { public int[] twoSum(int[] nums, int target) { Map<Integer, Integer> map = new HashMap<Integer, Integer>(); for (int i = 0; i < nums.length; i++) { if (map.containsKey(t

Leetcode3，无重复字符的最长子串思路：滑动窗口class Solution { public int lengthOfLongestSubstring(String s) { if (s == null || s.length() ==0){ return 0; } if (s.length() == 1){ return 1; } int l = s.leng