面试专题leetcode100题

已于 2022-03-20 23:05:03 修改
阅读量1.6k 收藏 5
点赞数
文章标签： java
于 2022-03-12 09:33:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44484668/article/details/123432540
版权

目录

递归

70. 爬楼梯（简单）

在这里插入图片描述

递归（自顶向下）

时空复杂度：n2，1

class Solution {
    public int climbStairs(int n) {
        if (n == 1) return 1;
        if (n == 2) return 2;
        return climbStairs(n - 1) + climbStairs(n - 2);
    }
}

在这里插入图片描述

递归+哈希表

时空复杂度：n，n

class Solution {
    private HashMap<Integer, Integer> hashMap = new HashMap<>();

    public int climbStairs(int n) {
        if (n == 1) return 1;
        if (n == 2) return 2;
        if (hashMap.get(n) != null) {
            return hashMap.get(n);
        } else {
            int res = climbStairs(n - 1) + climbStairs(n - 2);
            hashMap.put(n, res);
            return res;
        }
    }    
}

在这里插入图片描述

循环解法（自底向上）

时空复杂度：n，1

class Solution {
    public int climbStairs(int n) {
        if (n == 1) return 1;
        if (n == 2) return 2;
        int pre = 2, prePre = 1;
        int res = 0;
        for (int i = 3; i <= n; i++) {
            res = pre + prePre;
            prePre = pre;
            pre = res;
        }
        return res;
    }
}

在这里插入图片描述

509. 斐波那契数（简单）

在这里插入图片描述

递归（自顶向下）

时空复杂度：n2， 1

class Solution {
    public int fib(int n) {
        if(n==0) return 0;
        if(n==1) return 1;
        return fib(n-1)+fib(n-2);
    }
}

在这里插入图片描述

递归+哈希表

时空复杂度：n，n

class Solution {
    private HashMap<Integer, Integer> hashMap = new HashMap<>();

    public int fib(int n) {
        if (n == 0) return 0;
        if (n == 1) return 1;
        if (hashMap.get(n) != null) {
            return hashMap.get(n);
        } else {
            int res = fib(n - 1) + fib(n - 2);
            hashMap.put(n, res);
            return res;
        }
    }
}

在这里插入图片描述

循环解法（自底向上）

时空复杂度：n，1

class Solution {
    public int fib(int n) {
        if (n == 0) return 0;
        if (n == 1) return 1;
        int res = 0, pre = 1, prePre = 0;
        for (int i = 2; i <= n; i++) {
            res = pre + prePre;
            prePre = pre;
            pre = res;
        }
        return res;
    }
}

在这里插入图片描述

哈希表

1. 两数之和（简单）

在这里插入图片描述

暴力

时空复杂度：n2， 1

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) return new int[]{i, j};
            }
        }
        return null;
    }
}

在这里插入图片描述

哈希表

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (hashMap.get(target - nums[i]) != null) {
                return new int[]{hashMap.get(target - nums[i]), i};
            } else {
                hashMap.put(nums[i], i);
            }
        }
        return null;
    }
}

在这里插入图片描述

数组

88. 合并两个有序数组（简单）

在这里插入图片描述

暴力

时空复杂度：nlogn（快排），1

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        for (int i = 0; i < n; i++) {
            nums1[m + i] = nums2[i];
        }
        Arrays.sort(nums1);
    }
}

在这里插入图片描述

空间换时间

时空复杂度：n，n

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        ArrayList<Integer> list = new ArrayList<>();
        int i = 0, j = 0;
        for (; i < m && j < n; ) {//比较大小，除非某一方到头了
            if (nums1[i] < nums2[j]) {
                list.add(nums1[i++]);
            } else {
                list.add(nums2[j++]);
            }
        }
        if (i != m) {//nums1到头了，把nums2直接接过来就行了，无需比较
            for (int k = i; k < m; k++) {
                list.add(nums1[k]);
            }
        }
        if (j != n) {//nums2同理
            for (int k = j; k < n; k++) {
                list.add(nums2[k]);
            }
        }
        for (int k = 0; k < nums1.length; k++) {//转移到nums1中
            nums1[k] = list.get(k);
        }
    }
}

