每日leetcode - 剑指 offer

2020-11-18 18:54:01 130 收藏
分类专栏： [ 每日leetcode ]
最后发布:2020-11-18 18:54:01首次发布:2020-11-18 18:54:01
版权声明：本文为博主原创文章，遵循<a href="http://creativecommons.org/licenses/by-sa/4.0/" target="_blank" rel="noopener"> CC 4.0 BY-SA </a>版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42764468/article/details/109782211
版权

文章目录

剑指 Offer 03. 数组中重复的数字

找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

方法1：哈希表

class Solution {
    public int findRepeatNumber(int[] nums) {
        HashSet<Integer> set = new HashSet<>();
        for(int i=0;i<nums.length;i++){
            if(set.contains(nums[i])){
                return nums[i];
            }
            set.add(nums[i]);
        }
        return -1;
    }
}

方法2：ArrayList数组，超出时间限制

class Solution {
    public int findRepeatNumber(int[] nums) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0;i<nums.length;i++){
            if(list.contains(nums[i])){
                return nums[i];
            }
            list.add(nums[i]);
        }
        return -1;
    }
}

方法3：暴力法，超出时间限制

class Solution {
    public int findRepeatNumber(int[] nums) {
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]==nums[j]){
                    return nums[i];
                }
            }
        }
        return -1;
    }
}

方法4：根据题目条件，所有的数字范围都在0~n-1之间，可以让num[i]和索引i一一对应起来。

class Solution {
    public int findRepeatNumber(int[] nums) {
        int i=0;
        while (i<nums.length){
            if(nums[i]==i){
                i++;
                continue;
            }
            if(nums[i] == nums[nums[i]]) return nums[i];
            int temp = nums[i];
            nums[i] = nums[temp];
            nums[temp] = temp;
        }
        return -1;
    }
}

剑指 Offer 05. 替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

方法：遍历字符串，遇到空格就拼接%20

class Solution {
    public String replaceSpace(String s) {
        StringBuilder sb = new StringBuilder();
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)==' '){
                sb.append("%20");
            }else{
                sb.append(s.charAt(i));
            }
        }
        return sb.toString();
    }
}

剑指 Offer 06. 从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

方法1：递归

class Solution {
    ArrayList<Integer> list = new ArrayList<>();
    public int[] reversePrint(ListNode head) {
        dfs(head);
        int[] arr = new int[list.size()];
        for(int i=0;i<list.size();i++){
            arr[i] = list.get(i);
        }
        return arr;
    }

    private void dfs(ListNode root) {
        if(root==null) return;
        dfs(root.next);
        list.add(root.val);
    }
}

方法2：遍历链表并将值存放在ArrayList中

class Solution {
    ArrayList<Integer> list = new ArrayList<>();
    public int[] reversePrint(ListNode head) {
        ListNode cur = head;
        while (cur!=null){
            list.add(0,cur.val);
            cur = cur.next;
        }
        int[] arr = new int[list.size()];
        for(int i=0;i<arr.length;i++){
            arr[i] = list.get(i);
        }
        return arr;
    }
}

方法3：使用栈先进后出的特点

class Solution {
    ArrayList<Integer> list = new ArrayList<>();
    public int[] reversePrint(ListNode head) {
        Stack<Integer> stack = new Stack<>();
        ListNode cur = head;
        while (cur!=null){
            stack.push(cur.val);
            cur = cur.next;
        }
        int[] arr = new int[stack.size()];
        for(int i=0;i<arr.length;i++){
            arr[i] = stack.pop();
        }
        return arr;
    }
}

剑指 Offer 07. 重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

class Solution {
    HashMap<Integer,Integer> map = new HashMap<>();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int preleft = 0;
        int prerigt = preorder.length-1;
        int inleft = 0;
        int inright = inorder.length-1;
        for(int i=0;i<inorder.length;i++){
            map.put(inorder[i],i);
        }
        return rebuild(preleft,prerigt,inleft,inright,preorder);
    }

    private TreeNode rebuild(int preleft, int prerigt, int inleft, int inright, int[] preorder ) {
        if(preleft>prerigt || inleft>inright ) return null;
        int rootVal = preorder[preleft];
        TreeNode root = new TreeNode(rootVal);
        int index = map.get(rootVal);

        root.left = rebuild(preleft+1,preleft+index-inleft,inleft,index-1,preorder);
        root.right = rebuild(preleft+index-inleft+1,prerigt,index+1,inright,preorder);
        return root;
    }
}

