mark's technic world

None是一个object，是Option的子类型，定义如下 [java] view plain copyprint?case object None extends Option[Nothing] {    def isEmpty = true    def get = throw new NoSuchElementException("None.ge

package dataimport scala.collection.mutable.ListBufferimport scala.util.control.Breaksobject MergeSort { def mergeSort[T](compatator:(T,T)=>Boolean)(source:List[T]):List[T]={ if(source.leng

package dataobject MergeSortUsePattern { def mergeSort[T](compatator:(T,T)=>Boolean)(source:List[T]):List[T]={ source match{ case list if (list.length==0)=>return List() case list

package msimport scala.collection.mutable.ListBufferimport scala.util.control.Breaks/** * 1.把二元查找树转变成排序的双向链表（树） 题目：输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。要求不能创建任何新的结点，只调整指针的指向。 10 / / 6 14 / /

Spark内核是由Scala语言开发的，因此使用Scala语言开发Spark应用程序是自然而然的事情。如果你对Scala语言还不太熟悉，可以阅读网络教程A Scala Tutorial for Java Programmers或者相关Scala书籍进行学习。本文将介绍3个Scala Spark编程实例，分别是WordCount、TopK和SparkJoin，分别代表了Spark

package msimport scala.collection.mutable.ArrayBuffer/** * 2.设计包含min函数的栈（栈）定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。要求函数min、push以及pop的时间复杂度都是O(1)。 */class CustomStack[T<%Ordered[T]]{ var data:ArrayBu

1python版'''Created on 2017-1-16@author: admin3.求子数组的最大和（数组）题目：输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为O(n)。例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10,

1scala版package msimport scala.collection.mutable.ListBufferimport scala.collection.mutable.ListBuffer/** * 4.在二元树中找出和为某一值的所有路径（树）题目：输入一个整数和一棵二元树。从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。打印出和与输入整数相等的

1python版'''Created on 2017-1-17@author: admin第7题（链表）微软亚院之编程判断俩个链表是否相交给出俩个单向链表的头指针，比如h1，h2，判断这俩个链表是否相交。为了简化问题，我们假设俩个链表均不带环。问题扩展：1.如果链表可能有环列?2.如果需要求出俩个链表相交的第一个节点列?'''from _overlapped impor

1scala版本package msimport scala.util.Random/** * 第11题（树）求二叉树中节点的最大距离...如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义"距离"为两节点之间边的个数。写一个程序，求一棵二叉树中相距最远的两个节点之间的距离。 * */class RandomBinaryTree{ var r

1python版本'''Created on 2017-1-18@author: admin第13题（链表）：题目：输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针。链表结点定义如下： struct ListNode{ int m_nKey; ListNode* m_pNext;};'''from _overlapped imp

1scala版本package ms/** * 第14题（数组）：题目：输入一个已经按升序排序过的数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字。要求时间复杂度是O(n)。如果有多对数字的和等于输入的数字，输出任意一对即可。例如输入数组1、2、4、7、11、15和数字15。由于4+11=15，因此输出4和11 */object MicroSoft014 {

1scala版本package ms/** * 第15题（树）：题目：输入一颗二元查找树，将该树转换为它的镜像，即在转换后的二元查找树中，左子树的结点都大于右子树的结点。用递归和循环两种方法完成树的镜像转换。 例如输入： 8 / / 6 10 // //5 7 9 11输出： 8 / / 10 6 // //11 9 7 5定义二元查找树的结点

1python版本'''Created on 2017-1-18@author: admin'''from _overlapped import NULLclass BinaryTree: def __init__(self): self.root=self.Node(0) self.root.left=self.Node(1)

1scala版本package ms/** * 第18题（数组）：题目：n个数字（0,1,…,n-1）形成一个圆圈，从数字0开始，每次从这个圆圈中删除第m个数字（第一个为当前数字本身，第二个为当前数字的下一个数字）。当一个数字删除后，从被删除数字的下一个继续删除第m个数字。求出在这个圆圈中剩下的最后一个数字。 */class Circle(){ var start=N

scala版本package msimport scala.collection.mutable.ListBuffer/** * 第21题（数组）2010年中兴面试题编程求解：输入两个整数 n 和 m，从数列1，2，3.......n 中 随意取几个数,使其和等于 m ,要求将其中所有的可能组合列出来. */class ExtractSum{ var result:Li

1scala版本package ms/** * 第9题（树）判断整数序列是不是二元查找树的后序遍历结果题目：输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。如果是返回true，否则返回false。例如输入5、7、6、9、11、10、8，由于这一整数序列是如下树的后序遍历结果： 8 / / 6 10 / / /

A list of the top differences between Java, Scala, Groovy, Clojure and KotlinIt doesn’t matter if you’re developing in Java, Scala or any other JVM languages, there’s always something new to learn

如果你想比较一下看看两个Scala对象是否相等，可以使用或者==，或它的反义!=。下面举几个例子：scala> 1 == 2 res24: Boolean = false scala> 1 != 2 res25: Boolean = true scala> 2 == 2 res26: Boolean = true 这些操作对所有对象都起作用，而不仅仅是基本类型。例如，你可以用他比较

object WithScope { def withScope2(fun: =>String)={ fun } def fun()={ println("haha") "success" } def main(args: Array[String]): Unit = { withScope2(fun) }}object Wit

classOf、isInstanceOf、asInstanceOf三个预定义方法分析  Scala的三个预定义(predefined)方法，我们经常用到；它们用来感觉很简单， 但是里面还是隐藏了一些细节东西，不妨花点时间来分析分析。先上代码  PredefineTest.scala object PredefineTest{ def main(args: Arr

最近在学习scala语言，记录下学习心得。scala的extend和with是怎么用的？1extend后面可以接类和特质（trait）class A{ }trait B{ }比如：class C extends A{ }class D extends B{ }2如果 extends和with同时使用则类比如放在前面比如：class W

package dataimport scala.collection.mutable.ListBufferimport scala.collection.mutable.ListBufferobject BubbleSort { def bubbleSort[T<%Ordered[T]](source:ListBuffer[T]):ListBuffer[T]={ for(i

package dataimport scala.collection.mutable.ListBufferimport scala.collection.mutable.ListBufferobject QuickSort { def quickSort[T<% Ordered[T]](source:ListBuffer[T],left:Int,right:Int):List

package dataimport scala.collection.mutable.ListBufferobject InsertSort { def insertSort[T<%Ordered[T]](source:ListBuffer[T]):ListBuffer[T]={ for(i<-1 until source.length){ for(j<-(1 t

package dataimport scala.collection.mutable.ListBufferobject SelectSort { def selectSort[T](comparator:(T,T)=>Boolean)(source:ListBuffer[T]):ListBuffer[T]={ for(i<-0 until source.length){

把记录按步长gap分组，对每组记录采用直接插入排序方法进行排序。随着步长逐渐减小，所分成的组包含的记录越来越多，当步长的值减小到1时，整个数据合成为一组，构成一组有序记录，则完成排序。我们来通过演示图，更深入的理解一下这个过程。package dataimport scala.collection.mutable.ListBufferobject Sh

二叉堆满足二个特性：1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。下图展示一个最小堆：由于其它几种堆（二项式堆，斐波纳契堆等）用的较少，一般将二叉堆就简称

1> Mainfest上下文界定 1. 在Scala中数组必须是有类型的，如果直接是泛型的话将会报错，这时候引入了Manifest上下文界定，需要一个Mainfest[T]对象，而mainifest[T]有一个隐式值，2. 如果调用makePair(1,2)，编译器将定位到隐式的Manifst[Int]并实际上调用makePair(2,3)(intManifest),该方法调用的就是n

java中有运行时异常和检查异常，运行时异常不强制显示捕获处理，检查异常需要强制在代码中捕获处理。但是scala中所有异常都不强制捕获处理。我写了一段代码一些可能就不知道某个函数会抛出什么异常，哪些需要写代码处理，这样的设计好不好啊？万一我没捕获异常，哪天程序抛出个异常，没处理，程序不是奔溃了。scala中没有throws关键字，有@throws (classOf[IOExceptio

scala的访问修饰符有如下几个特性：如果不指定访问修饰符，scala默认为public； 较之Java，scala对protected的定义更加严格； scala可以对可见性进行细粒度的控制。scala的默认访问修饰符如果没有修饰符，scala会默认把类、字段、方法的访问修饰符当做public。如果要将之调整为private或protected，只需在前面添加对应的修饰符关键字即

private[包名],private[this] 可以放在字段，方法和类上，用来限制访问权限；1private[包名]包名可以是父包名或当前包名，如果是父包名，则父包和子包都可以访问2private[this]修饰的方法或字段只能在本类访问，如果是字段编译成java的时候就没有get或set方法。3如果有两个名称相同的子包，比如package x.y.z.x.v有两个x，当p

基数排序是另外一种比较有特色的排序方式，它是怎么排序的呢？我们可以按照下面的一组数字做出说明：12、 104、 13、 7、 9 （1）按个位数排序是12、13、104、7、9 （2）再根据十位排序104、7、9、12、13 （3）再根据百位排序7、9、12、13、104package dataimport scala.collection

计数排序的思想是对每一个输入元素x，确定出小于x的元素个数，有了这一信息，就可以把x直接放在它在最终输出数组的位置上，例如，如果有17个元素小于x，则x就是属于第18个输出位置。当几个元素相同是，方案要略作修改。package dataimport scala.collection.mutable.ArrayBufferobject CountSort { def countSor

自从开始看scala的Parser相关的源码以来，我越来越觉得scala中很多处理方法就像是用黑魔法在与编译器打交道。不变成JVM上的c++誓不罢休？ 看Programming in Scala 源码 33.6Scala代码  abstract class Parser[+T] ... { p =>  ...    def ~ [U](q: =>

结合性决定了当有一系列同一优先级的操作符时，它们的求值顺序。在Scala中，绝大部分的操作符都是左结合（从左到右）的，除了：1. 以冒号:结尾的操作符；2. 赋值操作符。而且，在右结合时，二元操作符的参数顺序也发生了变化：二元操作符是其第二个参数的方法。 // ::操作符用来构造列表1 :: 2 :: Nil // Nil表示空列表// 上面表达式表示：1 :: (2 :: Nil

试验中发现当有两个满足时就会报冲突语法错误

我无可救药地成为了Scala的超级粉丝。在我使用Scala开发项目以及编写框架后，它就仿佛凝聚成为一个巨大的黑洞，吸引力使我不得不飞向它，以至于开始背离Java。固然Java 8为Java阵营增添了一丝亮色，却是望眼欲穿，千呼万唤始出来。而Scala程序员，却早就在享受lambda、高阶函数、trait、隐式转换等带来的福利了。Java像是一头史前巨兽，它在OO的方向上几乎走到了极致，硬将