在这里插入图片描述

逆序遍历

时空复杂度：n，1

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = m - 1, j = n - 1, index = nums1.length - 1;
        while (i >= 0 && j >= 0) {
            if (nums1[i] < nums2[j]) {
                nums1[index--] = nums2[j--];
            } else {
                nums1[index--] = nums1[i--];
            }
        }
        if (i >= 0) {
            while (index >= 0) {
                nums1[index--] = nums1[i--];
            }
        }
        if (j >= 0) {
            while (index >= 0) {
                nums1[index--] = nums2[j--];
            }
        }
    }
}

283. 移动零（简单）

在这里插入图片描述

双指针

时空复杂度：n，1

class Solution {
    public void moveZeroes(int[] nums) {
        int j = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0) {
                swap(nums, i, j);
                j++;
            }
        }
    }

    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

448. 找到所有数组中消失的数字（简单）

时空复杂度：n，1

class Solution {
    public List<Integer> findDisappearedNumbers(int[] nums) {
        ArrayList<Integer> list = new ArrayList<>();
        int n = nums.length;
        for (int i = 0; i < n; i++) {//第一次便利，标记出现过的数字
            int x = (nums[i]-1) % n;
            nums[x] += n;
        }
        for (int i = 0; i < n; i++) {//第二次便利，没有标记的下表就是结果
            if (nums[i] <= n) list.add(i+1);
        }
        return list;
    }
}

在这里插入图片描述

链表

21. 合并两个有序链表（简单）

时空复杂度：n，1
在这里插入图片描述

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if (list1 == null) return list2;
        if (list2 == null) return list1;
        ListNode dummy = new ListNode(-1), p = dummy, p1 = list1, p2 = list2;
        while (null != p1 && null != p2) {
            if (p1.val < p2.val) {
                p.next = p1;
                p = p.next;
                p1 = p1.next;
            } else {
                p.next = p2;
                p = p.next;
                p2 = p2.next;
            }
        }
        if (null != p1) {
            p.next = p1;
        }
        if (null != p2) {
            p.next = p2;
        }
        return dummy.next;
    }
}

83. 删除排序链表中的重复元素（简单）

在这里插入图片描述

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) return head;
        ListNode p = head;
        while (p.next != null) {
            if (p.val == p.next.val) {
                p.next = p.next.next;
            } else {
                p = p.next;
            }
        }
        return head;
    }
}

141. 环形链表（简单）

时空复杂度：n，1
在这里插入图片描述

public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null) return false;
        ListNode slow = head, fast = head;
        while (fast!=null&&fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) return true;
        }
        return false;
    }
}

142. 环形链表 II（中等）

时空复杂度：n，1
在这里插入图片描述

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null) return head;
        ListNode slow = head, fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) break;
        }
        if (fast == null || fast.next == null) return null;
        slow = head;
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

160. 相交链表（简单）

时空复杂度：n，1
在这里插入图片描述
方法一：暴力
方法二:哈希表
方法三：双指针
方法四：长度统一

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1 = headA, p2 = headB;
        while (p1 != p2) {
            p1 = p1 == null ? headB : p1.next;
            p2 = p2 == null ? headA : p2.next;
        }
        return p1;
    }
}

206. 反转链表（简单）

在这里插入图片描述

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode p = head;
        ListNode pre = null;
        while (p != null) {
            ListNode next = p.next;
            p.next = pre;
            pre = p;
            p = next;
        }
        return pre;
    }
}

234. 回文链表（简单）

在这里插入图片描述

class Solution {
    public boolean isPalindrome(ListNode head) {
        ArrayList<Integer> list = new ArrayList<>();
        while (head != null) {
            list.add(head.val);
            head = head.next;
        }
        for (int i = 0, j = list.size() - 1; i < j; i++, j--) {
            if (list.get(i) != list.get(j)) return false;
        }
        return true;
    }
}

876. 链表的中间结点（简单）

时空复杂度：n，1

