MisAutumn
MisAutumn

leetcode BFS+DFS

BFS循环常用比较参数：queue.size()

107. Binary Tree Level Order Traversal II

https://leetcode.com/problems/binary-tree-level-order-traversal-ii/description/

//BFS time(logN+N) space(2N)
class Solution {
    public List> levelOrderBottom(TreeNode root) {
        List> result = new LinkedList<>();
        if(root==null) return result;
        Queue queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            List list = new LinkedList<>();
            int size = queue.size();
            for(int i=size; i>0; i--){
                root = queue.poll();
                list.add(root.val);
                if(root.left!=null) queue.offer(root.left);
                if(root.right!=null) queue.offer(root.right);
            }
            //头插法 不知道为什么不能用addFirst()
            result.add(0, list);
        }
        return result;
    }
}

102. Binary Tree Level Order Traversal

https://leetcode.com/problems/binary-tree-level-order-traversal/description/

class Solution {
    public List> levelOrder(TreeNode root) {
        List> whole = new LinkedList<>();
        Queue queue = new LinkedList<>();
        if(root==null) return whole;
        queue.offer(root);
        int num=1;
        while(queue.peek()!=null){
            List list = new LinkedList<>();
            int size = queue.size();
            for(int i=size; i>0; i--){
                root = queue.poll();
                list.add(root.val);
                if(root.left!=null) queue.offer(root.left);
                if(root.right!=null) queue.offer(root.right);
            }
            whole.add(list);
        }
        return whole;
    }
}

LinkedList 和 ArrayList 的区别：
LinkedList是采用链表实现的，在进行insert和remove动作时在效率上要比ArrayList要好得多!适合用来实现Stack(堆栈)与Queue(队列)。
ArrayList以数组的方式来实现，可以使用索引的方式来快速定位对象的位置，因此对于快速的随机取得对象的需求，使用ArrayList实现执行效率上会比较好。

103. Binary Tree Zigzag Level Order Traversal

class Solution {
    //BFS 与之前几题的不同之处是判断depth的奇偶性
    public List> zigzagLevelOrder(TreeNode root) {
        List> result = new LinkedList<>();
        if(root==null) return result;
        Queue queue = new LinkedList<>();
        queue.offer(root);
        int depth=0; 
        //even: from left to right 
        //odd: from right to left
        while(!queue.isEmpty()){
            List list = new LinkedList();
            int size = queue.size();
            for(int i=size; i>0; i--){
                root=queue.poll();
                if(depth%2==0) list.add(root.val);
                else list.add(0, root.val);
                if(root.left!=null) queue.offer(root.left);
                if(root.right!=null) queue.offer(root.right);
            }
            depth++;
            result.add(list);
        }
        return result;
    }
}

上面三道题大同小异，都用了BFS。下面尝试用DFS解第102题。

class Solution {
    public List> levelOrder(TreeNode root) {
        List> result = new ArrayList<>();
        level(root, result, 0);
        return result; 
    }
    public void level(TreeNode root, List> result, int height){
        if(root==null) return;
        //如果相同高度这个node不是第一个的话，不用新建list
        if(result.size()<=height) {
            List list = new LinkedList<>();
            result.add(list);
        }
        result.get(height).add(root.val);
        level(root.left, result, height+1);
        level(root.right, result, height+1);
    }
}

111. Minimum Depth of Binary Tree

DFS recursive

class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;
        int height=0;
        if(root.left==null && root.right==null) return height+1;
        else if(root.left!=null && root.right!=null) 
              return Math.min(minDepth(root.left), minDepth(root.right))+1;
        //一定注意还有以下这种情况：如果左右中只有一个是null，则返回最大深度
        else return Math.max(minDepth(root.left), minDepth(root.right))+1;
    }
}

BFS iterate：碰到没有子节点的node可以直接返回深度，不用找到最低点。

class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;
        Queue queue = new LinkedList<>();
        queue.offer(root);
        int height=0;
        while(!queue.isEmpty()){
            int size = queue.size();
            height++;
            for(int i = size; i>0; i--){
                TreeNode node = queue.poll();
                if(node.left==null && node.right==null) return height;
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
        }
        return height;
    }
}

101. Symmetric Tree

