simmons6666的博客

原创 如何将本地项目使用git上传到GitHub

一、建立SSH加密连接由于本地Git仓库和GitHub仓库之间的传输是通过SSH加密的，所以，需要一点设置：创建SSH Key。在用户主目录下，看看有没有.ssh目录，如果有，再看看这个目录下有没有id_rsa和id_rsa.pub这两个文件，如果已经有了，可直接跳到下一步。如果没有，打开Shell（Windows下打开Git Bash），创建SSH Key：ssh-keygen -t rsa -C "youremail@example.com"你需要把邮件地址换成你自己的邮件地址，然后一路回

原创 最小的k个数

求最小的k个数，用大顶堆，实现可以采用Java自带的容器PriorityQueueimport java.util.ArrayList;import java.util.PriorityQueue;import java.util.Comparator;public class Solution { public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) { ArrayLis

原创 最长回文子串

动归解法：class Solution { public String longestPalindrome(String s) { int n=s.length(); if(n<2) return s; int start=-1; int maxLength=-1; char[] ch=s.toCharArray(); boolean[][] dp=new boolean[n]

原创 最长公共子串&子序列

1.子串import java.util.*;public class Solution { /** * longest common substring * @param str1 string字符串 the string * @param str2 string字符串 the string * @return string字符串 */ public String LCS (String str1, String str2) {

原创 设计LRU缓存结构

描述设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能set(key, value)：将记录(key, value)插入该结构get(key)：返回key对应的value值[要求]set和get方法的时间复杂度为O(1)某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。若opt=1，接下来两个整数x, y，表示set(x, y)若opt=2，接下来一个整数x，表示get

原创 求最长递增子串&子序列

1.最长递增子串public static int getMax1(int[] arr){ int len=1; int res=0; for(int j=1;j<arr.length;j++){ if(arr[j-1]<arr[j]){ len++; res=Math.max(res,len); }else{

原创 动归-打家劫舍系列

一、标准动归class Solution { public int rob(int[] nums) { //不能进连续的屋子 int n=nums.length; if(n==1){ return nums[0]; } if(n==2){ return Math.max(nums[0],nums[1]); } int[] dp=new i

原创 01背包和完全背包写法区别

一、01背包class Solution { public boolean canPartition(int[] nums) { int len=nums.length; int sum=0; for(int num:nums){ sum+=num; } if(sum%2!=0) return false; int target=sum/2; boolea

原创 算法-括号问题

1.判断括号有效一般使用栈进行判断（1）（），{}，[]使用一个栈class Solution { public boolean isValid(String s) { //java中推荐使用Deque替代Stack，Deque堆栈操作方法：push()、pop()、peek() Deque<Character> stack=new LinkedList<>(); char[] c=s.toCharArray();

转载 spring什么时候实例化bean

第一：如果你使用BeanFactory作为Spring Bean的工厂类，则所有的bean都是在第一次使用该Bean的时候实例化第二：如果你使用ApplicationContext作为Spring Bean的工厂类，则又分为以下几种情况：（1）：如果bean的scope是singleton的，并且lazy-init为false（默认是false，所以可以不用设置），则ApplicationContext启动的时候就实例化该Bean，并且将实例化的Bean放在一个map结构的缓存中，下次再使用该Bean的

转载 ubuntu18修改mysql密码（亲测好用！）

教程

原创 美团2021笔试编程真题10（二分查找+贪心+小顶堆+分治递归）

1.寻找左侧边界的二分查找某比赛已经进入了淘汰赛阶段,已知共有n名选手参与了此阶段比赛，他们的得分分别是a_1,a_2….a_n,小美作为比赛的裁判希望设定一个分数线m，使得所有分数大于m的选手晋级，其他人淘汰。但是为了保护粉丝脆弱的心脏，小美希望晋级和淘汰的人数均在**[x,y]**之间。显然这个m有可能是不存在的，也有可能存在多个m，如果不存在，请你输出-1，如果存在多个，请你输出符合条件的最低的分数线。==解题：==使用二分搜索查找满足条件的左侧边界import java.lang.refl

原创 Scanner用法

1.获取一个数int N=sc.nextInt();2.获取整行String temp = sc.nextLine();返回的是一个字符串如果该句是在第一行获得，直接这样写就行；如果是在第一行后面获得，则需要在前面加上一句sc.nextLine()，即：sc.nextLine();String temp = sc.nextLine();...

原创 创建一个表

create table actor( actor_id smallint(5) primary key not null comment '主键id', first_name varchar(45) not null comment '名字', last_name varchar(45) not null comment '姓氏', last_update date not null comment '日期');注释使用comment...

原创 用于排序的窗口函数

1、RANK()在计算排序时，若存在相同位次，会跳过之后的位次。例如，有3条排在第1位时，排序为：1，1，1，4······2、DENSE_RANK()这就是题目中所用到的函数，在计算排序时，若存在相同位次，不会跳过之后的位次。例如，有3条排在第1位时，排序为：1，1，1，2······3、ROW_NUMBER()这个函数赋予唯一的连续位次。例如，有3条排在第1位时，排序为：1，2，3，4······窗口函数用法：<窗口函数> OVER ( [PARTITION BY &lt

转载 count(*),count(列名),count(1)区别

讲解

原创 三表连接查询

select e.last_name,e.first_name,d.dept_namefrom employees as eleft join dept_emp as de on e.emp_no=de.emp_noleft join departments as d on de.dept_no=d.dept_no;

原创 动态规划

1.跳跃游戏class Solution { public boolean canJump(int[] nums) { //使用贪心算法 int n=nums.length; int farthest=0; for(int i=0;i<n-1;i++){ farthest=Math.max(farthest,nums[i]+i); //遇到0卡住，跳不了

原创 贪心&数组&排序

目录1.无重复区间2.用最少数量的箭引爆气球1.无重复区间class Solution { public int eraseOverlapIntervals(int[][] intervals) { if(intervals.length==0) return 0; //贪心算法：区间调度，找到最多不重合子区间，用集合长度减去不重合子区间个数就是答案 //1.让二维数组按照每个一维数组的end进行排序（从小到大） //2.找到最小

转载 7.贪心算法

1.贪心算法概述贪心算法可以认为是动态规划算法的一个特例，相比动态规划，使用贪心算法需要满足更多的条件（贪心选择性质），但是效率比动态规划要高。比如说一个算法问题使用暴力解法需要指数级时间，如果能使用动态规划消除重叠子问题，就可以降到多项式级别的时间，如果满足贪心选择性质，那么可以进一步降低时间复杂度，达到线性级别的。什么是贪心选择性质呢，简单说就是：每一步都做出一个局部最优的选择，最终的结果就是全局最优。注意哦，这是一种特殊性质，其实只有一小部分问题拥有这个性质。2.举例说明举例：很经典的贪心算

原创 BFS&（二叉树+字符串+数组）

目录1.二叉树的最小深度2.打开转盘锁3.滑动谜题1.二叉树的最小深度/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int va

转载 6.BFS算法

问题的本质就是让你在一幅「图」中找到从起点start到终点target的最近距离框架：// 计算从起点 start 到终点 target 的最近距离int BFS(Node start, Node target) { Queue<Node> q; // 核心数据结构 Set<Node> visited; // 避免走回头路 q.offer(start); // 将起点加入队列 visited.add(start); int step =

原创 二叉树&递归

目录1.二叉树的序列化与反序列化2.二叉搜索树中第k小的元素3.把二叉树转换为累加树1.二叉树的序列化与反序列化/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Codec {

原创 5.二叉树遍历框架

这里写目录标题1.前序遍历2.中序遍历3.后序遍历4.层序遍历1.前序遍历void traverse(TreeNode root) { if (root == null) return; // 前序遍历的代码 traverse(root.left); traverse(root.right);}2.中序遍历void traverse(TreeNode root) { if (root == null) return; traverse(root

转载 java并发编程

一、基础知识1.并发编程1.并发编程的优缺点（1）优点：充分利用多核CPU的计算能力：通过并发编程的形式可以将多核CPU的计算能力发挥到极致，性能得到提升方便进行业务拆分，提升系统并发能力和性能：在特殊的业务场景下，先天的就适合于并发编程。现在的系统动不动就要求百万级甚至千万级的并发量，而多线程并发编程正是开发高并发系统的基础，利用多线程机制可以大大提高系统整体的并发能力以及性能。面对复杂业务模型，并行程序会比串行程序更适应业务需求，而并发编程更能吻合这种业务拆分 。（2）缺点;可能会遇到

原创 递归&二叉树

写递归算法的秘诀：写递归算法的关键是要明确函数的「定义」是什么然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。怎么理解呢，我们用一个具体的例子来说，比如说让你计算一棵二叉树共有几个节点：// 定义：count(root) 返回以 root 为根的树有多少节点int count(TreeNode root) { // base case if (root == null) return 0; // 自己加上子树的节点数就是整棵树的节点数 return

转载 round

在mysql中，round函数用于数据的四舍五入，它有两种形式：1、round(x,d) ，x指要处理的数，d是指保留几位小数这里有个值得注意的地方是，d可以是负数，这时是指定小数点左边的d位整数位为0,同时小数位均为0；2、round(x) ,其实就是round(x,0),也就是默认d为0；下面是几个实例1、查询: select round(1123.26723,2); 结果：1123.272、查询: select round(1123.26723,1); 结果: 1123.33

原创 group by和having

having跟在group by后面进行过滤例子：select number from gradegroup by numberhaving count(number)>=3;

转载 replace

replace的用法：UPDATE tbl_name SET field_name = REPLACE(field_name, string_to_find, string_to_replace)WHERE conditions;

原创 Leetcode每日刷题：链表&（递归+迭代）

1.递归＋迭代：反转链表/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */class Solution { public ListNode reverseList(ListNode head) { //1.递归解法

转载 Java基础

一、java概述1.什么是JavaJava是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。2.JVM、JRE和JDK的关系JVMJava Virtual Machine是Java虚拟机，Java程序需要运行在虚拟机上，不同的平台有自己的虚拟机，因此Java语言可以实现跨平台。JREJava Runtime Environment包括Java虚拟机和Java程序所需的核心类库等。核心类库主要是j

原创 Leetcode每日刷题：回溯算法&（字符串+数组）

1.回溯：组合总和class Solution { List<List<Integer>> res=new LinkedList<>(); public List<List<Integer>> combinationSum(int[] candidates, int target) { if(candidates==null || candidates.length==0){ return

原创 inner join,left join,right join

left join(左联接) :返回包括左表中的所有记录和右表中联结字段相等的记录right join(右联接) 返回包括右表中的所有记录和左表中联结字段相等的记录inner join(等值连接) 只返回两个表中联结字段相等的行...

原创 limit 和offset

以下的两种方式均表示取2,3,4三条条数据。1.select* from test LIMIT 1,3;当limit后面跟两个参数的时候，第一个数表示要跳过的数量，后一位表示要取的数量。2.select * from test LIMIT 3 OFFSET 1;(在mysql 5以后支持这种写法)当 limit和offset组合使用的时候，limit后面只能有一个参数，表示要取的的数量,offset表示要跳过的数量 。...

原创 如何设计一个关系型数据库？

转载 java线程池

1.线程池好处：**降低资源的消耗。**线程本身是一种资源，创建和销毁线程会有CPU开销；创建的线程也会占用一定的内存。**提高任务执行的响应速度。**任务执行时，可以不必等到线程创建完之后再执行。**提高线程的可管理性。**线程不能无限制地创建，需要进行统一的分配、调优和监控。2.ThreadPoolExecutor的处理流程corePool -> 核心线程池maximumPool -> 线程池BlockQueue -> 队列RejectedExecutionHandl

原创 Leetcode每日刷题：回溯算法&（数组+字符串）

1.回溯算法：全排列class Solution { List<List<Integer>> res=new LinkedList<>(); public List<List<Integer>> permute(int[] nums) { if(nums==null ||nums.length==0){ return res; } LinkedList&lt

原创 4.回溯算法

解决一个回溯问题，实际上就是一个决策树的遍历过程。你只需要思考 3 个问题：1、**路径：**也就是已经做出的选择。2、**选择列表：**也就是你当前可以做的选择。3、**结束条件：**也就是到达决策树底层，无法再做选择的条件。回溯算法的框架：result = []def backtrack(路径, 选择列表): if 满足结束条件: result.add(路径) return for 选择 in 选择列表: 做选择

转载 Redisson 实现分布式锁原理分析

知乎

转载 volatile关键字

volatile 的主要作用有两点： （1）保证变量的内存可见性 （2）禁止指令重排序volatile 修饰符适用于以下场景：某个属性被多个线程共享，其中有一个线程修改了此属性，其他线程可以立即得到修改后的值；或者作为状态变量，如 flag = ture，实现轻量级同步。volatile 属性的读写操作都是无锁的，它不能替代 synchronized，因为它没有提供原子性和互斥性。因为无锁，不需要花费时间在获取锁和释放锁上，所以说它是低成本的。volatile 只能作用于属性，我们用 volatil