在这里插入图片描述

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode p1 = head, p2 = head;
        while (p2 != null && p2.next != null) {
            p1 = p1.next;
            p2 = p2.next.next;
        }
        return p1;
    }
}

剑指 Offer 22. 链表中倒数第k个节点（简单）

时空复杂度：n，1
在这里插入图片描述

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode dummy = new ListNode(-1), p1 = dummy, p2 = dummy;
        dummy.next = head;
        for (int i = 0; i < k; i++) {
            p2 = p2.next;
        }
        while (p2 != null) {
            p1 = p1.next;
            p2 = p2.next;
        }
        return p1;
    }
}

栈和队列

232. 用栈实现队列（简单）

在这里插入图片描述

public class MyQueue {
    Stack<Integer> stack1;
    Stack<Integer> stack2;

    public MyQueue() {
        stack1 = new Stack<Integer>();
        stack2 = new Stack<Integer>();
    }

    public void push(int x) {
        stack1.add(x);
    }

    public int pop() {
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.add(stack1.pop());
            }
        }
        return stack2.pop();
    }

    public int peek() {
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.add(stack1.pop());
            }
        }
        return stack2.peek();
    }

    public boolean empty() {
        if (stack2.isEmpty() && stack1.isEmpty()) return true;
        return false;
    }
}

394. 字符串解码（中等）

在这里插入图片描述

树

144. 二叉树的前序遍历（简单）

class Solution {
    List<Integer> res;

    public List<Integer> preorderTraversal(TreeNode root) {
        res = new LinkedList<>();
        traverse(root);
        return res;
    }

    private void traverse(TreeNode root) {
        if (root == null) return;
        res.add(root.val);
        traverse(root.left);
        traverse(root.right);
    }
}

94. 二叉树的中序遍历（简单）

class Solution {
    List<Integer> res;

    public List<Integer> inorderTraversal(TreeNode root) {
        res = new LinkedList<>();
        traverse(root);
        return res;
    }

    private void traverse(TreeNode root) {
        if (root == null) return;
        traverse(root.left);
        res.add(root.val);
        traverse(root.right);
    }
}

145. 二叉树的后序遍历（简单）

class Solution {
    List<Integer> res;

    public List<Integer> postorderTraversal(TreeNode root) {
        res = new LinkedList<>();
        traverse(root);
        return res;
    }

    private void traverse(TreeNode root) {
        if (root == null) return;
        traverse(root.left);
        traverse(root.right);
        res.add(root.val);
    }
}

102. 二叉树的层序遍历（简单）

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> path = new LinkedList<>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) return res;
        traverse(root);
        return res;
    }

    private void traverse(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode poll = queue.poll();
                path.add(poll.val);
                if (poll.left != null) queue.add(poll.left);
                if (poll.right != null) queue.add(poll.right);
            }
            res.add(new LinkedList<>(path));
            path.clear();
        }
    }
}

101. 对称二叉树（简单）

时空复杂度：n，1
在这里插入图片描述

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) return true;
        return traverse(root.left, root.right);
    }

    private boolean traverse(TreeNode root1, TreeNode root2) {
        if (root1 == null && root2 == null) return true;
        if (root1 == null || root2 == null) return false;
        return root1.val == root2.val && traverse(root1.left, root2.right) && traverse(root1.right, root2.left);
    }
}

104. 二叉树的最大深度（简单）

时空复杂度：n，1
在这里插入图片描述

class Solution {
    public int maxDepth(TreeNode root) {
        return traverse(root);
    }

    private int traverse(TreeNode root) {
        if (root == null) return 0;
        return 1 + Math.max(traverse(root.left), traverse(root.right));
    }
}

110. 平衡二叉树（简单）

在这里插入图片描述

class Solution {
    public boolean isBalanced(TreeNode root) {
        return traverse(root) != -1;
    }

    private int traverse(TreeNode root) {
        if (root == null) return 0;
        int left = traverse(root.left);
        int right = traverse(root.right);
        if (left == -1 || right == -1 ||
                Math.abs(left - right) > 1) return -1;
        return Math.max(left, right) + 1;
    }
}

