HiSEN

发表于 | 分类于

名词解释

  1. 脏读: 对于两个事物 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段. 之后, 若 T2 回滚, T1读取的内容就是临时且无效的.
  2. 不可重复读: 对于两个事物 T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段. 之后, T1再次读取同一个字段, 值就不同了.
  3. 幻读: 对于两个事物 T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行. 之后, 如果 T1 再次读取同一个表, 就会多出几行.

数据库的4个事物隔离级别

√：可能会出现
×：为不会出现

name名称级别脏读不可重复读幻读
Read uncommitted读未提交1√√√
Read committed读提交2×√√
Repeatable read重复读3××√
Serializable序列化4×××

oracle

Oracle 支持的 2 种事务隔离级别：READ COMMITED, SERIALIZABLE.

Oracle 默认的事务隔离级别为: READ COMMITED

mysql

Mysql 支持 4 中事务隔离级别.

Mysql 默认的事务隔离级别为: REPEATABLE READ

延伸

参考：https://www.cnblogs.com/andy6/p/6045679.html

HiSEN

发表于 | 分类于

定义

最多有两棵子树的有序树，称为二叉树。二叉树是一种特殊的树。

性质

这里规定二叉树的根结点的层次为1。

  1. 性质1：则二叉树的第i 层最多有2i-1个结点（在此二叉树的层次从1开始，i≥1）
  2. 性质2：深度为k的二叉树最多有2k-1个结点。(k≥1)
  3. 性质3：对任何一棵二叉树T, 如果其叶结点个数为n0, 度为2的非叶结点个数为n2, 则有
    n0 = n2 + 1
  4. 性质4：具有 n(n>0)个结点的完全二叉树的深度为⎣log2n⎦+1；⎦x⎦表示不超过x的最大整数。
  5. 性质5：如果对一棵有n个结点的完全二叉树的结点按层序编号（从第1层到第⎣l og2n⎦ +1层，每层从左到右）,则对任一结点i（1≤i≤n),有：
    5.1 (1)如果i=1，则结点i无双亲，是二叉树的根；如果i>1，则其双亲是结点⎣i/2⎦。
    5.2 (2) 如果2i<=n, 则结点i的左孩子结点是2i；否则，结点i为叶子结点，无左孩子结点。
    5.3 (3)如果2i＋1<=n，则结点i的右孩子是结点2i＋1; 否则，结点i为叶子结点，无右孩子结点。

完整代码

https://github.com/hisenyuan/btree

二叉链表的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
package com.hisen.interview.tiger20171110.btree;

/**
 * @author : yhx
 * @date : 2017/11/10 18:42
 * @descriptor : 二叉树的 - 二叉链表实现
 */
public class LinkBTree implements BTree {

  private Object data;
  private BTree lChild;
  private BTree rChild;

  public LinkBTree() {
    this.clearTree();
  }

  public LinkBTree(Object data) {
    this.data = data;
    this.rChild = null;
    this.lChild = null;
  }

  @Override
  public void addLfetTree(BTree lChild) {
    this.lChild = lChild;
  }

  @Override
  public BTree getLfetTree() {
    return lChild;
  }

  @Override
  public void addRightTree(BTree rChild) {
    this.rChild = rChild;
  }

  @Override
  public BTree getRightTree() {
    return rChild;
  }

  @Override
  public void clearTree() {
    this.data = null;
    this.rChild = null;
    this.lChild = null;
  }

  @Override
  public int getDeep() {
    return deep(this);
  }


  @Override
  public Object getRootData() {
    return data;
  }

  @Override
  public boolean hasLeftTree() {
    if (lChild != null) {
      return true;
    }
    return false;
  }

  @Override
  public boolean hasRightTree() {
    if (rChild != null) {
      return true;
    }
    return false;
  }

  @Override
  public boolean isEmptyTree() {
    if ((lChild == null && rChild == null && data == null) || this == null) {
      return true;
    }
    return false;
  }

  @Override
  public boolean isLeaf() {
    if (lChild == null && rChild == null) {
      return true;
    }
    return false;
  }

  @Override
  public void removeLeftTree() {
    lChild = null;
  }

  @Override
  public void removeRightTree() {
    rChild = null;
  }

  @Override
  public BTree getRoot() {
    return this;
  }

  @Override
  public void setRootData() {
    this.data = data;
  }

  @Override
  public int size() {
    return size(this);
  }

  private int size(BTree bTree) {
    if (bTree == null) {
      return 0;
    } else if (bTree.isLeaf()) {
      return 1;
    } else {
      if (bTree.getLfetTree() == null) {
        return size(bTree.getRightTree()) + 1;
      } else if (bTree.getRightTree() == null) {
        return size(bTree.getLfetTree()) + 1;
      } else {
        return size(bTree.getLfetTree()) + size(bTree.getRightTree()) + 1;
      }
    }
  }

  /**
   * 计算二叉树的高度
   */
  private int deep(BTree bTree) {
    if (bTree.isEmptyTree()) {
      return 0;
    } else if (bTree.isLeaf()) {
      return 1;
    } else {
      if (bTree.getLfetTree() == null) {
        return deep(bTree.getRightTree()) + 1;
      } else if (bTree.getRightTree() == null) {
        return deep(bTree.getLfetTree()) + 1;
      } else {
        return Math.max(deep(bTree.getLfetTree()), deep(bTree.getRightTree())) + 1;
      }
    }
  }
}

二叉树的各种遍历

遍历方式：前序、中序、后序、层次

阅读全文 »

HiSEN

发表于 | 分类于 
1
2
3
4
5
6
7
8
#删除原有的规则
route delete 0.0.0.0