剑指 Offer 09. 用两个栈实现队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

方法：两个栈实现队列，只要stackB中有数据就弹出，只有stackB中没有数据才能将A栈数据压进去

class CQueue {
    Stack<Integer> stackA;
    Stack<Integer> stackB;

    public CQueue() {
        stackA = new Stack<>();
        stackB = new Stack<>();
    }

    public void appendTail(int value) {
        stackA.push(value);
    }

    public int deleteHead() {
        if(!stackB.isEmpty()) return stackB.pop();
        if(stackA.isEmpty()) return -1;
        while (!stackA.isEmpty()){
            stackB.push(stackA.pop());
        }
        return stackB.pop();
    }
}

剑指 Offer 10- I. 斐波那契数列

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下：

F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

方法1：动态规划

class Solution {
    public int fib(int n) {
        if(n==0) return 0;
        if(n==1) return 1;
        if(n==2) return 1;
        int[] dp = new int[n+1];
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 1;
        for(int i=3;i<=n;i++){
            dp[i] = dp[i-1]+dp[i-2];
            dp[i] = dp[i] % 1000000007;
        }
        return dp[n];
    }
}

方法2：递归，超出时间限制

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

剑指 Offer 10- II. 青蛙跳台阶问题

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

class Solution {
    public int numWays(int n) {
        //如果没有这些条件，会导致给dp赋值的时候数组越界
        if(n==0) return 1;
        if(n==1) return 1;
        if(n==2) return 2;

        int[] dp = new int[n+1];
        dp[1] = 1;
        dp[2] = 2;

        for(int i=3;i<=n;i++){
            dp[i] = dp[i-1]+dp[i-2];
            dp[i] = dp[i] % 1000000007;
        }
        return dp[n];
    }
}

剑指 Offer 11. 旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。

方法：二分查找

class Solution {
    public int minArray(int[] numbers) {
        if(numbers.length==0 || numbers==null) return 0;
        int start = 0;
        int end = numbers.length-1;
        while (start+1<end){
            int mid = start + (end-start)/2;
            if(numbers[mid]<numbers[end]){
                end = mid;
            }else if(numbers[mid]>numbers[end]){
                start = mid;
            }else if(numbers[mid]==numbers[end]){
                end--;
            }
        }
        if(numbers[start]<numbers[end]) return numbers[start];
        else return numbers[end];
    }
}

剑指 Offer 15. 二进制中1的个数

请实现一个函数，输入一个整数（以二进制串形式），输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2

public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        int res = 0;
        while (n!=0){
            res += n & 1;
            n = n>>>1;
        }
        return res;
    }
}

剑指 Offer 18. 删除链表的节点

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。

方法1：

class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode cur = dummy;
        while (cur!=null && cur.next!=null){
            if(cur.next.val==val){
                cur.next = cur.next.next;
            }
            //为了删除重复节点，所以不要加else
            cur = cur.next;
        }
        return dummy.next;
    }
}

方法2：

class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode cur = dummy;
        while (true){
            if(cur.next.val==val){
                cur.next = cur.next.next;
                //为了删除重复节点，所以加break
                break;
            }
            cur = cur.next;
        }
        return dummy.next;
    }
}

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

方法1：插入排序算法

class Solution {
    public int[] exchange(int[] nums) {
        if(nums.length==0 || nums==null) return new int[0];
        for(int i=1;i<nums.length;i++){
            int insertNum = nums[i];
            if(nums[i]%2==1){
                int insertIndex = i;
                while (insertIndex>0 && nums[insertIndex-1]%2==0){
                    nums[insertIndex] = nums[insertIndex-1];
                    insertIndex--;
                }
                nums[insertIndex] = insertNum;
            }
        }
        return nums;
    }
}

方法2：双指针

class Solution {
    public int[] exchange(int[] nums) {
        if(nums.length==0) return new int[0];
        int left = 0;
        int right = nums.length-1;
        while (left<right){
            while (left<right && nums[left]%2==1) left++;
            while (left<right && nums[right]%2==0) right--;
            int tmp = nums[left];
            nums[left] = nums[right];
            nums[right] = tmp;
        }
        return nums;
    }
}

剑指 Offer 22. 链表中倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。