Iterative solution using one queue and many list.

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null) return true;
        Queue queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List list = new ArrayList<>();
            for(int i = size; i>0; i--){
                TreeNode node = queue.poll();
                if(node!=null) list.add(node.val);
                else list.add(-1);
                if(node!=null) {
                    queue.offer(node.left);
                    queue.offer(node.right);
                }
            }
            for(int i = 0; i

Improve the solution to use only one queue without lists.

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null) return true;
        Queue queue = new LinkedList<>();
        queue.offer(root.left);
        queue.offer(root.right);
        while(!queue.isEmpty()){
            TreeNode left = queue.poll();
            TreeNode right = queue.poll();
            if(left==null&&right==null) continue;            
            else if(left==null || right==null) return false;
            else if(left.val!=right.val) return false;
            else{
                queue.offer(left.left);
                queue.offer(right.right);
                queue.offer(left.right);
                queue.offer(right.left);
            }
        }
        return true;
    }
}

DFS recursive solution.

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null) return true;
        return helper(root.left, root.right);
    }
    public boolean helper(TreeNode left, TreeNode right){
        if(left==null&&right==null) return true;
        else if(left==null || right==null) return false;
        else return (right.val==left.val) && helper(left.left, right.right) 
                                         && helper(left.right, right.left);
    }
}

513. Find Bottom Left Tree Value

思路：

  1. 先dfs找到深度，再bfs找最深一层的第一个。
    改进：2. 直接bfs循环的时候记录每一层第一个的值，最后返回。
    改进：3. bfs从右到左循环，返回整个循环的最后一个node的值。
class Solution {
    //BFS: 找到最后一层最左边的一个 time: O(n) space: O(n)
    public int findBottomLeftValue(TreeNode root) {
        int result=root.val;
        Queue queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            root = queue.poll();
            if(root.right!=null) queue.offer(root.right);
            if(root.left!=null) queue.offer(root.left);
        }
        return root.val;
    }
}

DFS方法待补充

515. Find Largest Value in Each Tree Row

BFS solution (pass!)

//BFS
class Solution {
    public List largestValues(TreeNode root) {
        List list = new LinkedList<>();
        if(root==null) return list;
        Queue queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int max = Integer.MIN_VALUE;
            for(int i=queue.size(); i>0; i--){
                root = queue.poll();
                if(root.val>max) max=root.val;
                if(root.left!=null) queue.offer(root.left);
                if(root.right!=null) queue.offer(root.right);
            }
            list.add(max);
        }
        return list;
    }
}

DFS

class Solution {
   public List largestValues(TreeNode root) {
       List list = new ArrayList<>();
       return helper(root, 0, list);
   }
   public List helper(TreeNode root, int level, List list){
       if(root==null) return list;
       if(list.size()<=level) list.add(root.val);
       else if(root.val > list.get(level)) list.set(level, root.val);
       helper(root.left, level+1, list);
       helper(root.right, level+1, list);
       return list;
   }
}

623. Add One Row to Tree

dfs

class Solution {
    public TreeNode addOneRow(TreeNode root, int v, int d) {
        if(root==null) return null;
        if(d==1){
            TreeNode left = new TreeNode(v);
            left.left=root;
            return left;
        }
        if(d==2){
            TreeNode left = new TreeNode(v);
            left.left = root.left;
            root.left = left;
            TreeNode right = new TreeNode(v);
            right.right = root.right;
            root.right = right;
            return root;
        }
        addOneRow(root.left, v, d-1);
        addOneRow(root.right, v, d-1);
        return root;
    }
}

671. Second Minimum Node In a Binary Tree

DFS

// the tree is non empty
// every node has none or two sub-node
class Solution {
    public int findSecondMinimumValue(TreeNode root) {
        return dfs(root, root.val);
    }
    public int dfs(TreeNode root, int result){
        if(root==null) return -1; //如果没有找到，返回-1
        //如果子节点大于最小值，直接返回子节点的值，不用继续递归
        //因为其子节点的值一定大于等于现在的值
        if(root.val>result) return root.val;
        int left = dfs(root.left, result);
        int right = dfs(root.right, result);
        if(left==-1) return right;
        else if(right==-1) return left;
        //如果左右结果都不是-1， 说明都比最小值大，返回其中较小的
        else return Math.min(left, right);
    }
}

BFS

