feat: 2025-10-30打卡

103.binary-tree-zigzag-level-order-traversal.java

@@ -0,0 +1,63 @@
+/*
+ * @lc app=leetcode id=103 lang=java
+ *
+ * [103] Binary Tree Zigzag Level Order Traversal
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        if(root == null) {
+            return new ArrayList<>();
+        }
+        LinkedList<TreeNode> queue = new LinkedList<>();
+        ArrayList<TreeNode> stack = new ArrayList<>();
+        queue.add(root);
+        List<List<Integer>> ret = new ArrayList<>();
+        List<Integer> curLayer = new ArrayList<>();
+        TreeNode lastLayerNode = null, curLayerNode;
+        while(!queue.isEmpty()) {
+            TreeNode tmp = queue.pollFirst();
+            curLayer.add(tmp.val);
+            if(tmp.left != null) {
+                // queue.add(tmp.left);
+                stack.addLast(tmp.left);
+            }
+            if(tmp.right != null) {
+                // queue.add(tmp.right);
+                stack.addLast(tmp.right);
+            }
+            if(tmp == lastLayerNode || lastLayerNode == null) {
+                // while()
+                // ret.add(curLayer);
+                // curLayer = new ArrayList<>();
+                // lastLayerNode = curLayerNode;
+                while(!stack.isEmpty()) {
+                    curLayerNode = stack.pollLast();
+                    queue.add(curLayerNode);
+                }
+                lastLayerNode = curLayerNode;
+                ret.add(curLayer);
+                curLayer = new ArrayList<>();
+            }
+        }
+        return ret;
+    }
+}
+// @lc code=end
+

402.remove-k-digits.java

@@ -0,0 +1,38 @@
+/*
+ * @lc app=leetcode id=402 lang=java
+ *
+ * [402] Remove K Digits
+ */
+
+// @lc code=start
+class Solution {
+    public String removeKdigits(String num, int k) {
+        ArrayDeque<Character> stack = new ArrayDeque<>();
+        for(int i = 0; i < num.length(); i++) {
+            if(k == 0) {
+                stack.addLast(num.charAt(i));
+            } else {
+                while(k>0 && !stack.isEmpty() && stack.peekLast() > num.charAt(i)) {
+                    k--;
+                    stack.removeLast();
+                }
+                stack.addLast(num.charAt(i));
+            }
+        }
+        while(!stack.isEmpty() && k > 0) {
+            k--;
+            stack.removeLast();
+        }
+        // 消除开头的0
+        while(!stack.isEmpty() && stack.getFirst()=='0') {
+            stack.removeFirst();
+        }
+        StringBuilder sb = new StringBuilder();   
+        for(Character c : stack) {
+            sb.append(c);
+        }
+        return sb.isEmpty()?"0":sb.toString();
+    }
+}
+// @lc code=end
+

71.simplify-path.java

@@ -0,0 +1,34 @@
+/*
+ * @lc app=leetcode id=71 lang=java
+ *
+ * [71] Simplify Path
+ */
+
+// @lc code=start
+class Solution {
+    public String simplifyPath(String path) {
+        String[] dirs = path.split("/");
+        ArrayList<String> stack = new ArrayList<>();
+        for(String dir: dirs) {
+            if(dir.isEmpty() || dir.equals(".")) {
+                continue;
+            } else if(dir.equals("..")) {
+                if(!stack.isEmpty()) {
+                    stack.removeLast();
+                }
+            } else {
+                stack.addLast(dir);
+            }
+        }
+        if(stack.isEmpty()) {
+            return "/";
+        }
+        StringBuilder sb = new StringBuilder();
+        for(String dir: stack) {
+            sb.append("/").append(dir);
+        }
+        return sb.toString();
+    }
+}
+// @lc code=end
+