方法：快慢指针，先让快指针走k步，然后让快慢指针同时走

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode fast = head;
        ListNode slow = head;
        for(int i=0;i<k;i++){
           fast = fast.next;
        }
        while (fast!=null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

剑指 Offer 24. 反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null) return null;
        ListNode pre = null;
        ListNode cur = head;
        //注意是cur!=null，每个数都要cur.next=pre
        while (cur!=null){
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

剑指 Offer 25. 合并两个排序的链表

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;
        while (l1!=null && l2!=null){
            if(l1.val<l2.val){
                cur.next = l1;
                l1 = l1.next;
            }else{
                cur.next = l2;
                l2 = l2.next;
            }
            cur = cur.next;
        }
        if(l1!=null){
            cur.next = l1;
        }else if(l2!=null){
            cur.next = l2;
        }
        return dummy.next;
    }
}

剑指 Offer 26. 树的子结构

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)。B是A的子结构， 即 A中有出现和B相同的结构和节点值。

class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        if(B == null) return false;
        if(A == null) return false;
        return dfs(A,B) || isSubStructure(A.left,B) || isSubStructure(A.right,B);
    }

    private boolean dfs(TreeNode A, TreeNode B) {
        // 如果B==null说明B这颗树的节点比较完了，返回true
        if(B==null) return true;
        // 如果B!=null,但是A==null，说明两颗子树不相等，返回false
        if(A==null) return false;

        return A.val==B.val && dfs(A.left,B.left) && dfs(A.right,B.right);
    }
}

剑指 Offer 27. 二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if(root==null) return null;
        return dfs(root);
    }

    private TreeNode dfs(TreeNode root) {
        if(root==null) return null;
        
        //递归的交换左右子树的节点
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;

        dfs(root.left);
        dfs(root.right);

        return root;
    }
}

剑指 Offer 28. 对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

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

    private boolean dfs(TreeNode A, TreeNode B) {
        if(A==null && B==null) return true;
//        if(A==null && B!=null) return false;
//        if(A!=null && B==null) return false;
        if(A==null || B==null) return false;

        return A.val==B.val && dfs(A.left,B.right) && dfs(A.right,B.left);
    }
}

剑指 Offer 30. 包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

class MinStack {
    Stack<Integer> stackA ;
    Stack<Integer> stackB;

    /** initialize your data structure here. */
    public MinStack() {
        stackA = new Stack<>();
        stackB = new Stack<>();
    }

    public void push(int x) {
        stackA.push(x);
        if(stackB.isEmpty() || stackB.peek()>=x){
            stackB.push(x);
        }
    }

    public void pop() {
        //注意比较弹出的值相等时使用equals
        if(stackA.pop().equals(stackB.peek())){
            stackB.pop();
        }
    }

    public int top() {
        return stackA.peek();
    }

    public int min() {
        return stackB.peek();
    }
}

剑指 Offer 31. 栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
        Stack<Integer> stack = new Stack<>();
        int index = 0;
        for(int i=0;i<pushed.length;i++){
            stack.push(pushed[i]);
            while (!stack.isEmpty() && stack.peek()==popped[index] && index<popped.length){
                stack.pop();
                index++;
            }
        }
        return stack.isEmpty();
    }
}

剑指 Offer 32 - I. 从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

class Solution {
    ArrayList<Integer> list = new ArrayList<>();
    public int[] levelOrder(TreeNode root) {
        if(root==null) return new int[0];
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()){
            TreeNode node = queue.pop();
            list.add(node.val);
            if(node.left!=null) queue.add(node.left);
            if(node.right!=null) queue.add(node.right);
        }
        int[] arr = new int[list.size()];
        for(int i=0;i<arr.length;i++){
            arr[i] = list.get(i);
        }
        return arr;
    }
}

剑指 Offer 32 - II. 从上到下打印二叉树 II

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        if(root==null) return res;
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()){
            ArrayList<Integer> list = new ArrayList<>();
            int len = queue.size();
            for(int i=0;i<len;i++){
                TreeNode node = queue.pop();
                list.add(node.val);
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
            }
            res.add(list);
        }
        return res;
    }
}