class Solution {
    public int findSecondMinimumValue(TreeNode root) {
        Queue queue = new LinkedList<>();
        int smallest = root.val;
        int result = Integer.MAX_VALUE;
        queue.offer(root);
        while(!queue.isEmpty()){
            root = queue.poll();
            //如果这个node和最小值相等，则把它的子节点加入queue
            if(root.val==smallest && root.left!=null){
                queue.offer(root.left);
                queue.offer(root.right);
            }
            //如果当前node大于最小值，不用加入其子节点。
            if(root.val>smallest && root.val

116. Populating Next Right Pointers in Each Node

dfs recursive solution

//all leaves are at the same level, and every parent has two children
public class Solution {
    public void connect(TreeLinkNode root) {
        if(root==null) return;
        if(root.left!=null) {
            root.left.next=root.right;
            if(root.next!=null) root.right.next=root.next.left;
        }
        connect(root.left);
        connect(root.right);
    }
}

bfs without extra space

public class Solution {
    public void connect(TreeLinkNode root) {
        while(root!=null){
            TreeLinkNode leftMost = root;
            while(root!=null && root.left!=null){
                root.left.next=root.right;
                if(root.next!=null) root.right.next=root.next.left;
                root=root.next;
            }
            root=leftMost.left;
        }
    }
}

117. Populating Next Right Pointers in Each Node II

iterative 太复杂了

public class Solution {
    public void connect(TreeLinkNode root) {
        TreeLinkNode leftMost = root;
        //every level
        while(root!=null){
            leftMost=root;
            //every connect in this level
            while(root!=null){
                TreeLinkNode cur = root;
                if(root.right!=null) {
                   if(root.left!=null) root.left.next=root.right;
                   cur=root.right;
                }
                else if(root.left!=null) cur=root.left;
                else{
                    root=root.next;
                    continue;
                }
                TreeLinkNode next = root.next;
                if(next!=null){
                    while(next!=null && next.left==null && next.right==null) next=next.next;
                    if(next==null) break;
                    if(next.left!=null) cur.next=next.left;
                    else if(next.right!=null) cur.next=next.right;
                }
                root=next;
            }
            while(leftMost!=null && leftMost.left==null && leftMost.right==null) leftMost=leftMost.next;
            if(leftMost==null) return;
            if(leftMost.left!=null) root=leftMost.left;
            else root=leftMost.right;
        }
    }
}

用dummy start 重新做

public class Solution {
    public void connect(TreeLinkNode root) {
        TreeLinkNode dummy = new TreeLinkNode(0);
        TreeLinkNode pre = dummy;
        //every level
        while(root!=null){
            if(root.left!=null){
                pre.next=root.left;
                pre=pre.next;
            }
            if(root.right!=null){
                pre.next=root.right;
                pre=pre.next;
            }
            root=root.next;
            //如果遍历到这个level最后一个node，pre.next是下一个level的开头
            if(root==null){
                pre=dummy;
                root=dummy.next;
                //一定要加这一句，否则死循环
                dummy.next=null;
            }
        }
    }
}

235. Lowest Common Ancestor of a Binary Search Tree

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==null) return root;
        //node的值比pq都小，说明目标节点在它右边
        if(root.val>p.val && root.val>q.val) 
              return lowestCommonAncestor(root.left, p, q);
        //node的值比pq都大，说明目标节点在它左边
        else if (root.val

236. Lowest Common Ancestor of a Binary Tree

dfs recursive

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==null || root==p || root==q) return root;
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        //如果两边都是null：说明两边为空，返回根节点
        //如果左边找到了，右边是空，返回左边；反之返回右边
        //如果两边都找到了，说明根节点左边也有右边也有，返回根节点
        return left==null ? right : (right==null ? left : root);
    }
}

617. Merge Two Binary Trees

//DFS
class Solution {
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        //当其中一个为空，此节点以下所有节点都变成另一个为根节点的子树
        if(t1==null) return t2;
        if(t2==null) return t1;
        //当两个node都不为空时，t1的值变为两个值之和
        t1.val+=t2.val;
        t1.left = mergeTrees(t1.left, t2.left);
        t1.right = mergeTrees(t1.right, t2.right);
        return t1;
    }
}

654. Maximum Binary Tree

思路：遍历，找到最大值和最大值的index，再在最大值的左边和右边分别找最大值。

//DFS  time: O(n^2) space: O(n)  （pass）
class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return recursive(nums, 0, nums.length-1);
    }
    public TreeNode recursive(int[] nums, int start, int end){
        if(start>end) return null;
        int max = nums[start];
        int index = start;
        for(int i=start; i<=end; i++){
            if(nums[i]>max) {
                max = nums[i];
                index = i;
            }
        }
        TreeNode root = new TreeNode(max);
        root.left=recursive(nums, start, index-1);
        root.right=recursive(nums, index+1, end);
        return root;
    }
}

