weixin_43812609的博客

重写Comparator，将子数组按照左端点进行升序排列。在res中最后一个区间的右端点小于当前区间的左端点那么没有重合，不合并。其余情况合并，并比较新的右端点的值。class Solution { public int[][] merge(int[][] intervals) { int n = intervals.length; if(n == 0){ return new int[0][2]; } .

模板/* 二叉树遍历框架 */void traverse(TreeNode root) { // 前序遍历 traverse(root.left) // 中序遍历 traverse(root.right) // 后序遍历}填充右侧结点的指针，可以使用前序遍历或者后序遍历位置中序遍历位置，添加递归代码。class Solution { public Node connect(Node root) { if(root == null

二叉树的最近公共祖先先看特殊情况：二叉搜索树二叉搜索树特性，左子树都比根节点数值大，右子树比根节点数值小。/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { pub

Java实现大顶堆和小顶堆实现数据结构采用java的优先队列，通过自定义排序方式来实现不同的堆//重写Comparator方法//通过返回y - x和x - y来返回大顶堆和小顶堆Comparator<Integer> cmp = new Comparator<Integer>(){ public int compare(Integer x,Integer y){ //返回大顶堆 return y - x; //返回小顶堆

x+y > y+x 那么x>y x大于y那么x应排在y的右边，这里要重写快速排序算法。class Solution { public String minNumber(int[] nums) { String[] strs = new String[nums.length]; for(int i = 0;i < nums.length;i++){ strs[i] = String.valueOf(nums[i]); .

class Solution { public boolean exist(char[][] board, String word) { char []tmp = word.toCharArray(); int r = board.length; int c = board[0].length; for(int i = 0;i < r;i++){ for(int j = 0;j < c;j++){.

class Solution { public int[] exchange(int[] nums) { int l = nums.length; int left = 0,right = l - 1; while(left < right){ while(left < right&&nums[left]%2!=0){ left++; } .

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { if(l1 == null){.

第一题连续最大子数组的和动态规划，注意点：如果dp[i-1]即前边i-1的最大连续子串和为负数，那么结果就为nums[i]。保存并记录max值返回结果class Solution { public int maxSubArray(int[] nums) { int l = nums.length; if(l == 0){return 0;} int []dp = new int[l]; dp[0] = nums[0];

第一题斐波那契数列，采用递归会超时。因为递归会重复的计算之前已经计算过的子问题，采用动态规划的算法，记录之前算过的数据。class Solution { public int fib(int n) { if(n == 0){return 0;} int []dp = new int[n + 1]; dp[0] = 0; dp[1] = 1; for(int i = 2;i <= n;i++){

第一题判断树的子结构先序遍历并使用递归判断树的子结构，注意在helper函数中判断的顺序，if(root2=null)这个条件要放在前面，否则出现A和B都判断到最后一个结点的时候错误的返回if(root1=null)即falseclass Solution { public boolean isSubStructure(TreeNode A, TreeNode B) { if(A == null||B == null){return false;} if(he

第一题 层次遍历二叉树使用队列实现/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public int[] levelOrder(TreeNode root)

第一题每一行从小到大排序，每一列也是从小到大排序。因此，每一行的最后一个数就是当前行最大的数字，如果该数字比target小就进入下一行，如果比target大就将列数减一（因为当前数字往下往右都是大于该数字的，往左往上都是小于该数字的）。class Solution { public boolean findNumberIn2DArray(int[][] matrix, int target) { if(matrix.length <= 0) return false;

第一题方法一 使用map，注意map在定义时需使用引用类型，不能使用基本类型要使用封装类型class Solution { public int findRepeatNumber(int[] nums) { Map<Integer,Boolean> map = new HashMap<>(); for(int i:nums){ if(map.containsKey(i)){ ret

第一题 替换空格方法一使用内置函数，拒绝重复造轮子class Solution { public String replaceSpace(String s) { return s.replace(" ","%20"); }}方法二使用StrngBuilder append操作。StringBuffer、StringBuilder和String一样，也用来代表字符串。String类是不可变类，任何对String的改变都 会引发新的String对象的生成；Str

题目一 从尾到头打印链表方法一 利用栈借助栈存储，再从栈中弹出存到数组中class Solution { public int[] reversePrint(ListNode head) { Deque<Integer> tmp = new LinkedList<>(); while(head!=null){ tmp.push(head.val); head = head.next;

第一题用两个栈实现队列，其中栈A负责入队操作，每次将元素加入到栈顶。栈B负责出队操作，将栈A中的数字反向存入，先入栈的数字存到栈顶然后出队操作。class MinStack { Stack<Integer> A,B; /** initialize your data structure here. */ public MinStack() { A = new Stack<>(); B = new Stack<>

class Solution { public boolean isPowerOfTwo(int n) { return n > 0 && (n&(n-1))==0; }}

对于括号类的问题要考虑到用栈来实现，现常用Deque来实现栈的操作而不使用Stack来定义栈。双端队列队列的实现有LinkedList和ArrayDeque两种方式，arrayDeque是数组结构，插入元素不能为nullLinkList是链表结构，常用无法确定数据量时有更好表现常用方法add()addFirst()addLast()contains()getFirst()getLast()pop()....更多详细方法见https://blog.csdn.net/qq_376.

深度优先搜索，采用递归算法，用ArrayList记录叶子结点的数值，最后判断遍历两颗树得到的序列是否完全相等。/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * .

采用二分法查找，如果所需的花的数量大于总共的花数则不能满足要求，然后最多等待的天数是最长开花时间的花束记为high，最后采用二分查找法进行搜索，查找满足条件的最少等待天数。class Solution { public int minDays(int[] bloomDay, int m, int k) { int length = bloomDay.length; if(k * m > length){return -1;} int low .

题目描述：将二维数组逆时针旋转45°，可以将整个矩阵看作一个二叉搜索树，其中右上角和左下角可分别看作根节点。左下角看作根节点：若当前值大于target则舍弃该行，若当前值小于target则舍弃该列。class Solution { public boolean findNumberIn2DArray(int[][] matrix, int target) { int rows = matrix.length - 1; if(rows < 0){

java采用HashMap+Set实现，HashMap用于记录每个数出现的次数，之后存到Set中进行判断class Solution { public boolean uniqueOccurrences(int[] arr) { Map<Integer,Integer> count = new HashMap<Integer,Integer>(); for(Integer i : arr){ if(count.con.

要划分尽可能多的区间，且相同字符只能出现在同一个区间里。采用双指针加贪心算法：1、用flag数组记录每个字符最后出现的位置2、对字符串遍历判断当前是否为结束节点，存储到列表resclass Solution { public List<Integer> partitionLabels(String S) { int []flag = new int[26]; int l = S.length(); //记录每个字符最后出现的位置 .

class Solution: def commonChars(self, A: List[str]) -> List[str]: res = [] min_lenth_char = min(A,key = len) for char in min_length_char: if all(char in item for item in A): res.append(char) A = [i.replace(char,'',1) for i in A] .

使用队列实现BFSqueue.peek()只获取队首元素不删除queue.poll()获取并删除队首元素/*// Definition for a Node.class Node { public int val; public Node left; public Node right; public Node next; public Node() {} public Node(int _val) { val = _va

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

方法一摩尔投票法用x记录当前众数，遍历数组，当前数字等于众数时vote加一，否则减一。当vote是0时更换众数。 public int majorityElement(int[] nums) { int x = nums[0]; int vote = 0; for(int k:nums){ if(vote == 0) x = k; if(k == x){ vote++.

解题思路二叉搜索树要求左小右大设G（n）是n个结点组成的二叉搜索树，G（n） = G（1）+G（2）+……G（n）设f(i)为以i为结点的树的个数f(i) = G(i-1)*G(n-i)联立得卡特兰数公式：G(n)=G(0)∗G(n−1)+G(1)∗G(n−2)+…+G(n−1)∗G(0)初始化G(0)=G(1)=1class Solution { public int numTrees(int n) { int []dp = new int[n+1]; .

解题思路盛水容积是两个边中较小的那个乘底边的长度 记高的边为S[i]，矮的边为S[j]，首先从数组最两端选择高边和矮边如果移动高的边S[i]，那么选择的矮边只可能<=S[j]，而移动后底边必然减少，因此移动后盛水容积必然小于原来的容积，所以每次移动的是矮边。具体代码如下：class Solution { public int maxArea(int[] height) { int i = 0, j = height.length - 1, res = 0; .

题目描述给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。​设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。示例:输入: [1,2,3,0,2]输出: 3解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]解题思路对于本题的股票买卖一共有三个状态，分别为持股，不持股处于冷冻期（前一天

解法一暴力，将两个数组一一比较存到一个新的一维数组中，并保持有序，之后按照奇数偶数进行返回。class Solution { public double findMedianSortedArrays(int[] nums1, int[] nums2) { int []num = new int[nums1.length+nums2.length]; int l1 = nums1.length; int l2 = nums2.length; .

思路：定义两个栈A,B，添加元素时全部加到A中，然后当需要删除元素时分三种情况，1、A不空，B空此时第一次删除，将A中元素全部加入到B中，删除。2、B不空，直接删除B栈顶元素。3、A空B空，返回-1class CQueue { stack<int> stack1,stack2;public: CQueue() { } void appendTail(int value) { stack1.push(value); } .

解法一使用java自带Arrays.sort()函数并返回class Solution { public int findKthLargest(int[] nums, int k) { Arrays.sort(nums); return nums[nums.length-k]; }}解法二使用java自带的优先队列类 PriorityQueue()利用小顶堆的思想，判断size大于k时删除堆中元素，最终堆顶就是第k大元素class Soluti.