剑指 Offer 32 - III. 从上到下打印二叉树 III

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        if(root==null) return res;
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int level = 1;
        while (!queue.isEmpty()){
            ArrayList<Integer> list = new ArrayList<>();
            int len = queue.size();
            for(int i=0;i<len;i++){
                TreeNode node = queue.pop();
                if(level%2==1){
                    list.add(node.val);
                }else{
                    list.add(0,node.val);
                }
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
            }
            level++;
            res.add(list);
        }
        return res;
    }
}
已标记关键词 清除标记
算法-leetcode-剑指offer上的题很多
06-20
非常好的算法书，讲解很详细，有C++/JAVA/Python代码，很多都是leetcode上的题解，非常高清，值得下载，如果很好，请给好评，让更多人看到节约他们找资料的时间，谢谢。
表情包
插入表情
还能输入1000个字符 “速评一下”
【Golang】LeetCode-剑指Offer-面试题64-求1+2+…+n【两种解法】
士多啤梨先生の博客
02-19 156
题目 求 1+2+…+n 要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。 示例 1： 输入: n = 3 输出: 6 示例 2： 输入: n = 9 输出: 45 限制： 1 <= n <= 10000 解法一：等差数列 math包下的Pow方法 math.Pow(x,y) 计算x的y次方，返回...
【LeetCode & 剑指offer 刷题笔记】汇总（已完成）
技术改变世界
01-11 3万+
前言   不知不觉就结束了自己的秋招之路，虽感觉有些艰辛但是收获很多。找工作那段时间做了很多学习笔记，这是数据结构与算法相关的一部分笔记，这一块除了复习相关教科书，还有就是刷leetcode和《剑指offer》了。这段时间稍微空闲些，打算把自己之前在印象笔记上做的笔记迁移到CSDN上（CSDN解析html源码的功能还没加上去，已经反馈了这个问题，我要再等等这个功能，免得要过多的二次编辑），供大家学...
LeetCode和剑指offer题目大合集
壮飞的博客
07-17 4532
AlgorithmCode 本仓库收集一些算法的答案，目标是整理一套系统的算法参考答案以供其他学习者参考,我也在慢慢的学算法并且在坚持刷题，我会不定期的上传新的题目，希望大家共同努力！ https://github.com/zfman/AlgorithmCode 在线编程网站： LeetCode 牛客网-剑指offer 目录 排序算法 LeetCode 剑指offer ...
LeetCode-剑指 Offer 57 - II. 和为s的连续正数序列
LQZme的博客
10-06 37
剑指 Offer 57 - II. 和为s的连续正数序列 题目说明 输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。 序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。 示例 输入：target = 9 输出：[[2,3,4],[4,5]] 输入：target = 15 输出：[[1,2,3,4,5],[4,5,6],[7,8]] 题解思路 滑动窗口 如果窗口和小于目标，需要添加数，右窗口右移一位，如果大于目标，需要减少数，左窗口右移一位
刷leetcode以及剑指offer的心得总结
侠客猪的博客
03-16 1168
使用Python语言刷LeetCode以及剑指offer的心得总结 1.在Python语言中字符串可以拥有列表(list)的部分功能： 比如：st=“sgrgeg” 字符串可以通过 st[i] （注意i为下标）进行输出，也可以通过for i in range(len(st)):方式进行遍历输出。但是字符串没有list列表所拥有的相关函数，比如reverse()函数等。 技巧：当整型数据需要逆转时，...
LeetCode-剑指Offer-11-旋转数组的最小数字
花花生的博客
02-17 200
题意描述： 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。 示例： 示例一： 输入：[3,4,5,1,2] 输出：1 示例二： 输入：[2,2,2,0,1] 输出：0 解题思路： Alice: 面试的时候还有这么简单...
Leetcode和剑指offer题解
三寸灰的博客
08-21 299
(keep updating…) Here are my solutions to the LeetCode problems, linking to my Github repository: EASY Leetcode 1 Two Sum Leetcode 9 Palindrome Number Leetcode 13 roman2integer Leetcode 14 lon...
LeetCode-剑指Offer-10- II. 青蛙跳台阶问题
花花生的博客
02-17 90
题意描述： 一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。 提示：0 <= n <= 100 示例： 示例一： 输入：n = 2 输出：2 示例二： 输入：n = 7 输出：21 解题思路： Alice: 好熟悉的题目，F...
LeetCode-剑指Offer-42-连续子数组的最大和
花花生的博客
02-24 82
题意描述： 输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。 要求时间复杂度为O(n)。 1 <= arr.length <= 10^5 -100 <= arr[i] <= 100 示例： 输入: nums = [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释: 连续子数组 [4,-1,2,...
Leetcode-剑指offer-01-用两个栈实现队列
wjlwangluo的博客
03-31 41
用两个栈实现队列 leetcode链接：https://leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof/ 题目如下： 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，delet...
剑指 Offer 总结 - leetcode 剑指offer系列
随便发挥的博客
08-31 184
剑指 Offer 系列完结撒花!! ???????? 本篇文章是对整个系列的精华总结, 对系列的每篇文章进行了分类, 并用一句话概括每道题的思路, 方便大家理解和记忆, 当然也包含原文完整链接供大家参考 总的来说, 写这个系列耗费了我不少精力, 不过我也很开心能和大家分享, 真心希望能对大家有所帮助, 也希望大家能够多多点赞转发和分享, 让更多人看到, 谢谢~ 接下来我需要休整一段时间来准备新的系列了, 中间也可能会有一些不定期更新. 至于新系列是什么呢? 大家敬请期待 ???? P.S.
Leetcode - 剑指offer 面试题29：数组中出现次数超过一半的数字及其变形(腾讯2015秋招 编程题4)...
weixin_34347651的博客
05-14 141
剑指offer 面试题29：数组中出现次数超过一半的数字提交网址：http://www.nowcoder.com/practice/e8a1b01a2df14cb2b228b30ee6a92163?tpId=13&tqId=11181 参与人数：3512 时间...
leetcode-剑指offer-53
lulchen的博客
04-16 48
正则解法 如果nums[0]之后出现target，肯定是形如’，target’这种，因此可以想到正则。 var search = function(nums, target) { var regnum = new RegExp('(\,'+target+')+') var strnum = nums.join() var nowres = regnum.exec(strn...
LeetCode剑指offer刷题总结---回溯法2
pnnngchg的博客
01-26 139
上一篇写了使用回溯法解决的几道题，这几天又把其他的回溯法的题做了一下。在这里总结一下。由于题目较多，就单独沾代码了，开链接直接看。 从题目要求上来说，主要分为三类： 查找，这类题一般要我们找出所有满足条件的情况，返回一个集合。结果集合作为递归函数的一个参数进行传递。如51. N-Queens，131. Palindrome Partitioning，93. Restore IP Addresse...
【Golang】LeetCode-剑指Offer-面试题54-二叉搜索树的第k大节点【解法与优化】
士多啤梨先生の博客
02-20 82
题目 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof 解题思路 二叉搜索树（Binary Search Tree），（又：二叉查找树，二叉排序树） 它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的...
LeetCode-剑指 Offer 题目集
HeavenDan的博客
12-21 21
题目集汇总 题号 题目链接 知识点 博客题解链接 完成时间 备注 题号 题目 题解链接 标签 备注 遍数 03 数组中重复的数字 【LeetCode-剑指Offer】03. 数组中重复的数字 数组、哈希表 04 二维数组中的查找 数组、双指针 05 替换空格 06 从尾到头打印链表 链表 07 重建二叉树 树、递归 09 用两个栈实现队列 栈、设计 10- I 斐波那契数列 递归 10- II 青蛙跳台阶问题 递归
LeetCode-剑指 Offer 57-和为s的两个数字
LQZme的博客
10-06 21
剑指 Offer 57. 和为s的两个数字 题目说明 输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。 示例 输入：nums = [2,7,11,15], target = 9 输出：[2,7] 或者 [7,2] 输入：nums = [10,26,30,31,47,60], target = 40 输出：[10,30] 或者 [30,10] 题解思路 双指针，如果和大于目标，后面的指针前移一位，如果小于目标，前面的指针后
Leetcode-队列-剑指 Offer 59 - I. 滑动窗口的最大值
一只菜鸟夹
08-02 46
Leetcode-队列-933. 最近的请求次数 题目题解代码其他 题目 给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。 示例: 输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3 输出: [3,3,5,5,6,7] 解释: 滑动窗口的位置 最大值 [1 3 -1] -3 5 3 6 7 3 1 [3 -1 -3] 5 3 6 7 3 1 3 [-1 -3 5] 3
©️2020 CSDN 皮肤主题: 酷酷鲨 设计师:CSDN官方博客 返回首页