def sorted[b >
: a]
(implicit ord: ordering[b]
): repr
scala>
val a = list(10,
5,8,
1,7)
.sorted
a: list[
int]
= list(1,
5,7,
8,10)
scala>
val b = list(
"banana"
,"pear",,
"orange"
).sorted
b: list[
string
]
如果序列持有的型別沒有隱式型別，則無法用 對它進行排序
其中emplist.sorted.foreach(println)等價於
emplist.
sorted
(ordering[emp]).
foreach
(println
)
val firstemp: emp = emp(1,
"michael"
,1000.00
)val secondemp: emp = emp(2,
"james"
,12000.00
)val thirdemp = emp(3,
"shaun"
,9000.00
)val emplist = list(firstemp, secondemp, thirdemp)
//傳參的時候不需要傳入隱式引數
emplist.sorted.foreach(println)
}case
class emp(id:
int, name:
string
, salary:
double
)object emp }}
隱式引數可以不用傳遞,系統會自動尋找
object _02******
}case
class emp(id:
int, name:
string
, salary:
double
)extends ordered[emp]
def sortwith
(lt:
(a, a)
=> boolean)
: repr
scala>
val list=list(
"a",
"d",
"f",
"b",
"e")
list: list[
string
]= list(a, d, f, b, e)
scala> list.sortwith(
(x,y)
=>x.tolowercaseres0: list[
string
]= list(a, b, d, e, f)
scala> list(
"steve"
,"tom"
,"john"
,"bob"
).sortwith(_.compareto(_)
<0)
res1: list[
string
]= list(bob, john, steve, tom)
比較簡單,不用定義隱式什麼的
object _02******
).foreach(println)}}
case
class emp(id:
int, name:
string
, salary:
double
)
def sortby[b]
(f: a =
> b)
(implicit ord: ordering[b]
): repr
scala>
val words =
"the quick brown fox jumped over the lazy dog"
.split(
' ')
words: array[
string
]= array(the, quick, brown, fox, jumped, over, the,
lazy
, dog)
//依據字串長度進行排序
scala> words.sortby(x=>x.length)
res0: array[
string
]= array(the, fox, the, dog, over,
lazy
, quick, brown, jumped)
//先依據字串長度,再依據首字母排序
scala> words.sortby(x=>x.length,x.head)
:26: error: too many arguments for method sortby:
(f:string
=> b)
(implicit ord: scala.math.ordering[b]
)array[
string
] words.sortby(x=>x.length,x.head)
^scala> words.sortby(x=>
(x.length,x.head)
)res2: array[
string
]= array(the, dog, fox, the,
lazy
, over, brown, quick, jumped)
//依據字典排序
scala> words.sortby(x=>x)
res3: array[
string
]= array(the, brown, dog, fox, jumped,
lazy
, over, quick, the)
scala>
val a = list(
("a",2
),("b",44
),("c",20
),("a",20
),("a",1
))a: list[
(string
,int)]
= list(
(a,2),
(b,44),
(c,20),
(a,20),
(a,1))
//依據數字進行排序
scala> a.sortby(x=>x._2)
res8: list[
(string
,int)]
= list(
(a,1),
(a,2),
(c,20),
(a,20),
(b,44))
//先依據字母排序,字母相同的依據數字排序
scala> a.sortby(x=>
(x._1,x._2)
)res9: list[
(string
,int)]
= list(
(a,1),
(a,2),
(a,20),
(b,44),
(c,20))
scala> a.sortby(x=>x._1)
res10: list[
(string
,int)]
= list(
(a,2),
(a,20),
(a,1),
(b,44),
(c,20))
//先依據數字排序,數字相同的依據字母排序
scala> a.sortby(x=>
(x._2,x._1)
)res11: list[
(string
,int)]
= list(
(a,1),
(a,2),
(a,20),
(c,20),
(b,44
))
def sortby[b]
(f: a => b)
(implicit ord: ordering[b]
): repr = sorted(ord on f)
object _02******
}case
class emp(id:
int, name:
string
, salary:
double
)
Scala 三個引號
雙引號 1.換行需要加 n 比如 val s select from user n where user id 100 println s 控制台輸出結果 select from user where user id 100 三引號1 中間字串可以直接回車換行val s select from us...
三個簡單的排序
氣泡排序 從第乙個元素開始,和它右邊的哪個元素比較,如果它比右邊的哪個元素大的話,就交換位置,經過第一次後,最右邊的那個元素,就是最大的哪個元素.第二次同樣,從第一元素開始,但是比較到倒數第二個元素,這樣右邊第二個元素就是第二高的元素.依次這樣下去,每次比較的結束值就是,比上一次小乙個,直到結束的標...
O n 的三個排序演算法
今天覆習下最簡單的三個排序演算法，乙個是選擇排序，乙個是插入排序，乙個是氣泡排序，三者時間複雜度都是o n 通過分析來發現三者的優劣，以及對最好的情況和最壞的情況進行分析。另外，這三中排序演算法都是基於比較的排序演算法。基於比較的排序演算法的執行過程，會涉及兩種操作，一種是元素比較大小，另一種是元素...