start

归并排序的概要 1.核心思想 归并排序属于排序方式的一种，相比于冒泡排序其速度要快很多，稍次于快速排序。该方法的重要思想为分治法，首先将整个数据从中间一分为二，然后左右俩边再重复上述操作，直至分为每个子段只有一个数，这时候我们可以认为这个子段是有序的了，然后俩俩相比较合并达到排序效果，其排序类型为稳定排序。 2.代码 # include <stdio.h> # include <stdlib.h> void Merge ( int Arr1 [ ] , int Arr2 [ ] , int start , int mid , int end ) //start是数组头元素,mid是中间值，因为要从中间一分为二，end就是结尾啦 { int i = start , j = mid + 1 , k = start ; while ( i != mid + 1 && j != end + 1 ) { if ( Arr1 [ i ] > Arr1 [ j ] ) Arr2 [ k ++ ] = Arr1 [ j ++ ] ; else Arr2 [ k ++ ] = Arr1 [ i ++ ] ; } //如果最后俩个数组合并后有一个没用完，那没用完的数一定有序，依次加在后面即可 while ( i != mid + 1 ) Arr2 [ k ++ ] = Arr1 [ i ++ ] ;

题目描述： 这里有一个非负整数数组 arr，你最开始位于该数组的起始下标 start 处。当你位于下标 i 处时，你可以跳到 i + arr[i] 或者 i - arr[i]。 请你判断自己是否能够跳到对应元素值为 0 的 任意 下标处。 注意，不管是什么情况下，你都无法跳到数组之外。 示例 1： 输入：arr = [4,2,3,0,3,1,2], start = 5 输出：true 解释： 到达值为 0 的下标 3 有以下可能方案： 下标 5 -> 下标 4 -> 下标 1 -> 下标 3 下标 5 -> 下标 6 -> 下标 4 -> 下标 1 -> 下标 3 示例 2： 输入：arr = [4,2,3,0,3,1,2], start = 0 输出：true 解释： 到达值为 0 的下标 3 有以下可能方案： 下标 0 -> 下标 4 -> 下标 1 -> 下标 3 示例 3： 输入：arr = [3,0,2,1,2], start = 2 输出：false 解释：无法到达值为 0 的下标 1 处。 提示： 1 <= arr.length <= 5 * 10^4 0 <= arr[i] < arr.length 0 <= start < arr.length 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/jump

