reduce(化简)、fold(折叠)和scan(扫描)的应用

package com.zyc.scala

/**
* Created with IntelliJ IDEA.
* Author: zyc2913@163.com
* Date: 2020/9/21 17:12
* Version: 1.0
* Description: reduce(化简)、fold(折叠)和scan(扫描)的应用
*/
object StudyReduce {
  def main(args: Array[String]): Unit = {
    //声明一个Int型数组
    val arr1:Array[Int] = Array(1, 2, 3)

    /**
     * reduceLeft左化简，，也可以简写成reduce，从左边开始，前两个数的运算结果与后一个数继续运算
     *def reduceLeft(op: (B, A) => B): B
     *  B是 A或者A的超类
     *  B上一次运算的结果
     *  运算逻辑如下图所示
     */
    /*
        6
       / \
      3 + 3
     / \
    1 + 2
   */
    //对数组arr1做化简运算
    //((1,2),3)
    val i0 = arr1.reduceLeft((a: Int, b: Int) => a + b)
    //((1,2),3)
    val i1 = arr1.reduce((a: Int, b: Int) => a + b)
    //打印到控制台：i和i1的值相同
    println(i0) //控制台输出：6

    /**
     * reduceRight右化简，从右边开始，最右边两个数的运算结果与其前一个数继续运算
     * def reduceRight(op: (A, B) => B): B
     * 运算逻辑如下图
     */
    /*
           2
          / \
        1 - -1
            / \
           2 - 3
  */
    //(1,(2,3))
    val i2 = arr1.reduceRight((a: Int, b: Int) => a - b)
    println(i2)  //控制台输出：2

    /**
     * foldLeft 左折叠,也可以简写成fold, 从左边开始，有初始值，初始值与左边第一个数运算的结果在与第二个数运算，依次类推
     * def foldLeft[B](z: B)(op: (B, A) => B): B =
     * 第一个参数是传入的初始值，将上一步返回的值作为函数的第一个参数继续传递参与运算，直到所有元素被遍历
     * 可以把 reduceLeft 看做简化版的 foldLeft,只是reduceLeft默认从head元素开始
     *
     * 执行逻辑如下图
     */
      /*
                    94
                   /  \
                  97 - 3
                 /  \
                99 - 2
               /  \
             100 - 1
       */
      //(((100,1),2),3)
    val i3 = arr1.foldLeft(100)(_ - _)
      //(((100,1),2),3)
    val i4 = arr1.fold(100)(_ - _)
    //打印到控制台，i3和i4的值相同
    println(i3)//控制台输出：94

    /**
     * foldRight 右折叠 从右边开始运算，有初始值，初始值和最右边的第一个数运算，所得结果与前一个数运算
     * def foldRight[B](z: B)(op: (A, B) => B): B =
     */
      /*
              -98
            /    \
           1  -  99
               /   \
              2 -  -97
                  /  \
                 3  - 100
       */
    //(1,(2,(3,100)))
    val i5 = arr1.foldRight(100)(_ - _)
    println(i5) //控制台输出：-98

    /**
     * scanLeft 左扫描,也可以简写成scan，从左边开始，有初始值，初始值每次和一个数运算得到一个值，结果是包括初始值和计算值组成的一个数组
     * def scanLeft[B, That](z: B)(op: (B, A) => B): That =
     *
     * 即对某个集合的所有元素做 fold 操作，但是会把产生的所有中间结果放置于一个集合中保存。
     */
    /*
                 94
                /  \
               97 - 3
              /  \
             99 - 2
            /  \
          100 - 1
    */
    // 100 (1,2,3) => (100,99,97,94)
    val ints = arr1.scanLeft(100)(_ - _)
    // 100 (1,2,3) => (100,99,97,94)
    val ints1 = arr1.scan(100)(_ - _)
    println(ints1.toList)  //控制台输出：List(100, 99, 97, 94)
    /**
     * scanRight右扫描
     * 执行逻辑如下图：从下往上计算
     */
      /*
        -98
     /     \
    1  -   99
         /    \
       2  -  -97
            /   \
           3 - 100
       */
      //(1,2,3) 100 => (-98,99,-97,100)
    val ints2 = arr1.scanRight(100)(_ - _)
    println(ints2.toList)

  }

}