面试专题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
    评论
LeetCode常用算法模式&大厂面试题整理
qq_45770532的博客
06-28 1851
文章参考自 educative 参考文献链接 1、滑动窗口     1 一个左指针，一个右指针。其中左指针用于缩小范围，右指针用于扩大搜索范围。一般求滑动窗口的最小值都是在缩小左指针的时候取得的。     2 右指针扩展的条件时：只要当前还没有满足条件，就暴力增长，直到第一次满足条件为止。     3 左指针收缩的条件：只要当前指针的缩小还没影响窗口的可满足性，就一直暴力向左增长。一但当前指针向前移动的时候影响了窗口的可满足性，就记录下当前的窗口大小，并更新目前为止满足条件的最小窗口记录。之后，再次扩展右指
程序员必做50题的解答(完结撒花)分解质因数输出9*9口诀国际象供棋盘兔子判断101-200之间有多少个素数水仙花数条件运算符求其最大公约数和最小公倍数字符的个数打印出杨辉三角形有n个人围成一圈，顺序
include_io的博客
07-23 3330
有n个人围成一圈，顺序排号。从第一个人开始报数(从1到3报数),凡报到3的人退出圈子，问最后留下的是原来第几号的那位。一个偶数总能表示为两个素数之和。判断一个素数能被几个9整除.打印出所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。例如:153是一个“水仙花数”, 因为153=1 的三次方+5的三次方+3的三次方判断101-200之间有多少个素数，并输出所有素数。输入两个正整数m和n,求其最大公约数和最小公倍数一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1
【分类整理】面试最常考的 100 道 LeetCode 算法题
负雪明烛
12-27 1万+
100道面试常考的力扣算法题，经过众多面试者投票选出来的，快来领取！
LeetCode刷题总结 - 面试经典 150 题 -持续更新
qq_45464560的博客
07-29 6654
LeetCode刷题总结 - 面试经典 150 题 - 持续更新其他系列数组 / 字符串88. 合并两个有序数组27. 移除元素26. 删除有序数组中的重复项80. 删除有序数组中的重复项 II169. 多数元素189. 轮转数组121. 买卖股票的最佳时机122. 买卖股票的最佳时机 II55. 跳跃游戏274. H 指数380. O(1) 时间插入、删除和获取随机元素238. 除自身以外数组的乘积739. 每日温度42. 接雨水双指针125. 验证回文串392. 判断子序列167. 两数之和 II -
【LeetCode 随笔】面试经典 150 题【中等＋困难】持续更新中。。。
最新发布
shiranyyds的博客
05-23 1280
n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。每个孩子至少分配到 1 个糖果。相邻两个孩子评分更高的孩子会获得更多的糖果。请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。规则定义： 设学生 A 和学生 B左右相邻，A 在 B 左边； 左规则： 当 B>A时，B的糖比A的糖数量多。右规则： 当 A>B时，A 的糖比B的糖数量多。相邻的学生中，评分高的学生必须获得更多的糖果 等价于 所有学生满足左规则且满足右规则。
LeetCode精选算法100题,从入门到入赘
IT邦德
05-21 1万+
算法是程序员的内功，掌握算法不仅能帮助你在面试中过关斩将，赢取 Dream Offer，更能充分锻炼你的逻辑思维与底层能力
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上经典面试问题Java语言实现
12-21
这是个人搜集的LeetCode上一些经典面试问题的Java语言实现，涉及数组、链表、堆栈、队列、二叉树、并查集、字典树等15个维度，供各位学习参考使用！
微软等数据结构 算法面试100题全部答案集锦
01-23
微软等 数据结构 算法面试100题 全部答案集锦
java面试100题及面试技巧总结
08-15
java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的
LeetCode 最常见100道题
保持一颗敬畏之心，简单地调用C++，适当地向C++妥协，让以后的自己看懂代码，让别人看懂代码。
05-03 1085
目录前言正文一、反转链表1. [题目](https://leetcode-cn.com/problems/reverse-linked-list/)2. 解答 前言 正文 一、反转链表 1. 题目 2. 解答 a. 迭代法: 答案 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nul
Leetcode热题Hot100+Top面试题-数组
weixin_42127177的博客
10-20 4308
题目： 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。 示例 1： 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。 示例 2： 输入：nums = [3,2,4], target
leetcode 15 3-sum【双指针】
MissZhou要努力
08-01 296
Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero. Note: The solution set must not cont...
LeetCode面试常见100题（ TOP 100 Liked Questions）
热门推荐
lanyu_01的博客
07-16 3万+
这篇文章是关于LeetCode Top 100 Liked Questions 的 专栏记录，其中部分题目可能包括解题思路和多种优化解法。 目录： 1、Two Sum 2、Add Two Numbers 3、Longest Substring Without Repeating Characters 1、Two Sum Given an array of intege...
Vue 前端面试题 leetcode
08-24
当面试 Vue 前端开发岗位时，可能会遇到以下类型的问题： 1. Vue 相关问题： - 请解释 Vue.js 是什么，以及它与其他前端框架的区别。 - Vue 的生命周期钩子函数有哪些？请按顺序列出。 - Vue 中的 computed 属性和 methods 方法有什么区别？ - 请解释 v-bind 和 v-model 指令的作用。 2. 组件问题： - 请解释 Vue 组件的概念，并提供一个简单的示例。 - 如何在父组件和子组件之间传递数据？ - 请解释 Vue 中的 props 和 $emit 的作用，并提供一个示例。 3. 路由问题： - Vue Router 是什么，以及它的作用是什么？ - 请解释 Vue Router 中的路由守卫，并举例说明各个守卫的用途。 4. 状态管理问题： - 请解释 Vuex 是什么，以及它的作用是什么？ - Vuex 中的 state、mutations、getters 和 actions 分别是什么，有什么作用？ 对于 LeetCode 相关问题，可以参考一些对算法和数据结构有要求的题目，例如： - 实现一个链表的反转。 - 判断一个字符串是否为回文串。 - 实现二叉树的遍历（前序、中序、后序）。 - 实现快速排序算法。 以上问题仅作为参考，实际面试中可能会有更多不同类型的问题。在准备面试时，建议熟悉 Vue 的基本概念和用法，并且掌握一些常见的算法和数据结构。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值