前面一篇文章介紹了SimHash演算法的基本原理和主要的應用場景。由於SimHash演算法是一種在大規模資料下解決文字相似與否的演算法，這篇文章主要介紹一下自己基於Scala實現的一種精簡版SimHash演算法。

演算法思路：

對於一個文字內容，先使用正則表示式對無意義字元進行過濾，再以滑動切片的方法將文字切成一個字串陣列，其中滑動切片視窗的閾值視情況而定。然後對該字串陣列，進行權重派分。程式碼中給出了字首、字尾和平攤的方案進行派分，權重賦值為1和3（詳細請看程式碼）。然後通過雜湊函式對每個分片字串進行計算，並生成該分片的權重陣列。接下來把所有分片權重陣列累加，再將64位權重陣列大於0的位置1，其餘置0，生成最終的SimHash值。

雜湊值計算，由於生成64位雜湊值，為了方便後面操作，使用位陣列。

  def byte2Bools(b: Byte) =
    (0 to 7).foldLeft(ArrayBuffer[Boolean]())((bs, i) => bs += isBitSet(b, i)).reverse

  def isBitSet(byte: Byte, bit: Int) =
    ((byte >> bit) & 1) == 1

  def hashFuc(st:String):ArrayBuffer[Boolean] ={
    var str
    =org
 
.apache.commons.codec.digest.DigestUtils.md5Hex(st)
    var hashV = new java.math.BigInteger(str,16)
    var hashArrByte =hashV.toByteArray()
    var hashArrBoolean = ArrayBuffer[Boolean]()
    var len = hashArrByte.length
    for(i<- 0 to len-1){
      var temArr = byte2Bools(hashArrByte(i))
      hashArrBoolean
 
++=temArr
    }
    hashArrBoolean
  }

正則過濾函式，用來給文字去掉意義不大的字元。

  def tokenlize(str:String):ArrayBuffer[String]={
    var reg = """[\w\u4e00-\u9fcc]+""".r
    var s = str.toLowerCase()
    var reStr = (reg findAllIn s).mkString("")
    var ans = slide(reStr)
    ans
  }

滑動切片函式，用來將文字切片。

  def slide(str:String): ArrayBuffer[String] ={
    val slideWidth = 4
    var len = str.length
    var res = ArrayBuffer[String]()
    var a = 0
    if(len>=4){
      for(a <- 0 to (len - slideWidth)){
        var s = str.slice(a,a+slideWidth)
        res+=s
      }
    }else{
      res+= str
    }
    res
  }

對切片陣列賦予權重

  def weightCul(Type:String,length:Int):ArrayBuffer[Int] = {
    var weights = ArrayBuffer[Int]()
    val len = length/2 + 1
    val a = 1
    if(weightType=="pre"){
      for(a<- 1 to len){
        weights+= 3
      }
      for(a<- 1 to length-len){
        weights+= 1
      }

    }else{
      if(weightType=="suf"){
        for (a<- 1 to length-len){
          weights+= 1
        }
        for (a<- 1 to len){
          weights+= 3
        }

      }else{
        for (a<- 1 to length){
          weights+= 1
        }
      }
    }
    weights
  }

對文字進行SimHash值計算

  def buildByArr(fea:ArrayBuffer[(String, Int)]):String = {
    var v = ArrayBuffer[Int]()
    val f = 64
    for (i<- 1 to f){
      v+= 0
    }
    var len=fea.length
    for (j<- 0 to len-1){
      var feature = fea(j)
      var hashArr = hashFuc(feature._1)
      var weight = feature._2
      var hLen = hashArr.length
      for(a<-0 to f-1){
        if ((hashArr(hLen-1-a))){
          v(a)+= weight
        }else{
          v(a)-= weight
        }
      }
    }
    var list = new java.math.BigInteger("0")
    for(k<- 0 to f-1){
      if(v(k)>0){
        list = list.setBit(k)
      }
    }
    val simHash = list.toString
    SimHash
  }

至此，就可以計算出在不同權重方案下SimHash的值。

這種計算方法比較適合較短文字的計算，長文字採用分詞的方式較為有效。