qq_53226437的博客

文章目录面试题 01.02. 判定是否互为字符重排题目思路代码实现面试题 01.02. 判定是否互为字符重排题目给定两个字符串 s1 和 s2，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。示例 1：输入: s1 = “abc”, s2 = “bca”输出: true示例 2：输入: s1 = “abc”, s2 = “bad”输出: false说明：0 <= len(s1) <= 1000 <= len(s2) <= 100

面试题 02.01. 移除重复节点题目编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。示例1:输入：[1, 2, 3, 3, 2, 1]输出：[1, 2, 3]示例2:输入：[1, 1, 1, 1, 2]输出：[1, 2]提示：链表长度在[0, 20000]范围内。链表元素在[0, 20000]范围内。思路暴力解法从前面每个节点开始，与后面的每个节点进行比较，从而进行重复元素的移除，如下：但是显然时间复杂度为O(n2n^2n2)利用数组存储已访问节点，

分发糖果题目n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。你需要按照以下要求，给这些孩子分发糖果：每个孩子至少分配到 1 个糖果。相邻两个孩子评分更高的孩子会获得更多的糖果。请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。动态规划我采用的是动态规划的方法，设dp[i]表示前i+1个分数时的最优策略有如下三种情况：如果第i个分数大于第i-1个分数，自然：dp[i] = dp[i-1] + 1如果第i个分数小于第i-1个分数，并且dp[i-1

两整数之和思路知识储备a&b产生进位、a^b产生当前位结果进位仍然需要与当前位结果求和才能得到最终结果进位为0时，最终结果才会产生过程在上面的介绍中，不难发现其实就是一个迭代的过程初始时，进位设为a，结果设为b循环判断进位是否为0，不为0，则计算进位和当前位为0，结束循环，此时res中存储了最终结果Java代码实现public class 两整数之和 { public int getSum(int a, int b) { int carry

排序数组自己实现思路手写快排Javaclass Solution { int[] array; public int[] sortArray(int[] nums) { this.array = nums; quickSort(0,nums.length-1); return nums; } void quickSort(int l,int r){ if (l<r){ i

删除有序数组中的重复项方法一：自己写的答案思路：把数组的长度赋值给len进入循环，不是最后一个值则判断是否重复，重复则将后续的值依次往前挪，将重复值覆盖，len–nums[j]–的原因时，j-1当前已经时最后一个值的索引了，但是后续数值并没有删除，当nums[j-1]==nums[j]的时候将会陷入死循环，所以需要修改后续的值，至于为什么是自减1，是因为给数组是递增的，自减1才不会与前面的值重复同时考虑可能有多个重复值，使用while循环返回lenclass Solution {

寻找峰值要求：思路：由于时间负责度需要是O(log⁡n\log_nlogn​),所以选择了分治法进行查找由于给出的函数形式不满足递归的需求，创建新函数递归函数，判断递归截止条件：l>r对中间索引的值进行条件判断，符合峰值条件，返回索引否则，递归调用左边区间，并将返回值存储在target中，使用三目运算符决定返回值，如果左边区间返回值为-1，那么右边返回值决定了是否有峰值：为-1，则左右均为-1，无峰值；否则，峰值出现在右边区间，返回即可。如果左边区间不为-1，那么直接返回该峰值对

二分查找>注意：nums数组需要是递增数组思路：设置上下界：l、r计算中间索引mid，并将对应索引的数据与查找目标target对比相等：返回mid索引target大：需要查找的数据应该在区间[mid+1,r]target小：需要查找的数据应该在区间[l,mid-1]当l>r时，依旧没有找到，说明该数值并不在该数组中class Solution { public int search(int[] nums, int target) { int

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { TreeNode max = p.val>q.val?p:q; TreeNode min = p.val<q.val?p:q; while (root!=null){ if (root.val>=min.val&&root.val<=max.v

public int kthSmallest(TreeNode root, int k) { int i = 1; Stack<TreeNode> stack = new Stack<>(); TreeNode node = root; while (!stack.isEmpty()||node!=null){ while (node!=null){ stack.p

迭代思路private TreeNode node;private Stack<TreeNode> stack;public BSTIterator(TreeNode root) { this.node =root; stack = new Stack<>();}public int next() { while (node !=null){ stack.push(node); node = node.left;

public TreeNode sortedArrayToBST(int[] nums) { return sortedArrayToBST(nums,0,nums.length);}private TreeNode sortedArrayToBST(int[] nums,int low,int high){ if (low>=high) return null; int middle = (low+high)>>1; TreeNode root =

public void recoverTree(TreeNode root) { Stack<TreeNode> stack = new Stack<>(); TreeNode node = root; TreeNode prev = null; TreeNode node1=null,node2=null; while (!stack.isEmpty()||node!=null){ while (node!=null){

递归版本public boolean isValidBST(TreeNode root) { return range(root,Integer.MIN_VALUE-1L,Integer.MAX_VALUE+1L);}public boolean range(TreeNode node,long min,long max){ if (node==null) return true; if (node.val<=min||node.val>=max) return

通过java语言对BSTree的实现public class BSTree<E> { private int size = 0; private Comparator comparator; private Node<E> root; public BSTree(){ this(null); } public BSTree(Comparator comparator){ this.comparato

private int[] preprivate int[] post;public TreeNode constructFromPrePost(int[] preorder, int[] postorder) { pre = preorder; post = postorder; return buildTree(0,0,pre.length);}private TreeNode buildTree(int i,int j,int n){ if (n==0) r

private Map<Integer,Integer> indexMap;private int postindex;public TreeNode buildTree(int[] inorder, int[] postorder) { indexMap = new HashMap<>(); int len = postorder.length; postindex = len - 1; for (int i=0;i<len;i++) i

private Map<Integer,Integer> indexMap;public TreeNode buildTree(int[] preorder, int[] inorder) { indexMap = new HashMap<>(); int len = preorder.length; for (int i=0;i<len;i++) indexMap.put(inorder[i],i); return buildTree(p

递归版本public boolean isSymmetric(TreeNode root) { if(root==null) return true; TreeNode left = root.left; TreeNode right = root.right; if (left==null&&right==null) return true; else if (left==null||right==null) return false;

先前序遍历，后展开public void flatten(TreeNode root) { if (root==null) return; Stack<TreeNode> stack = new Stack<>(); List<TreeNode> list = new ArrayList<>(); TreeNode node = root; while (!stack.isEmpty()||node!=null){

递归形式public int maxDepth(Node root) { if (root==null) return 0; int depth = 0; for (Node node:root.children) { int temp =maxDepth(node); if (depth<temp) depth = temp; } return 1+depth;}类同二叉树，但是没有二叉树一行代码来得简洁，需要遍历所有子

递归形式public List<Integer> preorder(Node root) { return preorder(root,new ArrayList<>());}private List<Integer> preorder(Node nodes,List<Integer> list){ if (nodes==null) return list; list.add(nodes.val); for(Node n

递归形式public List<Integer> postorder(Node root) { return postorder(root,new ArrayList<>());}private List<Integer> postorder(Node nodes,List<Integer> list){ if (nodes==null) return list; for(Node node:nodes.children) po

递归形式public List<Integer> preorder(Node root) { return preorder(root,new ArrayList<>());}private List<Integer> preorder(Node nodes,List<Integer> list){ if (nodes==null) return list; list.add(nodes.val); for(Node n

public List<List<Integer>> levelOrderBottom(TreeNode root) { List<List<Integer>> lists = new ArrayList<>(); if (root==null) return lists; Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root

递归实现public int maxDepth(TreeNode root) { if (root==null) return 0; return 1 + Math.max(maxDepth(root.left),maxDepth(root.right));}思路：就是取左右节点深度最大值+1（根节点）设置递归终止条件队列迭代实现public int maxDepth(TreeNode root) { if (root==null) return 0; Q

public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> list = new ArrayList<List<Integer>>(); if (root==null) return list; Queue<TreeNode> queue = new LinkedList<>(); queue

递归实现public List<Integer> postorderTraversal(TreeNode root) { return traversal(root,new ArrayList<>());}public List<Integer> traversal(TreeNode node,List<Integer> list) { if (node==null) return list; traversal(node.le

递归实现public List<Integer> inorderTraversal(TreeNode root) { return traversal(root,new ArrayList<>());}public List<Integer> traversal(TreeNode node,List<Integer> list){ if (node == null) return list; traversal(node.left

递归形式public List<Integer> preorderTraversal(TreeNode root) { return traversal(root,new ArrayList<Integer>()); }public List<Integer> traversal(TreeNode node,List<Integer> list){ if (node==null) return list; list.add(

前序、中序、后序、层次遍历皆可实现，我就实现一下前序和层次就好前序遍历实现public TreeNode invertTree(TreeNode root) { if (root==null) return root; TreeNode temp = root.left; root.left = root.right; root.right = temp; invertTree(root.left); inv

这道题跟我上一篇文章的思路其实是差不多的，就是反过来而已但是时间复杂度的话，无疑用栈实现队列要简单得多，基本可以说是O(1)而用队列实现栈，时间复杂度则达到了O(n)思路：每次push时，就把outDeque中符合规则的元素全部push进inDeque，然后交换inDeque和outDeque的指向不知道小伙伴们有没有注意到，其实这不就是递归的思想么？只着眼于当前事件，并相信完成当前事情的前提已经准备好了private Queue<Integer> inDeque = new L

正如题目所说的，利用栈来实现队列但是栈是后进先出，队列是先进先出，怎么才能用栈实现队列呢？答案是：用两个栈来实现一个队列先定义一个inStack和一个outStack进队的元素都push进inStack里出队时，判断outStack是否为空，如果空，则将inStack中元素全部pop出来，再依次push进outStack说到这里，其实就是负负得正，需要出队元素的优先级，outStack栈顶–>outStack栈底–>inStack栈底–>inStack栈顶队列为空时，inS

这道题折磨了自己很久，但是正向的思路其实也很简单，就是用一个栈来保存括号之前的符号然后当遇到+时符号不变，遇到-时，符号反转可以注意到：一开始就push了一个1进去，这是把整个字符串用一个括号括起来，自然这个大括号前面的符号是+，所以为1至于else里面的while循环，其实就是字符串可以给出多位整数，无疑，我们要用while循环把这个多位整数还原出来进行运算public int calculate(String s){ int res=0; Stack<Int

public int evalRPN(String[] tokens) { Stack<Integer> stack = new Stack<>(); int result; for (String token : tokens) { if (token.length() > 1) { stack.push(Integer.parseInt(token));

public int scoreOfParentheses(String s) { int score = 0; int count = 0; int len = s.length(); for (int i=0;i<len;i++){ char c = s.charAt(i); if(c=='(') count++; else {

很久之前做的答案public boolean isValid(String s) { char[] c = new char[10000]; int j=0; for(int i=0;i<s.length();i++){ switch(c[j]){ case '(': if(s.charAt(i)==')') j--;

public ListNode middleNode(ListNode head) { int count=0; ListNode temp = head; while (temp!=null){ count++; temp = temp.next; } for (int i=0;i<count/2;i++) head = head.next; return

递归解决方案public ListNode deleteDuplicates(ListNode head) { if (head==null) return null; ListNode newhead = deleteDuplicates(head.next); if (newhead==null) return head; if(head.val== newhead.val) head = newhead; else he

递归解决方案public ListNode removeElements(ListNode head, int val) { if (head==null) return null; ListNode newhead = removeElements(head.next,val); if(head.val!=val) head.next = newhead; else head = newhead; return head;