**Algorithm**
每周至少做一个leetcode算法题

**Review**
阅读并点评至少一篇英文技术文章
（英文论文文献）

**Tip**
至少学习一个技术技巧

**Share**
分享一篇有观点和思考的技术文章

Algorithm

数据结构与算法之美之变形二分查找
大前提：都是有序数组，可能存在重复元素

1. 查找第一个等于某个数值的元素
2. 查找最后一个等于某个数值的元素
3. 查找第一个大于等于某个数值的元素
4. 查找最后一个小于等于某个数值的元素
5. 给定一个循环有序数组，如[4,5,6,1,2,3]，查找等于某个数值的元素，假设没有重复元素
6. 上一题如果有重复元素呢？查找第一个等于某个数值的元素

前四道题类似，思路也很简单，找到符合条件的元素后看是否是第一个，是则直接返回，不是则继续二分
代码如下：

//1. 查找第一个等于某个数值的元素
public static int findFirstValueEqualsTarget(int[] arr, int target) {
        if (arr == null || arr.length == 0) {
            return -1;
        }

        int begin = 0, end = arr.length-1;
        int mid = begin + (end - begin) / 2;
        while (begin <= end) {
            if (arr[mid] == target) {
                if (mid == 0 || arr[mid - 1] < target) {
                    return mid;
                } else {
                    //继续二分
                    end = mid - 1;
                }
            } else if (arr[mid] < target) {
                begin = mid + 1;
            } else{
                end = mid - 1;
            }

            mid = begin + (end - begin) / 2;
        }
        return -1;
    }

//2. 查找最后一个等于某个数值的元素
public static int findLastValueEqualsTarget(int[] arr, int target) {
        if (arr == null || arr.length == 0) {
            return -1;
        }

        int begin = 0, end = arr.length-1;
        int mid = begin + (end - begin) / 2;
        while (begin <= end) {
            if (arr[mid] == target) {
                if (mid == arr.length - 1 || arr[mid + 1] > target) {
                    return mid;
                } else {
                    //继续二分
                    begin = mid + 1;
                }
            } else if (arr[mid] < target) {
                begin = mid + 1;
            } else{
                end = mid - 1;
            }

            mid = begin + (end - begin) / 2;
        }
        return -1;
    }

//3. 查找第一个大于等于某个数值的元素
public static int findFirstValueLargeOrEqualsTarget(int[] arr, int target) {
        if (arr == null || arr.length == 0) {
            return -1;
        }

        int begin = 0, end = arr.length-1;
        int mid = begin + (end - begin) / 2;
        while (begin <= end) {
            if (arr[mid] >= target) {
                if (mid == 0 || arr[mid - 1] < target) {
                    return mid;
                } else {
                    //继续二分
                    end = mid - 1;
                }
            } else{
                begin = mid + 1;
            }

            mid = begin + (end - begin) / 2;
        }
        return -1;
    }

//4. 查找最后一个小于等于某个数值的元素
public static int findLastValueLessOrEqualsTarget(int[] arr, int target) {
        if (arr == null || arr.length == 0) {
            return -1;
        }

        int begin = 0, end = arr.length-1;
        int mid = begin + (end - begin) / 2;
        while (begin <= end) {
            if (arr[mid] <= target) {
                if (mid == arr.length - 1 || arr[mid + 1] > target) {
                    return mid;
                } else {
                    //继续二分
                    begin = mid + 1;
                }
            } else{
                end = mid - 1;
            }

            mid = begin + (end - begin) / 2;
        }
        return -1;
    }

第五题依然可以采用二分法，只不过数组会被一分为2，一部分是有序的，一部分仍然是循环数组，针对有序部分进行二分查找，不断循环即可找到，查看leetcode其他人写的代码，简洁很多，但是很难理解，还是自己按照思路暴力破解写了一遍。

//5.
class Solution {
    //先确定[begin,mid]/[mid,end]的排序性，再利用arr[mid]与target比较
    public int search(int[] arr, int target) {
        if(arr == null || arr.length == 0){
            return -1;
        }
        
        int begin = 0, end = arr.length-1;
        int mid = begin + (end-begin)/2;
        while(begin <= end){
            
            //左半部分有序
            if(arr[begin] < arr[mid] ||  begin == mid){
                if(arr[mid] < target){
                    begin = mid + 1;
                } else if(arr[mid] == target){
                    return mid;
                } else {
                    if(arr[begin] > target){
                        begin = mid + 1;
                    } else{
                        end = mid-1;
                    }
                }
            } else {
                //左半部分是循环数组,则右半部分一定是有序的，那么考虑右半部分
                if(arr[mid] < target){
                    if(arr[end] < target){
                        end = mid -1;
                    } else {
                        begin = mid+1;
                    }
                } else if(arr[mid] == target){
                    return mid;
                } else {
                    end = mid - 1;
                }
            }
            
            mid = begin + (end-begin)/2;
        }
        
        return -1;
    }

第六题参照之前的思路就可以写出来了，当找到符合条件的时候，判断前一个数是否等于，不等于则找到，等于则继续二分即可，这里就不再贴代码了

Review

继续微服务系统的文章：
Microservices vs. SOA
主要概述了微服务与SOA的区别

Microservices vs. SOA.png

Tip

hibernate分组校验实践
参考：https://www.cnblogs.com/mr-yang-localhost/p/7812038.html

• hibernate校验：通过注解的方式更加简洁的校验字段是否合法
• hibernate分组校验：在注解字段要满足的条件时，指定校验分组；则校验的时候校验组列表只有包含了某个字段的指定校验分组时，才会去校验该字段，否则略过。
  什么场景下会用到分组校验：最简单的，数据库插入操作要求某些字段为非空，更新操作时这些字段并不要求为非空，这个时候可以通过指定不同的校验组来区分校验

例子链接如下：https://www.jianshu.com/p/cf64e2726a81

Share

今天被人问起，为什么这么爱跑步？刚开始跑步就是单纯的想要工作之余放松一下，渐渐的从中找到了乐趣，通过跑步也爱上了健身，所以对于身材渐渐有了要求，于是也加强了健身的频次，整个人状态感觉好了不少，这可能就是所谓的良性循环吧。
之所以能坚持下来，主要是跑步可以随时随地跑，很方便，不想球类运动和游泳对场地有要求，相对就没这么好坚持下去。所以工作学习也是一样，开始阶段尽量选择易操作易实现的，慢慢养成习惯，然后慢慢的增加难度，这样或许坚持就没这么难了。