scala 总结

scala 简洁整理

package com.ghc.bigdata
object AdvancedScala{
  def main(args: Array[String]):Unit = {
    /*val arr:Array[Int] = (10 to 1 by -1).toArray
    println("before sort arr: " + arr.mkString(","))
    selectSort(arr)
    println("after sort arr: " + arr.mkString(","))
    switchFunc(Array(1, 3, 5))
*/
    val parentArr : Array[Parent] = Array(Parent("Frank", 18), Parent("Tom", 20), Parent("Ali", 16))
    println(parentArr.mkString(","))
//    insertSort[Parent](parentArr)
//    heapSort[Parent](parentArr)
//    shellSort[Parent](parentArr)
//    bubbleSort(parentArr)
//    quickSort(parentArr)
    mergeSort(parentArr)
    println(parentArr.mkString(","))

    parentArr.foreach(p => matchParent(p))

  }

  def matchParent(x: Parent) = x match  {
    case Parent("Frank", 18) => println("frank...")
    case Parent("Tom", 20) => println("Tom...")
    case Parent("Ali", 15) => println("Ali")
    case _ => println("nonononoononononono")
  }

  // 参数隐式传递的  方法， 如果有默认值用默认值，没有默认值用 implicit 声明的同一类型的值
  def selectSort(implicit arr: Array[Int] = Array(10, 9, 8, 7, 6, 5, 4)):Unit = {
    for(i <- 0 to arr.length -1 - 1 ; j<- (i+1 to arr.length -1)){
      if(arr(i).compareTo(arr(j))>0){
        swap(arr, i, j)
      }
    }
  }

  def switchFunc(s: Any): Unit = {
    s match{
      case a:String => println("s 是 字符串")
      case Array(0,_*) => println("s 是以 0 开头的 数组")
      case Array(1, 0) => println(s"xxx")
      case _ => println("啥也不是")
    }
  }

  def insertSort[T <: Comparable[T]](arr: Array[T]):Unit = {
    for(i <- (0 to arr.length-1); j<-(i.to(1).by(-1))){
      if(arr(j).compareTo(arr(j-1)) < 0){
        swapT(arr, j, j-1);
      }
    }
  }

  def swapT[T <: Comparable[T]](arr:Array[T], i:Int, j:Int):Unit = {
    val tmp: T = arr(i)
    arr(i) = arr(j)
    arr(j) = tmp
  }
  def swap(arr:Array[Int], i:Int, j:Int):Unit = {
    arr(i) = arr(i) ^ arr(j)
    arr(j) = arr(i) ^ arr(j)
    arr(i) = arr(i) ^ arr(j)
  }

  def heapSort[T <: Comparable[T]](arr: Array[T]):Unit = {
    buildHeap[T](arr)
    for(i <- Range(arr.length -1, 0, -1)){
      swapT[T](arr, i, 0)
      heapify(arr, i, 0)
    }
  }

  private def heapify[T <: Comparable[T]](arr:Array[T], len:Int, index:Int): Unit ={
    if(index >= len) return

    val leftChildNode = 2 * index + 1
    val rightChildNode = 2 * index + 2
    var max = index

    if(leftChildNode < len && arr(leftChildNode).compareTo(arr(max)) > 0){
      max = leftChildNode
    }
    if(rightChildNode < len && arr(rightChildNode).compareTo(arr(max)) > 0){
      max = rightChildNode
    }
    if(max != index){
      swapT(arr, index, max)
      heapify(arr, len, max)
    }
  }

  private def buildHeap[T <:Comparable[T]](arr:Array[T]): Unit ={
    val lastChildNode = arr.length - 1
    val lastParentNode = (lastChildNode - 1) >> 1
    for(i <- lastChildNode to 0 by -1){
      heapify(arr, arr.length, i)
    }
  }

  def shellSort[T <: Comparable[T]](arr:Array[T]):Unit = {
    var h = 1
    while(h < arr.length / 3){
      h = 3*h + 1
    }
    for(gap <- h to 1 by -1){
      for(i <- gap until arr.length by 1){
        for(j <- i to gap by -gap){
          if(arr(j-gap).compareTo(arr(j)) > 0){
            swapT(arr, j-gap, gap)
          }
        }
      }
    }
  }

  def quickSort[T <: Comparable[T]](arr:Array[T]):Unit = {
    internalQuickSort(arr, 0, arr.length - 1)
  }

  private def internalQuickSort[T <: Comparable[T]](arr: Array[T], left:Int, right:Int): Unit ={
    if(left < right){
      val pivot:Int = partition(arr, left, right)
      internalQuickSort(arr, 0, pivot - 1)
      internalQuickSort(arr, pivot + 1, right)
    }
  }

  private def partition[T <: Comparable[T]](arr: Array[T], left:Int, right:Int): Int ={
    var i = left
    var j = right
    val pivot = arr(i)
    while(i <= j){
      while(i <= j && arr(j).compareTo(pivot) >= 0){
        j -= 1
      }
      arr(i) = arr(j)
      while(i <= j && pivot.compareTo(arr(i)) > 0){
        i += 1
      }
      arr(j) = arr(i)
    }
    arr(i) = pivot
    i
  }

  def mergeSort[T <: Parent](arr: Array[Parent]):Unit = {
    internalMergeSort(arr, 0, arr.length - 1)
  }

  def internalMergeSort[T <: Comparable[T]](arr: Array[T], left:Int, right:Int): Unit ={
    if(left < right){
      val mid = left + ((right - left) >> 1)
      internalMergeSort(arr, left, mid)
      internalMergeSort(arr, mid+1, right)
      merge(arr, left, mid+1, right)
    }
  }

  def merge[T <: Comparable[T]](arr : Array[T], left:Int, right:Int, rightBounds:Int): Unit ={
    var i = left
    var j = right
    var k = 0
    var count = rightBounds - left + 1
    val tempArr : Array[T] = new Array(count).asInstanceOf[Array[T]]
    val mid = right - 1

    while(i <= mid && j <= rightBounds){
      if(arr(i).compareTo(arr(j)) < 0){
        tempArr(k) = arr(i)
        i += 1
        k += 1
      }else{
        tempArr(k) = arr(j)
        j += 1
        k += 1
      }
    }
    while(i <= mid){
      tempArr(k) = arr(i)
      i += 1
      k += 1
    }
    while(j <= rightBounds){
      tempArr(k) = arr(j)
      j += 1
      k += 1
    }
    for(m <- 0 until count){
      arr(m + left) = tempArr(m)
    }
  }
  // T* = 多参数
  def bubbleSort[T <: Comparable[T]](arr: Array[T]):Unit = {
    for(i <- 0 to arr.length -1){
      for(j <- 0 until arr.length - 1 - i){
        if(arr(j).compareTo(arr(j+1)) > 0){
          swapT(arr, j, j+1)
        }
      }
    }
  }

}

object Parent{
  def unapply(t: Parent): Option[(String, Int)] = Some((t.name, t.age))

  def apply(name:String, age:Int):Parent = new Parent(name, age)
}

class Parent(var name:String, var age:Int) extends Comparable[Parent]{
  override def compareTo(that: Parent): Int = {
    if(this.name.compareTo(that.name) > 0){
      return 1
    }else if(this.name.compareTo(that.name) < 0){
      return -1
    } else{
      this.age - that.age
    }
  }

  override def toString: String = {
    val builder = new StringBuilder()
    builder.append("Person(")
      .append(this.name)
      .append(",")
      .append(age)
      .append(")")
      .toString()
  }
}

class AdvancedScala{

}