scala快排、归并与二分查找

scala中快速排序、归并排序、二分查找的写法

快速排序

详解思想见：快速排序详解

package blog

/**
  *快速排序
  */
object QuickSort {

  def main(args: Array[String]): Unit = {
    val arr = Array(-2, -4, 4, 5, -1, 8, -9, 11)
    println("排序后的数组：" + quickSort(arr).mkString("[", ",", "]"))
  }

  /*
      快速排序的核心思想为左边的比基准数小，右边的比基准数大，所以我们可以
      利用scala中的partition方法将数组分为左右两组，head表示第一个数即
      基准数，tail表示剩下的数。
   */
  def quickSort(arr: Array[Int]): Array[Int] = {
    //递归先写递归出口，每一次递归待排序的数组中的元素就会减少，待所有的数完成排序后，数组自然为空
    if (arr.isEmpty) Array()
    else {
      //将数组分成两半,符合条件的数组放在左边
      val (left, right) = arr.tail.partition(num => num < arr.head)
      //按照小+基准数+大的顺序将数组拼接起来，.:+表示加在首部，.++表示加在尾部
      (quickSort(left)).:+(arr.head).++(quickSort(right))
    }
  }
}

归并排序

详解思想见：归并排序详解

package blog


/**
  * 归并排序
  */
object MergerSort {
  def main(args: Array[String]): Unit = {
    val arr = Array(-2, -4, 4, 5, -1, 8, -9, 11)
    val temp = new Array[Int](arr.length)
    mergeSort(arr, 0, arr.length - 1, temp)
    println(arr.mkString("[", ",", "]"))
  }

  def mergeSort(arr: Array[Int], left: Int, right: Int, temp: Array[Int]): Unit = {
    if (left < right) {
      val mid = (left + right) / 2
      mergeSort(arr, left, mid, temp)
      mergeSort(arr, mid + 1, right, temp)
      merge(arr, left, mid, right)

    }

    def merge(arr: Array[Int], left: Int, mid: Int, right: Int): Unit = {
      val temp = new Array[Int](right - left + 1)
      var i = left
      var j = mid + 1
      var k = 0
      while (i <= mid && j <= right) {
        if (arr(i) <= arr(j)) {
          temp(k) = arr(i)
          k += 1
          i += 1
        } else {
          temp(k) = arr(j)
          k += 1
          j += 1
        }
      }
      while (i <= mid) {
        temp(k) = arr(i)
        k += 1
        i += 1
      }
      while (j <= right) {
        temp(k) = arr(j)
        k += 1
        j += 1
      }
      for (n <- 0 until temp.length)
        arr(left + n) = temp(n)
    }
  }
}

二分查找

package blog

/**
  * 二分查找
  */
object BinarySearch {
  def main(args: Array[String]): Unit = {
    val arr = Array(-2, -4, 4, 5, -1, 8, -9, 11)
    val key = 4
    var index = binarySearch(arr, key)
    println("非递归："+index)
    index = binarySearch(arr, key, 0, arr.length - 1)
    println("递归："+index)
  }

  /*
      二分查找的思想就是，先找中间的数，如果比中间的
      数大，就在左边找，如果比中间的数小，就在右边找
   */
  //非递归
  def binarySearch(array: Array[Int], key: Int): Int = {
    var start = 0
    var end = array.length - 1
    while (start <= end) {
      val mid = (start + end) / 2
      if (key == array(mid))
      //这里必须加return才能跳出循环
        return mid
      else if (key < array(mid))
        end = mid - 1
      else
        start = mid + 1
    }
    //这里不存在的数我返回一个如果他存在所在的位置，并加上符号
    return -start
  }

  //递归
  def binarySearch(array: Array[Int], key: Int, start: Int, end: Int): Int = {
    val mid = (start + end) / 2
    if (start <= end) {
      if (key == array(mid))
        return mid
      else if (key < array(mid))
        return binarySearch(array, key, 0, mid - 1)
      else
        return binarySearch(array, key, mid + 1, end)
    } else
      return -start
  }
}