#新增外网 172.16.188.254为网关(修改之前先看好)
route add 0.0.0.0 mask 0.0.0.0 172.16.188.254 metric 30  -p

#新增内网 16.0.0.0为内网网段 17.82.200.254为网关
route add 16.0.0.0 mask 255.0.0.0 17.82.200.254 metric 10 -p

带来的问题就是：
内网的数据库，在启动之后。时不时会自动断开，导致影响正常工作，时不时得重启程序才能测试

HiSEN

发表于 | 分类于

在eclipse中有列编辑模式：toggle block selection mode

在idea中也可以，而且还比较高级，哈哈

idea -> 右上角 -> Edit -> Column Selection Mode -> 移动光标到你想要弄的行

完事在重复一次，就可以退出列编辑模式

HiSEN

发表于 | 分类于

最小公倍数：
数论中的一种概念，两个整数公有的倍数成为他们的公倍数

其中一个最小的公倍数是他们的最小公倍数

同样地，若干个整数公有的倍数中最小的正整数称为它们的最小公倍数

求最小公倍数算法：

最小公倍数=两整数的乘积÷最大公约数

求最大公约数算法：

(1) 辗转相除法

有两整数a和b：

  1. a%b得余数c
  2. 若c=0，则b即为两数的最大公约数
  3. 若c≠0，则a=b，b=c，再回去执行1

例如:求27和15的最大公约数过程为

  1. 27÷15余12
  2. 5÷12余3
  3. 12÷3余0

因此，3即为最大公约数

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/**
 * 最大公约数
 */
public int getGCD(int m, int n) {
  if (n == 0) {
    return m;
  }
  return getGCD(n, m % n);
}

/**
 * 最小公倍数
 * @param m
 * @param n
 * @return
 */
public int getLCM(int m, int n) {
  int mn = m * n;
  return mn / getGCD(m, n);
}

/**
   * 辗转相除求最大公约数
   * 有两整数a和b：
   * ① a%b得余数c
   * ② 若c=0，则b即为两数的最大公约数
   * ③ 若c≠0，则a=b，b=c，再回去执行①
   */
  public int divisionGCD(int m, int n) {
    int a;
    while (n != 0) {
      a = m % n;
      m = n;
      n = a;
    }
    return m;
  }
  /**
   * 相减法求最大公约数
   * 有两整数a和b：
   * ① 若a>b，则a=a-b
   * ② 若a<b，则b=b-a
   * ③ 若a=b，则a（或b）即为两数的最大公约数
   * ④ 若a≠b，则再回去执行①
   */
  public int subtractionGCD(int m,int n){
    while(m != n){
      if (m>n){
        m = m-n;
      }else {
        n = n - m;
      }
    }
    return m;
  }

HiSEN

发表于 | 分类于

早些天不忙的时候看的入门，从有道云笔记搬过来的

简介

Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从Apache2.0协议开源。
Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。
容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

Docker的应用场景

  1. Web 应用的自动化打包和发布。
  2. 自动化测试和持续集成、发布。
  3. 在服务型环境中部署和调整数据库或其他的后台应用。
  4. 从头编译或者扩展现有的OpenShift或Cloud Foundry平台来搭建自己的PaaS环境。
    阅读全文 »
HiSEN

发表于 | 分类于

昨天在群里看到有人问怎么通过sql在oracle中取微秒

以前没有遇到过，就搜索了一下，找了一会给找到了

1
select to_char(systimestamp, 'yyyy-mm-dd hh24:mi:ss ff') from dual;

输出:年-月-日 时:分:秒 微秒

1
2017-9-24 10:38:27 129368

很少问题是搜索引擎找不到的，学会如何描述问题才是关键

HiSEN

发表于 | 分类于

概述

布隆过滤器的作用是加快判定一个元素是否在集合中出现的方法。

因为其主要是过滤掉了大部分元素间的精确匹配，故称为过滤器。

其应用场景为需要频繁在一个海量的集合中查找某个元素是否存在。

并且通常，这个值不在集合中。

比如Google chrome用此方法检查一个url是否在恶意url库中。

简单的例子

假设有一些字符串，假设有一个字符串a，要在集合B中查找其是否在集合B中。最笨的方法是遍历集合B中的每个元素bi，精确匹配a是否等于bi。若集合B中有N个元素，则最坏情况下需要执行N次精确匹配。

一个改进的方法是将a和B中每个字符串按照特定规则映射为数字，称为hash值。规则可以任意设置。比如取各字符串的首字母和尾字母的编码之乘积，取奇数个字符的编码执行异或，等。将比较字符串问题变成一个比较数字的问题。比较字符串需要从头到尾比较，而数字的比较会快很多。

需要注意的是，当两个字符串相同时，采用相同的映射规则得到的数字一定相同。但当两个字符串不同时，得到的字符串不一定不同。所以，当我们发现两个字符串的hash值相同时，两个字符串不一定相同，所以需要进一步去精确匹配两个字符串是否相同。但采用hash值方法已经能够过滤掉一部分以前需要精确匹配的计算量。仅当hash值相同（假设hash值通过字符串首尾字母计算得来，则当两个字符串首尾字母相同时hash值相同）时才去比较字符串本身。若选择hash值合理，则性能将大幅提高。

布隆过滤器通过将一个字符串使用多个不同的hash值计算方法，映射为多个不同的hash值，当所有这些hash值完全相同时，才认为两个字符串相同。从而进一步降低了放生hash值相同的可能性，从而进一步提高了过滤的性能。

Java代码实现

算法使用了md5值来生成n个不同的hash值

阅读全文 »