226. 翻转二叉树（简单）

在这里插入图片描述

class Solution {
    public TreeNode invertTree(TreeNode root) {
        traverse(root);
        return root;
    }

    private void traverse(TreeNode root) {
        if (root == null) return;
        traverse(root.left);
        traverse(root.right);
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

二进制

常用位运算
按位与：1&1=1 0&0=0 1&0=0
Brian Kernighan 算法:对于任意整数 x，令 x=x& (x−1)，该运算将 x 的二进制表示的最后一个 1 变成 0。
按位或： 1|1=1 0|0=0 1|0=1
按位非： ~1=0 ~0=1
按位异或：1^ 1=0 1^0=1 0 ^ 0=0, 相同为0，不同为1

1.任何数和 0 做异或运算，结果仍然是原来的数，即 a^ 0=a。
2.任何数和其自身做异或运算，结果是 0，即a^a=0。
3.异或运算满足交换律和结合律，即 a^b ^a=a ^ a ^ b=b.

有符号左移：<< （若正数，高位补0，负数，高位补1）
有符号右移：>>
无符号右移: >>>（无论正负，高位均补0）

位运算常用场景
判断奇偶数：n&(n-1),最后一位是1，是奇数，0，偶数
实现数字翻倍或减半：左乘右除

136. 只出现一次的数字（简单）

在这里插入图片描述

class Solution {
    public int singleNumber(int[] nums) {
        int res = 0;
        for (int num : nums) {
            res ^= num;
        }
        return res;
    }
}

338. 比特位计数（简单）

在这里插入图片描述

class Solution {
    public int[] countBits(int n) {
        int[] nums = new int[n+1];
        for (int i = 0; i <= n; i++) {
            nums[i] = countOne(i);
        }
        return nums;
    }

    private int countOne(int i) {
        int cnt = 0;
        while (i != 0) {
            i &= i - 1;
            cnt++;
        }
        return cnt;
    }
}

461. 汉明距离（简单）

在这里插入图片描述

class Solution {
    public int hammingDistance(int x, int y) {
        int k = x ^ y;
        int cnt = 0;
        while (k != 0) {
            k &= k - 1;
            cnt++;
        }
        return cnt;
    }
}

字符串处理

20. 有效的括号（简单）

在这里插入图片描述

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == ')') {
                if (stack.isEmpty() || stack.pop() != '(') return false;
            } else if (s.charAt(i) == ']') {
                if (stack.isEmpty() || stack.pop() != '[') return false;
            } else if (s.charAt(i) == '}') {
                if (stack.isEmpty() || stack.pop() != '{') return false;
            } else stack.push(s.charAt(i));
        }
        return stack.isEmpty();
    }
}

415. 字符串相加（简单）

在这里插入图片描述

class Solution {
    public String addStrings(String num1, String num2) {
        StringBuffer sb = new StringBuffer();
        int carry = 0;
        for (int i = num1.length() - 1, j = num2.length() - 1; i >= 0 || j >= 0; i--, j--) {
            int a = i >= 0 ? num1.charAt(i) - '0' : 0;
            int b = j >= 0 ? num2.charAt(j) - '0' : 0;
            int sum = a + b + carry;
            sb.append(sum % 10);
            carry = sum / 10;
        }
        if (carry != 0) sb.append('1');
        return sb.reverse().toString();
    }
}

动态规划

53. 最大子数组和（简单）

在这里插入图片描述

