scala 九大排序算法

scala 九大排序算法

排序算法

• 直接插入排序
• 堆排序
• 冒泡排序
• 快速排序
• 选择排序
• 归并排序
• 计数排序
• 桶排序
• 基数排序

---

源代码

import java.io.PrintWriter
import scala.collection.mutable.ArrayBuffer
import scala.io.Source
import scala.util.Random
import scala.util.control.Breaks._


/**
  * Created by user on 6/2/17.
  */
object SortAll {
  def main(args: Array[String]): Unit = {
    val timestart = System.currentTimeMillis()

    val num=400000
    val creatData = new PrintWriter("/home/user/inputdata") //产生待排序数据
    for (_ <- 1 to 300000000) creatData.println(Random.nextInt(num))
    creatData.close()
    val file = Source.fromFile("/home/user/inputdata")
    val predata = new ArrayBuffer[Int]
    for (line <- file.getLines()) predata += line.toInt
    val sorteddata = qksort(predata)  //根据需要，调用不同的排序函数
    val outData = new PrintWriter("/home/user/outdata")
    for (i <- sorteddata) outData.println(i)
    val timeover = System.currentTimeMillis()
    print("The runtime is  " + (timeover - timestart) / 1000.0 + "  s")
  }


    /*函数功能：直接插入排序*/
    def SinsrtSort(inputData: ArrayBuffer[Int]): ArrayBuffer[Int] = {
      for (i <- 1 until inputData.length) {
        val x = inputData(i)
        var j = i - 1
        while (j > 0 && x < inputData(j)) {
          inputData(j + 1) = inputData(j)
          j = j - 1
        }
        inputData(j + 1) = x
      }
      inputData
    }

    /*函数功能：堆化*/
    def heapify(inputData: ArrayBuffer[Int], m: Int, j: Int): Unit = {
      var i = m
      var k = 2 * i
      val x = inputData(i)
      breakable {
        //调用循环终止break方法
        while (k <= j) {
          if (k < j)
            if (inputData(k) < inputData(k + 1)) k = k + 1
          if (x >= inputData(k)) break
          else {
            inputData(i) = inputData(k)
            i = k
            k = 2 * i
          }
        }
      }
      inputData(i) = x
    }

    /*函数功能：堆排序*/
    def heapSort(inputData: ArrayBuffer[Int]): ArrayBuffer[Int] = {
      var i = inputData.length / 2
      while (i >= 1) {
        heapify(inputData, i - 1, inputData.length - 1)
        i = i - 1
      }
      var j = inputData.length - 1
      while (j > 0) {
        val x = inputData(0)
        inputData(0) = inputData(j)
        inputData(j) = x
        heapify(inputData, 0, j - 1)
        j = j - 1
      }
      inputData
    }

    /*函数功能：冒泡排序*/

    def bubblingSort(inputData: ArrayBuffer[Int]): ArrayBuffer[Int] = {
      for (j <- 0 to inputData.length - 3)
        for (i <- 0 to inputData.length - 2 - j) {
          if (inputData(i) > inputData(i + 1)) { //判断前一个元素是否大于后一个，如果大于，则交换
            val temp = inputData(i + 1)
            inputData(i + 1) = inputData(i)
            inputData(i) = temp
          }
        }
      inputData
    }

    /*函数功能：快速排序*/
    def qksort(inputData: ArrayBuffer[Int]): ArrayBuffer[Int] = {
      def qsort1(inputData: ArrayBuffer[Int], left: Int, right: Int): Unit = {
        if (left < right) {
          var i = left
          var j = right
          val x = inputData(i)
          while (i < j) {
            while (i < j && inputData(j) > x) j = j - 1 /* 从右向左找第一个小于x的数 */
            if (i < j) {
              inputData(i) = inputData(j)
              i = i + 1
            }
            while (i < j && inputData(i) < x) i = i + 1 /* 从左向右找第一个大于x的数 */
            if (i < j) {
              inputData(j) = inputData(i)
              j = j - 1
            }
          }
          inputData(i) = x
          qsort1(inputData, left, i - 1) /* 递归调用 */
          qsort1(inputData, i + 1, right)
        }
      }
      qsort1(inputData, 0, inputData.length - 1)
      inputData
    }


