Scala数据结构——简单排序

Scala版数据结构——简单排序

1. 冒泡排序

思路：

			冒泡排序作为排序算法中的入门级算法，思路也是相对简单。但是相对的，
			也是各种排序算法中运行速度相对较慢的一种。其大致思路就是，每次拿
			一个元素和相邻的元素进行比较，每次比较时，满足大小条件的，就会交
			换位置，经过一轮排序后，最大（或最小）的数就会到最右边的位置。
			重复进行，直到找到倒数第一大（小）的数，整个排序就完成了。详情见
			下图。

代码:

def main(args: Array[String]): Unit = {
    val arr: Array[Int] = Array(2, 1, 44, 3, 5, 7)
    val sortedArr = popSort(arr)
    printf("一共执行了%d次",sortedArr._2)
  }

  def popSort(arr: Array[Int]): (Array[Int],Int) = {
    var temp = 0
    var count = 0
    for (i <- 0 to arr.length - 1) {
      for (j <- 0 to arr.length - 2 - i) {
        if (arr(j) > arr(j+1)) {
          var temp = arr(j)
          arr(j) = arr(j+1)
          arr(j+1) = temp

        }
        count+=1
      }
    }
    return (arr,count)
  }

		可以看到，执行时间最长的应当是完全反序的时候，如果待排序数组长度为N,
		则需要进行N-1次比较，交换位置时至少0次，至多N-1次，按照比较次数来算，
		第一次排序时，需要比较N-1，第二次N-2,以此类推，总共需:
		(N-1)+(N-2)+(N-3)......+(N-(N-1))=N*(N-1)/2次。
		那么次算法的运行时间和待排序的数组的长度之间的关系为T= O（Nˇ2），
		长度越长，排序时间越长。

2. 选择排序

思路：

		选择排序改良了冒泡排序，减少了交换位置的次数。选择排序不再是两两进行比较，
		而是选择一个元素和之后的所有的元素依次比较，最小的放左边，那么下一轮比较
		的时候，左边的元素就是有序的，只需要从下一个元素开始即可。

代码:

def main(args: Array[String]): Unit = {
    val arr: Array[Int] = Array(2, 1, 44, 3, 5, 7)
    val sortedArr = selectSort(arr)
    sortedArr._1.foreach(println)
    printf("一共执行了%d次",sortedArr._2)
  }

  def selectSort(arr: Array[Int]): (Array[Int], Int) = {
    var count = 0
      for(i <- 0 to arr.length-1){
        for (j <- i to arr.length-1){
          if (arr(i)>arr(j)){
            var min = arr(j)
            arr(j)=arr(i)
            arr(i) = min
          }
        }
        count+=1
      }
    return (arr, count)
  }

3. 插入排序

思路：

	相比较冒泡排序和选择排序，插入排序的速度会更快一些。插入排序的原理为，假设待排序
	的元素集合中有N个元素局部有序，那么需要做的就是拿其他无序的元素，和有序的元素比
	较，插入到对应合适的位置即可，将所有无序的元素全部插入到假设有序的元素集合中，
	所有元素就已经排好序了

代码:

 def main(args: Array[String]): Unit = {
    val arr: Array[Int] = Array(2, 1, 44, 3, 5, 7)
    val sortedArr = insertSort(arr)
    sortedArr._1.foreach(println)
    printf("一共执行了%d次", sortedArr._2)
  }
  def insertSort(arr: Array[Int]): (Array[Int], Int) = {
    var count = 0
    for (i <- 0 to arr.length - 1) {
      val unsorted = arr(i)
      var j = i - 1
      while (j >= 0 && arr(j) > unsorted) {
        arr(j + 1) = arr(j)
        j = j - 1
      }
      arr(j+1) = unsorted
      count += 1
    }
    return (arr, count)
  }

数据结构后续博文：

栈、队列、链表、递归、高级排序、二叉树、红黑树、2-3-4数、外部存储、哈希表、堆、图、带权图。更新频率大概两道三个工作日一篇博文。希望大家喜欢！！！