leetcode 记录

最新推荐文章于 2024-03-18 22:58:15 发布

保护眼睛

最新推荐文章于 2024-03-18 22:58:15 发布

阅读量63

点赞数 2

分类专栏： Java 文章标签： leetcode queue 队列算法

本文链接：https://blog.csdn.net/qq_45859087/article/details/117665703

版权

Java 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

这篇博客涵盖了多种算法问题的解决方案，包括LeetCode上的删除链表倒数第n个节点、IP地址无效化，以及糖果分配问题。还讨论了如何解决手套匹配问题，并探讨了N叉树的深度计算，展示了递归与非递归两种方法。这些内容涉及数据结构、算法和问题解决策略。

摘要由CSDN通过智能技术生成

leetcode 记录

19.删除链表的倒数第n个节点

只遍历一遍链表

class Solution19 {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode slow = head;
        ListNode fast = head;
        for (int i = 0; i < n; i++) {
            fast = fast.next;
        }
        if (fast == null) {
            return head.next;
        }
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }

        slow.next = slow.next.next;

        return head;
    }
}

1108.IP地址无效化

class Solution1108 {

    public static String defangIPaddr1(String address) {
        return address.replace(".", "[.]");
    }

    public String defangIPaddr2(String address) {
        StringBuilder res = new StringBuilder();
        int len = address.length();
        for (int i = 0; i < len; i++) {
            char ch = address.charAt(i);
            if (ch == '.') {
                res.append("[.]");
            } else {
                res.append(ch);
            }
        }
        return res.toString();
    }

}

575.分糖果

class Solution575 {
    class Solution {
        public int distributeCandies(int[] candyType) {
            HashSet<Integer> set = new HashSet<>();
            for (int i : candyType) {
                set.add(i);
            }
            return Math.min(set.size(), candyType.length / 2);
        }
    }
}

1103.分糖果II

class Solution1103 {
    public static void main(String[] args) {
        System.out.println(Arrays.toString(distributeCandies(7, 4)));
    }

    public static int[] distributeCandies(int candies, int num_people) {
        int[] res = new int[num_people];
        int getCandies = 1;

        while (candies > 0) {
            for (int i = 0; i < num_people; i++) {
                if (candies - getCandies > 0) {
                    candies -= getCandies;
                    res[i] += (getCandies++);
                } else {
                    res[i] += candies;
                    return res;
                }
            }
        }
        return res;
    }
}

手套问题

class SolutionSolves {
    public int findMinimum(int n, int[] left, int[] right) {
        int sum_left = 0;
        int sum_right = 0;
        int left_min = Integer.MAX_VALUE;
        int right_min = Integer.MAX_VALUE;
        int zero_color = 0;

        for (int i = 0; i < n; i++) {
            
            if (left[i] * right[i] == 0) {

                zero_color += left[i];
                zero_color += right[i];

            } else {
                left_min = Math.min(left_min, left[i]);
                right_min = Math.min(right_min, right[i]);

                sum_left += left[i];
                sum_right += right[i];

            }
        }

        return (sum_left < sum_right ? sum_left - left_min + zero_color + 2
                : sum_right - right_min + zero_color + 2);
    }
}

559.求N叉树的深度

class Solution559 {
    //递归实现
    public int maxDepth(Node root) {
        if (root == null) return 0;

        int res = 1;
        for (Node child : root.children) {
            res = Math.max(res, maxDepth(child) + 1);
        }
        return res;
    }

    //非递归实现
    public int maxDepth1(Node root) {
        if (root == null) return 0;
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 0;
        while (!queue.isEmpty()) {
            depth++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                Node cur = queue.poll();
                for (Node child : cur.children) {
                    queue.offer(child);
                }
            }
        }
        return depth;
    }
}