    //选择排序
    def SelectionSort(inputData: ArrayBuffer[Int]): ArrayBuffer[Int] = {
      for (i <- 0 until inputData.length - 1) {
        var index = i
        var value = inputData(i)
        for (j <- i + 1 until inputData.length) {
          if (value > inputData(j)) {
            index = j
            value = inputData(j)
          }
        }
        if (index != i) {
          inputData(index) = inputData(i)
          inputData(i) = value
        }
      }
      inputData
    }

    //归并排序
    def merge(a: List[Int], b: List[Int]): List[Int] = (a, b) match {
      case (Nil, _) => b
      case (_, Nil) => a
      case (x :: xs, y :: ys) =>
        if (x <= y) x :: merge(xs, b)
        else y :: merge(a, ys)
    }

    def mergeSort(lst: List[Int]): List[Int] = {
      if (lst.length < 2) lst
      else {
        val (first, second) = lst.splitAt(lst.length / 2)
        merge(mergeSort(first), mergeSort(second))
      }
    }

    //计数排序
    def Countingsort(inputData: ArrayBuffer[Int], k: Int): Array[Int] = {
      //k表示有所输入数字都介于0到k之间
      val temp = new Array[Int](k)
      // 临时存储区
      val outdata = new Array[Int](inputData.length)
      val len = temp.length
      for (i <- 0 until len) {
        // 初始化
        temp(i) = 0
      }
      for (i <- inputData.indices) {
        temp(inputData(i)) = temp(inputData(i)) + 1
      }
      for (i <- 1 until len) {
        temp(i) = temp(i) + temp(i - 1)
      }
      // 把输入数组中的元素放在输出数组中对应的位置上
      var n = inputData.length - 1
      while (n >= 0) {
        // 从后往前遍历
        outdata(temp(inputData(n)) - 1) = inputData(n)
        temp(inputData(n)) = temp(inputData(n)) - 1
        n = n - 1
      }
      outdata
    }

    //桶排序
    def bucketsort(inputData: ArrayBuffer[Int], max: Int): ArrayBuffer[Int] = {
      var buckets = new Array[Int](max)
      for (i <- inputData.indices) //计数
        buckets(inputData(i)) = buckets(inputData(i)) + 1
      var j = 0
      for (i <- 0 until max)
        while (buckets(i) > 0) {
          inputData(j) = i
          j = j + 1
          buckets(i) = buckets(i) - 1
        }
      buckets = null
      inputData
    }

    /** 基数排序函数
      * B表示要排序的数组
      * d表示每一位数字的范围（这里是10进制数，有0~9一共10种情况）
      */
    def RadixSort(inputData: ArrayBuffer[Int], d: Int): ArrayBuffer[Int] = {
      //n用来表示当前排序的是第几位
      var n = 1
      //hasNum用来表示数组中是否有至少一个数字存在第n位
      var hasNum = false
      /** 二维数组temp用来保存当前排序的数字
        * 第一维d表示一共有d个桶
        * 第二维B.length表示每个桶最多可能存放B.length个数字
        */
      val temp = Array.ofDim[Int](d, inputData.length)
      val order = new Array[Int](d)
      breakable {
        while (true) {
          //判断是否所有元素均无比更高位，因为第一遍一定要先排序一次，所以有n!=1的判断
          if (n != 1 && !hasNum) {
            break
          }
          hasNum = false
          //遍历要排序的数组，将其存入temp数组中（按照第n位上的数字将数字放入桶中）
          for (i <- inputData.indices) {
            val x = inputData(i) / (n * 10)
            if (x != 0) hasNum = true
            val lsd = x % 10
            temp(lsd)(order(lsd)) = inputData(i)
            order(lsd) = order(lsd) + 1
          }
          //k用来将排序好的temp数组存入B数组（将桶中的数字倒出）
          var k = 0
          for (i <- 0 until d) {
            if (order(i) != 0) {
              var j = 0
              while (j < order(i)) {
                inputData(k) = temp(i)(j)
                k = k + 1
                j = j + 1
              }
            }
            order(i) = 0
          }
          n = n + 1
        }
      }
      inputData
    }

}