优化：

//待补充

你可能感兴趣的:(leetcode BFS+DFS)

  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • leetcode-617. 合并二叉树 manba_ leetcodehot100leetcode算法
    题目描述给你两棵二叉树：root1和root2。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为null的节点将直接作为新二叉树的节点。返回合并后的二叉树。注意:合并过程必须从两个树的根节点开始。示例1：输入：root1=[1,3,2,
  • 代码随想录Day 41|动态规划之买卖股票问题，leetcode题目121. 买卖股票的最佳时机、122. 买卖股票的最佳时机Ⅱ、123. 买卖股票的最佳时机Ⅲ LluckyYH 动态规划leetcode算法数据结构
    提示：DDU，供自己复习使用。欢迎大家前来讨论~文章目录买卖股票的最佳时机相关题目题目一：121.买卖股票的最佳时机解题思路：题目二：122.买卖股票的最佳时机II解题思路：题目三：123.买卖股票的最佳时机III解题思路总结买卖股票的最佳时机相关题目题目一：121.买卖股票的最佳时机[[121.买卖股票的最佳时机](https://leetcode.cn/problems/combination
  • 【算法练习】IDEA集成leetcode插件实现快速刷 2401_84102892 2024年程序员学习算法intellij-idealeetcode
    ============点击右侧边leetcode->设置->配置地址、用户名、密码、存放目录、文件模板用户名要登录后在账号信息里看模板代码1.codefilename!velocityTool.camelC
  • Day_11 ROC_bird.. 算法
    面试题16.15.珠玑妙算-力扣（LeetCode）/***Note:Thereturnedarraymustbemalloced,assumecallercallsfree().*///下标和对应位置的值都一样，answer[0]+1,对应位置的值猜对了，但是下标不对，answer[1]+1int*masterMind(char*solution,char*guess,int*returnSiz
  • LeetCode 53. Maximum Subarray 枯萎的海风 算法与OJC/C++leetcode
    1.题目描述Findthecontiguoussubarraywithinanarray(containingatleastonenumber)whichhasthelargestsum.Forexample,giventhearray[−2,1,−3,4,−1,2,1,−5,4],thecontiguoussubarray[4,−1,2,1]hasthelargestsum=6.clicktos
  • leetcode中等.数组(21-40)python 九日火 pythonleetcode
    80.RemoveDuplicatesfromSortedArrayII(m-21)Givenasortedarraynums,removetheduplicatesin-placesuchthatduplicatesappearedatmosttwiceandreturnthenewlength.Donotallocateextraspaceforanotherarray,youmustdoth
  • LeetCode github集合，附CMU大神整理笔记 Wesley@ LeetCodegithub
    GithubLeetCode集合本人所有做过的题目都写在一个java项目中，同步到github中了，算是见证自己的进步。github目前同步的题目是2020-09-17日之后写的题。之前写过的题会陆续跟新到github中。目前大概400个题目Github项目链接：https://github.com/sunliancheng/leetcode_github附上一份优秀的教材整合：这是卡内基梅隆(C
  • [Swift]LeetCode943. 最短超级串 | Find the Shortest Superstring 黄小二哥 swift
    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号：山青咏芝（shanqingyongzhi）➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）➤GitHub地址：https://github.com/strengthen/LeetCode➤原文地址：https://www.cnblogs.com/streng
  • [Swift]LeetCode767. 重构字符串 | Reorganize String weixin_30591551 swiftruntime
    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号：山青咏芝（shanqingyongzhi）➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）➤GitHub地址：https://github.com/strengthen/LeetCode➤原文地址：https://www.cnblogs.com/streng
  • leetcode-124 Binary Tree Maximum Path Sum 乐观的大鹏 LeetCode
    Givenanon-emptybinarytree,findthemaximumpathsum.Forthisproblem,apathisdefinedasanysequenceofnodesfromsomestartingnodetoanynodeinthetreealongtheparent-childconnections.Thepathmustcontainatleastonenodea
  • 【LeetCode】53. Maximum Subarray 墨染百城 LeetCodeleetcode
    问题描述问题链接：https://leetcode.com/problems/maximum-subarray/#/descriptionFindthecontiguoussubarraywithinanarray(containingatleastonenumber)whichhasthelargestsum.Forexample,giventhearray[-2,1,-3,4,-1,2,1,-
  • leetcode刷题day19|二叉树Part07（235. 二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作、450.删除二叉搜索树中的节点） 小冉在学习 leetcode算法数据结构
    235.二叉搜索树的最近公共祖先思路：二叉搜索树首先考虑中序遍历。根据二叉搜索树的特性，如果p,q分别在中间节点的左右两边，该中间节点一定是最近公共祖先，如果在同一侧，则递归这一侧即可。递归三部曲：1、传入参数：根节点，p，q，返回节点。2、终止条件：因为p,q一定存在，所以不会遍历到树的最底层，因此可以不写终止条件3、递归逻辑：如果p,q均小于root的值，递归调用左子树；如果p,q均大于roo
  • LeetCode 673. Number of Longest Increasing Subsequence (Java版; Meidum) littlehaes 字符串动态规划算法leetcode数据结构
    welcometomyblogLeetCode673.NumberofLongestIncreasingSubsequence(Java版;Meidum)题目描述Givenanunsortedarrayofintegers,findthenumberoflongestincreasingsubsequence.Example1:Input:[1,3,5,4,7]Output:2Explanatio
  • Leetcode 3286. Find a Safe Walk Through a Grid Espresso Macchiato leetcode笔记leetcode3286leetcodemeidumleetcode双周赛139bfs最优路径
    Leetcode3286.FindaSafeWalkThroughaGrid1.解题思路2.代码实现题目链接：3286.FindaSafeWalkThroughaGrid1.解题思路这一题的话思路上就是一个宽度优先遍历，我们按照health进行排序进行宽度优先遍历，看看在health被消耗完之前是否可能走到终点即可。2.代码实现给出python代码实现如下：classSolution:deffin
  • leetcode 11. 盛最多水的容器 Source_Chang
    leetcode核心思想：双指针，数字小的那个指针移动classSolution{public:intmaxArea(vector&height){intleft=0;intright=height.size()-1;intmaxArea=0;while(left
  • leetcode刷题day13|二叉树Part01（递归遍历、迭代遍历、统一迭代、层序遍历） 小冉在学习 leetcode算法职场和发展
    递归遍历思路：使用递归的方式比较简单。1、递归函数的传参：因为最后输出一个数组，所以需要传入根节点和一个容器，本来想写数组，但发现长度不能确定，所以选择list。2、终止条件：当访问的节点为空时，return3、递归函数的逻辑：先访问一个节点，递归访问其他节点144.二叉树的前序遍历代码如下：classSolution{publicListpreorderTraversal(TreeNoderoo
  • leetcode021-合并两个有序链表 陆阳226
    问题描述将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。示例：输入：1->2->4,1->3->4输出：1->1->2->3->4->4解答递归法：每一层减去一个较小的节点，直到某个链表为null递归结束。publicstaticListNodesolution(ListNodel1,ListNodel2){if(l1==null){returnl2;}
  • 每日一题《leetcode--LCR 022.环形链表||》 Peace & Love487 题目分享leetcode链表算法笔记数据结构
    https://leetcode.cn/problems/c32eOV/我们使用两个指针，fast与slow。它们起始都位于链表的头部。随后slow指针每次向后移动一个位置，而fast指针向后移动两个位置。如果链表中存在环，则fast指针最终将再次与slow指针在环中相遇。structListNode*detectCycle(structListNode*head){structListNode*
  • LCR 078. 合并 K 个升序链表 装B且挨揍の LeetCode链表算法数据结构经验分享笔记java
    https://leetcode.cn/problems/vvXgSW/description/https://leetcode.cn/problems/vvXgSW/description/解题思路方法一：每个链表维护一个索引，每次找到值最小的节点，索引加一。可以采用优先队列实现。/***Definitionforsingly-linkedlist.*publicclassListNode{*i
  • LeetCode:2390. 从字符串移除*号 使用栈，时间复杂度O(N) 忍界英雄 每日一题leetcodelinux算法
    2390.从字符串移除*号today2390.从字符中移除*号题目表述给你一个包含若干星号*的字符串s。在一步操作中，你可以：选中s中的一个星号。移除星号左侧最近的那个非星号字符，并移除该星号自身。返回移除所有星号之后的字符串。注意：生成的输入保证总是可以执行题面中描述的操作。可以证明结果字符串是唯一的。示例1:输入:s=“leet**cod*e”输出:“lecoe”解释:从左到右执行移除操作：距
  • ⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表 英雄哪里出来 《LeetCode算法全集》算法数据结构链表c++归并排序
    饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述  将两个不降序链表合并为一个新的不降
  • 【LeetCode 算法笔记】84. 柱状图中最大的矩形 Sardar_ 算法leetcode笔记
    目录问题描述暴力求解：栈问题描述给定n个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为1。求在该柱状图中，能够勾勒出来的矩形的最大面积。示例1:输入：heights=[2,1,5,6,2,3]输出：10解释：最大的矩形为图中红色区域，面积为10示例2：输入：heights=[2,4]输出：4提示：1int:area=0n=len(heights)foriinrange(n):
  • 【LeetCode 算法笔记】739. 每日温度 Sardar_ 算法leetcode笔记
    目录问题描述暴力解法栈问题描述给定一个整数数组temperatures，表示每天的温度，返回一个数组answer，其中answer[i]是指对于第i天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用0来代替。示例1:输入:temperatures=[73,74,75,71,69,72,76,73]输出:[1,1,4,2,1,1,0,0]示例2:输入:temperatures=
  • 面试题24. 反转链表 阿星啊阿星
    反转链表题目描述定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点示例：输入:1->2->3->4->5->NULL输出:5->4->3->2->1->NULL提示：0<=节点个数<=5000转载来源：力扣（LeetCode）题目分析1→2→3→null初始化时h为1，now为2，h的next设置成null，有：null←1（h） 2（now）→3现在将保存一下now的next
  • 【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法leetcodeb树
    数据结构和算法实践-树-LeetCode113-路径总和Ⅱ题目MyThought代码示例JAVA-8题目给你二叉树的根节点root和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点输入：root=[5,4,8,11,null,13,4,7,2,null,null,5,1],targetSum=22输出：[[5,4,11,2],[
  • 单词搜索 II xialu
    来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/word-search-ii题目描述:给定一个mxn二维字符网格board和一个单词（字符串）列表words，找出所有同时在二维网格和字典中出现的单词。单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重
  • 对股票分析时要注意哪些主要因素？ 会飞的奇葩猪 股票 分析 云掌股吧
    　　众所周知，对散户投资者来说，股票技术分析是应战股市的核心武器，想学好股票的技术分析一定要知道哪些是重点学习的，其实非常简单，我们只要记住三个要素：成交量、价格趋势、振荡指标。     一、成交量 　　大盘的成交量状态。成交量大说明市场的获利机会较多，成交量小说明市场的获利机会较少。当沪市的成交量超过150亿时是强市市场状态，运用技术找综合买点较准；
  • 【Scala十八】视图界定与上下文界定 bit1129 scala
    Context Bound，上下文界定，是Scala为隐式参数引入的一种语法糖，使得隐式转换的编码更加简洁。   隐式参数 首先引入一个泛型函数max，用于取a和b的最大值 def max[T](a: T, b: T) = { if (a > b) a else b }  因为T是未知类型，只有运行时才会代入真正的类型，因此调用a >
  • C语言的分支——Object-C程序设计阅读有感 darkblue086 applec框架cocoa
    自从1972年贝尔实验室Dennis Ritchie开发了C语言，C语言已经有了很多版本和实现，从Borland到microsoft还是GNU、Apple都提供了不同时代的多种选择，我们知道C语言是基于Thompson开发的B语言的，Object-C是以SmallTalk-80为基础的。和C++不同的是，Object C并不是C的超集，因为有很多特性与C是不同的。 Object-C程序设计这本书
  • 去除浏览器对表单值的记忆 周凡杨 html记忆autocompleteform浏览
                                       &n
  • java的树形通讯录 g21121 java
    最近用到企业通讯录，虽然以前也开发过，但是用的是jsf，拼成的树形，及其笨重和难维护。后来就想到直接生成json格式字符串，页面上也好展现。 // 首先取出每个部门的联系人 for (int i = 0; i < depList.size(); i++) { List<Contacts> list = getContactList(depList.get(i
  • Nginx安装部署 510888780 nginxlinux
    Nginx ("engine x") 是一个高性能的 HTTP 和 反向代理 服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源
  • java servelet异步处理请求 墙头上一根草 ｊａｖａ异步返回ｓｅｒｖｌｅｔ
    servlet3.0以后支持异步处理请求，具体是使用AsyncContext ，包装httpservletRequest以及httpservletResponse具有异步的功能，        final AsyncContext ac = request.startAsync(request, response);   ac.s
  • 我的spring学习笔记8-Spring中Bean的实例化 aijuans Spring 3
    在Spring中要实例化一个Bean有几种方法： 1、最常用的（普通方法） <bean id="myBean" class="www.6e6.org.MyBean" /> 使用这样方法，按Spring就会使用Bean的默认构造方法，也就是把没有参数的构造方法来建立Bean实例。 （有构造方法的下个文细说） 2、还
  • 为Mysql创建最优的索引 annan211 mysql索引
    索引对于良好的性能非常关键，尤其是当数据规模越来越大的时候，索引的对性能的影响越发重要。 索引经常会被误解甚至忽略，而且经常被糟糕的设计。 索引优化应该是对查询性能优化最有效的手段了，索引能够轻易将查询性能提高几个数量级，最优的索引会比 较好的索引性能要好2个数量级。 1 索引的类型 (1) B-Tree 不出意外，这里提到的索引都是指 B-
  • 日期函数 百合不是茶 oraclesql日期函数查询
      ORACLE日期时间函数大全 TO_DATE格式(以时间:2007-11-02 13:45:25为例) Year: yy two digits 两位年 显示值:07 yyy three digits 三位年 显示值:007
  • 线程优先级 bijian1013 javathread多线程java多线程
    多线程运行时需要定义线程运行的先后顺序。 线程优先级是用数字表示，数字越大线程优先级越高，取值在1到10，默认优先级为5。 实例： package com.bijian.study; /** * 因为在代码段当中把线程B的优先级设置高于线程A,所以运行结果先执行线程B的run()方法后再执行线程A的run()方法 * 但在实际中，JAVA的优先级不准，强烈不建议用此方法来控制执
  • 适配器模式和代理模式的区别 bijian1013 java设计模式
    一.简介        适配器模式：适配器模式（英语：adapter pattern）有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类别自己的接口包裹在一个已存在的类中。      &nbs
  • 【持久化框架MyBatis3三】MyBatis3 SQL映射配置文件 bit1129 Mybatis3
     SQL映射配置文件一方面类似于Hibernate的映射配置文件，通过定义实体与关系表的列之间的对应关系。另一方面使用<select>,<insert>,<delete>，<update>元素定义增删改查的SQL语句， 这些元素包含三方面内容 1. 要执行的SQL语句 2. SQL语句的入参，比如查询条件 3. SQL语句的返回结果
  • oracle大数据表复制备份个人经验 bitcarter oracle大表备份大表数据复制
    前提：    数据库仓库A（就拿oracle11g为例）中有两个用户user1和user2,现在有user1中有表ldm_table1,且表ldm_table1有数据5千万以上，ldm_table1中的数据是从其他库B（数据源）中抽取过来的，前期业务理解不够或者需求有变，数据有变动需要重新从B中抽取数据到A库表ldm_table1中。    
  • HTTP加速器varnish安装小记 ronin47 http varnish 加速
    上午共享的那个varnish安装手册，个人看了下，有点不知所云，好吧~看来还是先安装玩玩！ 苦逼公司服务器没法连外网，不能用什么wget或yum命令直接下载安装，每每看到别人博客贴出的在线安装代码时，总有一股羡慕嫉妒“恨”冒了出来。。。好吧，既然没法上外网，那只能麻烦点通过下载源码来编译安装了！ Varnish 3.0.4下载地址： http://repo.varnish-cache.org/
  • java-73-输入一个字符串，输出该字符串中对称的子字符串的最大长度 bylijinnan java
    public class LongestSymmtricalLength { /* * Q75题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。 * 比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。 */ public static void main(String[] args) { Str
  • 学习编程的一点感想 Cb123456 编程感想Gis
           写点感想，总结一些，也顺便激励一些自己.现在就是复习阶段，也做做项目.      本专业是GIS专业，当初觉得本专业太水，靠这个会活不下去的，所以就报了培训班。学习的时候，进入状态很慢，而且当初进去的时候，已经上到Java高级阶段了，所以.....，呵呵，之后有点感觉了，不过，还是不好好写代码，还眼高手低的，有
  • [能源与安全]美国与中国 comsci 能源
         现在有一个局面：地球上的石油只剩下N桶，这些油只够让中国和美国这两个国家中的一个顺利过渡到宇宙时代，但是如果这两个国家为争夺这些石油而发生战争，其结果是两个国家都无法平稳过渡到宇宙时代。。。。而且在战争中，剩下的石油也会被快速消耗在战争中，结果是两败俱伤。。。       在这个大
  • SEMI-JOIN执行计划突然变成HASH JOIN了 的原因分析 cwqcwqmax9 oracle
    甲说： A B两个表总数据量都很大，在百万以上。 idx1  idx2字段表示是索引字段 A B 两表上都有 col1字段表示普通字段 select xxx from A where A.idx1 between mmm and nnn      and exists (select 1 from B where B.idx2 =
  • SpringMVC-ajax返回值乱码解决方案 dashuaifu AjaxspringMVCresponse中文乱码
      SpringMVC-ajax返回值乱码解决方案   一：（自己总结，测试过可行） ajax返回如果含有中文汉字，则使用：（如下例：） @RequestMapping(value="/xxx.do")       public @ResponseBody void getPunishReasonB
  • Linux系统中查看日志的常用命令 dcj3sjt126com OS
    因为在日常的工作中，出问题的时候查看日志是每个管理员的习惯，作为初学者，为了以后的需要，我今天将下面这些查看命令共享给各位 cat tail -f 日 志 文 件 说 明 /var/log/message 系统启动后的信息和错误日志，是Red Hat Linux中最常用的日志之一 /var/log/secure 与安全相关的日志信息 /var/log/maillog 与邮件相关的日志信
  • [应用结构]应用 dcj3sjt126com PHPyii2
    应用主体 应用主体是管理 Yii 应用系统整体结构和生命周期的对象。 每个Yii应用系统只能包含一个应用主体，应用主体在 入口脚本中创建并能通过表达式 \Yii::$app 全局范围内访问。 补充: 当我们说"一个应用"，它可能是一个应用主体对象，也可能是一个应用系统，是根据上下文来决定[译：中文为避免歧义，Application翻译为应
  • assertThat用法 eksliang JUnitassertThat
    junit4.0  assertThat用法 一般匹配符1、assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) ); 注释： allOf匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&） 2、assertThat( testedNumber, anyOf( g
  • android点滴2 gundumw100 应用服务器android网络应用OSHTC
    如何让Drawable绕着中心旋转？ Animation a = new RotateAnimation(0.0f, 360.0f, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,0.5f); a.setRepeatCount(-1); a.setDuration(1000); 如何控制Andro
  • 超简洁的CSS下拉菜单 ini htmlWeb工作html5css
    效果体验：http://hovertree.com/texiao/css/3.htmHTML文件： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>简洁的HTML+CSS下拉菜单-HoverTree</title>
  • kafka consumer防止数据丢失 kane_xie kafkaoffset commit
    kafka最初是被LinkedIn设计用来处理log的分布式消息系统，因此它的着眼点不在数据的安全性（log偶尔丢几条无所谓），换句话说kafka并不能完全保证数据不丢失。   尽管kafka官网声称能够保证at-least-once，但如果consumer进程数小于partition_num，这个结论不一定成立。   考虑这样一个case，partiton_num=2
  • @Repository、@Service、@Controller 和 @Component mhtbbx DAOspringbeanprototype
    @Repository、@Service、@Controller 和 @Component 将类标识为Bean Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类
  • java 多线程高并发读写控制 误区 qifeifei java thread
    先看一下下面的错误代码，对写加了synchronized控制，保证了写的安全，但是问题在哪里呢？ public class testTh7 { private String data; public String read(){ System.out.println(Thread.currentThread().getName() + "read data "
  • mongodb replica set(副本集)设置步骤 tcrct javamongodb
    网上已经有一大堆的设置步骤的了，根据我遇到的问题，整理一下，如下： 首先先去下载一个mongodb最新版，目前最新版应该是2.6 cd /usr/local/bin wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.0.tgz tar -zxvf mongodb-linux-x86_64-2.6.0.t
  • rust学习笔记 wudixiaotie 学习笔记
    1.rust里绑定变量是let，默认绑定了的变量是不可更改的，所以如果想让变量可变就要加上mut。 let x = 1; let mut y = 2; 2.match 相当于erlang中的case，但是case的每一项后都是分号，但是rust的match却是逗号。 3.match 的每一项最后都要加逗号，但是最后一项不加也不会报错，所有结尾加逗号的用法都是类似。 4.每个语句结尾都要加分
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他