1.引入相关依赖： 2.common: public class SnowFlakeIDGenerator { private static SnowFlake snowFlake = null; private static long workid = 5; private static long datacenterId = 31; static{ snowFlake = new SnowFlake(workid,datacenterId); } public static void main(String[] args) { System.out.println("snoflake:"+generateSnowFlakeId()); } /** * 雪花算法ID生成，全局唯一 * @return * long id */ public final static long generateSnowFlakeId(){ return snowFlake.nextId(); } static class SnowFlake{ // 时间起始标记点，作为基准，一般取系统的最近时间（一旦确定不能变动） private final static long twepoch = 1288834974657L; // 机器标识位数 private final static long

String str = "Hello,World! in Java." ; Pattern pattern = Pattern . compile ( "W(or)(ld!)" ) ; Matcher matcher = pattern . matcher ( str ) ; while ( matcher . find ( ) ) { System . out . println ( "Group 0:" + matcher . group ( 0 ) ) ; //得到第0组——整个匹配 System . out . println ( "Group 1:" + matcher . group ( 1 ) ) ; //得到第一组匹配——与(or)匹配的 System . out . println ( "Group 2:" + matcher . group ( 2 ) ) ; //得到第二组匹配——与(ld!)匹配的，组也就是子表达式 System . out . println ( "Start 0:" + matcher . start ( 0 ) + " End 0:" + matcher . end ( 0 ) ) ; //总匹配的索引 System . out . println ( "Start 1:" + matcher . start ( 1 ) + "

后台用习惯了框架分页，到做网页的时候就不自己去写分页了，并且需要的分页也是比较简单的，然后就在网上找了个简单的分页插件：kkpager 需要导入的js 和cs: 　　　　 kkpager.js 　　　　kkpager.min.js 　　　　kkpager.css 效果图如下： 　　 以下为实例： ----------BaseDao.java //分页查询 public List<T> listByPage(String hql,int start,int maxNum,Object ...params){ Query q = getSession().createQuery(hql); q.setFirstResult(start); q.setMaxResults(maxNum); for(int i = 0;i < params.length;i++){ q.setParameter(i, params[i]); } return q.list(); } ------------serviceImpl public Map<String, Object> getAll(int start, int limit,StuInfo entity) { Map<String, Object> map = HQLUtils.getHqlByEntity(entity); List

今天在网上找了一下，发觉有比较多的方法，现在列出来，需要的朋友可以参考一下。 功能最丰富的就是第一种方法了： 1 vector< string > Split( const string & s, const string & match, bool removeEmpty= false , bool fullMatch= false ) 2 // 参数s为需要肢解的字符串 3 // 参数match为肢解匹配字符串 4 // 参数removeEmpty为是否删除空字符 5 // 参数fullMatch为是否只保留全匹配的字符串 6 7 下面为代码区： 8 #include < string > 9 #include 10 11 namespace Daniweb 12 { 13 using namespace std; 14 15 typedef string ::size_type ( string ::*find_t)( const string & delim, 16 string ::size_type offset) const ; 17 18 /// 19 /// Splits the string s on the given delimiter(s) and 20 /// returns a list of tokens without the delimiter

递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解，避免重复计算。 斐波那契数列 Leetcode-70. 爬楼梯 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ 注意：给定 n 是一个正整数。 示例 1： 输入： 2 输出： 2 解释： 有两种方法可以爬到楼顶。 1. 1 阶 + 1 阶 2. 2 阶 示例 2： 输入： 3 输出： 3 解释： 有三种方法可以爬到楼顶。 1. 1 阶 + 1 阶 + 1 阶 2. 1 阶 + 2 阶 3. 2 阶 + 1 阶 解法： Java 定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp[i] 表示走到第 i 个楼梯的方法数目。 第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达，走到第 i 个楼梯的方法数为走到第 i-1 和第 i-2 个楼梯的方法数之和。 考虑到 dp[i] 只与 dp[i - 1] 和 dp[i - 2] 有关，因此可以只用两个变量来存储 dp[i - 1] 和 dp[i - 2]，使得原来的 O(N) 空间复杂度优化为 O(1) 复杂度。 class Solution { public int climbStairs ( int n ) { if ( n

方法 描述 str.capitalize() 返回副本，首字母大写，其余小写 str.upper() 全部大写 str.isupper() 是否都是大写 str.lower() 小写 str.islower() 是否都是小写 str.swapcase() 转换大小写 str.title() 首字母大写，其余小写 str.istitle() str.center(width[, fillchar]) 返回长度为width的字符串，并使得自身居中。 str.zfill(width) 填充0 str.ljust(width[, fillchar]) str.rjust(width[, fillchar]) str.lstrip([chars]) str.rstrip([chars]) str.strip([chars]) 去除空白符 str.find(sub[, start[, end]]) 返回sub字符串的索引 str.index(sub[, start[, end]]) 未找到则报错 str.rfind(sub[, start[, end]]) 从左边找 str.rindex(sub[, start[, end]]) str.expandtabs(tabsize=8) 返回副本，空格替换制表符 str.replace(old, new[, count]) 替换字符

在处理多线程同步问题的时候，我们一般有临界区，互斥量，信号量和消息机制等几种解决方案，在c#中可以非常方便的使用它们来实现进程的同步。下面我就常用的lock,Monitor和Mutex几种来说明如何实现进程的同步。 lock和Monitor依靠一种“令牌”对象来实现进程的同步，下面看一段示范代码： class Example { int count = 0; object o = new object();//令牌对象 static void Main(string[] args) { Example e=new Example(); Thread pthread = new Thread(e.produce); Thread cthread = new Thread(e.consume); pthread.Start(); cthread.Start(); } public void produce() { while (true) { lock (o) { count = count + 1; } } } public void consume() { while (true) { lock (o) { count = count - 1; } } } } 在程序中，我们需要产生两个生产和消费的线程，但是两个线程对count的访问必须是互斥的，也就是要实现两个现场的同步

在部署cas-overlay-template时，将打的war放置tomcat的webapp下面，发生如下异常 java . lang . IllegalStateException : ContainerBase . addChild : start : org . apache . catalina . LifecycleException : Failed to start component [ StandardEngine [ Catalina ] . StandardHost [ localhost ] . StandardContext [ / cas ] ] 原因：是因为我的JDK环境是12的太高了，后来降到了JDK8就OK了 来源： CSDN 作者： 小花荣 链接： https://blog.csdn.net/Leo_songHJ/article/details/103995904