class Solution {
    public int maxSubArray(int[] nums) {
        int[] dp=new int[nums.length];//dp[i]代表以i为结尾的最大连续子数组和
        //base case
        dp[0]=nums[0];
        for(int i=1; i<nums.length; i++){
            dp[i]=Math.max(dp[i-1]+nums[i], nums[i]);
        }
        int max=Integer.MIN_VALUE;
        for(int i=0; i<dp.length; i++){
            max=Math.max(max,dp[i]);
        }
        return max;
    }
}
鼠鼠我呀2
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
100道面试题
大菠萝
03-10 67
1
Node面试题
qq593249106的博客
10-27 2019
前端面试题之Node Node的特点有三个：单线程、事件驱动、非阻塞I/O 优点： 因为Node是基于事件驱动和无阻塞的，所以非常适合处理并发请求，因此构建在Node上的代理服务器相比其他技术实现（如Ruby）的服务器表现要好得多。 与Node代理服务器交互的客户端代码是由javascript语言编写的，因此客户端和服务器端都用同一种语言编写，这是非常美妙的事情。 缺点： Node是一个相...
【分类整理】面试最常考的 100 道 LeetCode 算法题
负雪明烛
12-27 1万+
100道面试常考的力扣算法题，经过众多面试者投票选出来的，快来领取！
【Leetcode：面试经典150题】（1-10题）解析
dreaming_creator的博客
03-03 2789
该部分内容主要讲解Leetcode网站中，面试经典150题中1-10题，该部分主要包括动态数组、排序、双指针、贪心和动态规划的内容。每题包括题目描述、示例、提示、部分模拟计算、代码实现和结果展示。 笔者参加过一些算法竞赛，有些微薄见解如下：在学习算法的过程中，我们通常会进行题型分类学习，如动态规划问题，我们首先会做一些相关例题，主要学习什么题适合动态规划解决以及如何设动态规划计算法思路两个方面。但我们对于未学习的算法有时候初步学习的时候有较大难度，因此笔者认为模拟计算是一个很好的方式。
Leetcode热门100题
RuanJian_GC的博客
06-24 556
空间复杂度：O(n)。空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n)的级别。时间复杂度：O(n)，其中 n 为二叉树节点的个数。后序遍历（左右中）：即为翻转的（中右左）->压入中结点->循环：弹出，压入左节点，压入右节点。前序遍历（中左右）->压入中结点->循环：弹出，压入右节点，压入左节点。，请你找出其中不含有重复字符的 最长 子串 的长度。的链表，表示两个非负的整数。请你将两个数相加，并以相同形式返回一个表示和的链表。整数，并返回它们的数组下标。，请你在该数组中找出。
LeetCode面试热题十
保持热爱，持续学习
12-31 537
目录（序号为leetcode题号） 202. 快乐数 204. 计数质数 206. 反转链表 207. 课程表 208. 实现 Trie (前缀树) 210. 课程表 II 212. 单词搜索 II 215. 数组中的第K个最大元素 217. 存在重复元素 218. 天际线问题
LeetCode力扣 5题
制定持续可量化的目标，不断坚持。
02-09 1153
思路：数组nums1和nums2通过比较的方式填充nums1末尾。思路：先合并两个数组，然后通过冒泡排序进行排序。
Leetcode面试经典150题
qq_45249273的博客
03-14 874
经典面试题150
leetcode答案-leetcode-tencent:leetcode面试-腾讯专题做题记录
06-30
leetcode面试-腾讯专题做题记录 LeetCode腾讯专题地址， 小目标 每天至少一道算法题 每天更新README学习markdown写法(不会真的有人不会markdown吧，不会吧，不会吧) 先这样，有什么想到的再说 1月20日 正式开始，...
leetcode题库-LeetCode:LeetCode解题
06-29
LeetCode 是一个在线编程平台，专注于提供算法题目以提升编程技能，尤其对于准备技术面试大有裨益。这个“LeetCode解题”题库可能是某位开发者为了整理和记录自己在LeetCode上解决题目时的经验、思路和代码而创建的...
java-leetcode面试题解Stack之第42题接雨水-题解.zip
05-05
这道第42题，"接雨水"，是Stack专题的一部分，旨在考察开发者对数据结构和算法的理解。在这个题解中，我们将深入探讨如何使用Stack解决这个问题。 "接雨水"问题描述如下：给定一个高度不一的非空整数数组，这些数组...
leetcode题库-LeetCode:leetcode练习集合（分专题练习）
06-29
这样你才能更好的掌握某一类专题的套路，题是做不完的，但是专题可以做完！ 做题方法： 一刷十分钟做不出来直接看答案，有些题的思路第一次真的想不到 二刷开始就需要自己做出来，因为第一次你已经有印象了 再接下来...
leetcode题库-LeetCode:力码
06-29
“面试题”分栏可能是LeetCode中针对程序员面试的专题题目集合。这些题目可能来源于各大知名企业的面试经验分享，或者是由LeetCode社区根据实际面试场景整理的题目。解决这些题目可以帮助开发者了解不同公司的面试...
leetcode 最常见的 150 道前端面试题（简单题上）
前端开发博客
08-22 1万+
大家好，之前分享leetcode 最常见的150道前端面试题（简单题下）上篇来了。前言本文题目选自LeetCode 精选 TOP 面试题[1]，而这些题在自己和同事亲身经历中，确实遇到...
leetcode|面试题专题
一名路过的小码农啊
05-27 340
面试题51. 数组中的逆序对 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。 利用归并排序，将数组分成两部分，前面一部分和后面一部分，进行归并的时候，需要比较两个数组的数值大小，如果第二个数组的值小的话，代表前一个数组剩下的都比当前值大，则可以计算出逆序对的大小 private int cnt=0; public void merge(int[] nums,int ps,int pe,int ls,int le){
javascript ES5中 foreach()遍历方法
weixin_44638167的博客
09-28 5798
forcach() array.forEach(function(currentValue, index, arr)) currentValue：数组当前项的值 index：数组当前项的索引 (可选) arr：数组对象本身 filter() 方法创建一个新的数组， 新数组中的元素是通过检查指定数组中符合条件的所有元素,主要用于筛选数组 注意它直接返回一个新数组 代码: <script> var arr=[50,86,12,10,0,38]; var newa
2020最新-精选基础算法100题（面试必备）
热门推荐
ATFWUS的博客
05-18 28万+
0x01.概述 作为一个程序员，算法能力必不可少，虽然不一定是算法工程师，但是算法还是彰显着个人的编码能力，面试中也经常会被问到，甚至会被要求临场做算法题，所以，还是好好积累吧。 个人其实对算法挺有兴趣的，从3月份开始，陆陆续续刷了一些算法题，把一些有意义的记录下来了，也顺便写了一些题解，个人认为，还是挺有收获的。 之前写了一篇算法文章的目录，不过后来就忘了实时去更新了，于是现在，想把之前做过的一些有意义的算法题分享出来，刚好整理了100篇比较有意义的。希望对大家有所帮助。 0x02.说明 关
Leetcode 面试热题（一）
weixin_38428439的博客
09-12 502
以下是本人社招时在Leetcode和牛客网上的大厂的高频题，大概两三百道，大家可以根据下面推荐的题目来有选择的刷题，最好是进入Leetcode或牛客来刷，里面有需要优秀解法可以参考； 常见考点有背包、DFS、BFS、动态规划、数组、状态压缩、图优化等等。 //牛客网地址：https://www.nowcoder.com/ta/job-code-high //2021.03.28 1、反转链表 /* struct ListNode { int val; struct Li...
Leetcode Top100题目和答案（面试必备）
最新发布
Python老吕的博客
07-13 637
在面试准备过程中，LeetCode上的Top 100题目无疑是最受重视的资源之一。这些题目涵盖了算法、数据结构、动态规划、图论等多个领域，是检验编程能力和逻辑思维能力的绝佳工具。下面，我们将从LeetCode Top 100中精选几道题目，并给出相应的答案和解析。题目描述： 给定一个整数数组和一个目标值，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。答案： 解题思路： 本题使用哈希表来存储数组中的元素及其索引。遍历数组，对于每个元素，计算其与目标值的差值，并检查哈希表中是否已存在该差值。若
Java解码LeetCode经典50题面试指南
本资源是一份针对LeetCode经典50题的Java版本解题指南，旨在帮助求职者提升在IT面试中的竞争力。它涵盖了数组、字符串、数学、链表和二叉树等多个核心数据结构和算法领域。以下是部分题目及其知识点的详细解读： 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值