1
1
//! Sorting methods
2
+ #[ forbid( deprecated_mode) ] ;
3
+ #[ forbid( deprecated_pattern) ] ;
4
+
2
5
import vec:: { len, push} ;
3
6
import core:: cmp:: { Eq , Ord } ;
4
7
@@ -15,12 +18,12 @@ type le<T> = pure fn(v1: &T, v2: &T) -> bool;
15
18
* Has worst case O(n log n) performance, best case O(n), but
16
19
* is not space efficient. This is a stable sort.
17
20
*/
18
- fn merge_sort < T : copy > ( le : le < T > , v : ~ [ const T ] ) -> ~[ T ] {
21
+ fn merge_sort < T : copy > ( le : le < T > , v : & [ const T ] ) -> ~[ T ] {
19
22
type slice = ( uint , uint ) ;
20
23
21
24
return merge_sort_ ( le, v, ( 0 u, len ( v) ) ) ;
22
25
23
- fn merge_sort_ < T : copy > ( le : le < T > , v : ~ [ const T ] , slice : slice )
26
+ fn merge_sort_ < T : copy > ( le : le < T > , v : & [ const T ] , slice : slice )
24
27
-> ~[ T ] {
25
28
let begin = slice. first ( ) ;
26
29
let end = slice. second ( ) ;
@@ -35,7 +38,7 @@ fn merge_sort<T: copy>(le: le<T>, v: ~[const T]) -> ~[T] {
35
38
return merge ( le, merge_sort_ ( le, v, a) , merge_sort_ ( le, v, b) ) ;
36
39
}
37
40
38
- fn merge < T : copy > ( le : le < T > , a : ~ [ T ] , b : ~ [ T ] ) -> ~[ T ] {
41
+ fn merge < T : copy > ( le : le < T > , a : & [ T ] , b : & [ T ] ) -> ~[ T ] {
39
42
let mut rs = ~[ ] ;
40
43
vec:: reserve ( rs, len ( a) + len ( b) ) ;
41
44
let a_len = len ( a) ;
@@ -54,7 +57,7 @@ fn merge_sort<T: copy>(le: le<T>, v: ~[const T]) -> ~[T] {
54
57
}
55
58
}
56
59
57
- fn part < T : copy > ( compare_func : le < T > , arr : ~ [ mut T ] , left : uint ,
60
+ fn part < T : copy > ( compare_func : le < T > , arr : & [ mut T ] , left : uint ,
58
61
right : uint , pivot : uint ) -> uint {
59
62
let pivot_value = arr[ pivot] ;
60
63
arr[ pivot] <-> arr[ right] ;
@@ -71,7 +74,7 @@ fn part<T: copy>(compare_func: le<T>, arr: ~[mut T], left: uint,
71
74
return storage_index;
72
75
}
73
76
74
- fn qsort < T : copy > ( compare_func : le < T > , arr : ~ [ mut T ] , left : uint ,
77
+ fn qsort < T : copy > ( compare_func : le < T > , arr : & [ mut T ] , left : uint ,
75
78
right : uint ) {
76
79
if right > left {
77
80
let pivot = ( left + right) / 2 u;
@@ -90,12 +93,12 @@ fn qsort<T: copy>(compare_func: le<T>, arr: ~[mut T], left: uint,
90
93
* Has worst case O(n^2) performance, average case O(n log n).
91
94
* This is an unstable sort.
92
95
*/
93
- fn quick_sort < T : copy > ( compare_func : le < T > , arr : ~ [ mut T ] ) {
96
+ fn quick_sort < T : copy > ( compare_func : le < T > , arr : & [ mut T ] ) {
94
97
if len :: < T > ( arr) == 0 u { return ; }
95
98
qsort :: < T > ( compare_func, arr, 0 u, len :: < T > ( arr) - 1 u) ;
96
99
}
97
100
98
- fn qsort3 < T : copy Ord Eq > ( arr : ~ [ mut T ] , left : int , right : int ) {
101
+ fn qsort3 < T : copy Ord Eq > ( arr : & [ mut T ] , left : int , right : int ) {
99
102
if right <= left { return ; }
100
103
let v: T = arr[ right] ;
101
104
let mut i: int = left - 1 ;
@@ -152,14 +155,14 @@ fn qsort3<T: copy Ord Eq>(arr: ~[mut T], left: int, right: int) {
152
155
*
153
156
* This is an unstable sort.
154
157
*/
155
- fn quick_sort3 < T : copy Ord Eq > ( arr : ~ [ mut T ] ) {
158
+ fn quick_sort3 < T : copy Ord Eq > ( arr : & [ mut T ] ) {
156
159
if arr. len ( ) <= 1 { return ; }
157
160
qsort3 ( arr, 0 , ( arr. len ( ) - 1 ) as int ) ;
158
161
}
159
162
160
163
#[ cfg( test) ]
161
164
mod test_qsort3 {
162
- fn check_sort ( v1 : ~ [ mut int] , v2 : ~ [ mut int] ) {
165
+ fn check_sort ( v1 : & [ mut int] , v2 : & [ mut int] ) {
163
166
let len = vec:: len :: < int > ( v1) ;
164
167
quick_sort3 :: < int > ( v1) ;
165
168
let mut i = 0 u;
@@ -198,7 +201,7 @@ mod test_qsort3 {
198
201
199
202
#[ cfg( test) ]
200
203
mod test_qsort {
201
- fn check_sort ( v1 : ~ [ mut int] , v2 : ~ [ mut int] ) {
204
+ fn check_sort ( v1 : & [ mut int] , v2 : & [ mut int] ) {
202
205
let len = vec:: len :: < int > ( v1) ;
203
206
pure fn leual ( a : & int , b : & int ) -> bool { * a <= * b }
204
207
quick_sort :: < int > ( leual, v1) ;
@@ -258,7 +261,7 @@ mod test_qsort {
258
261
#[ cfg( test) ]
259
262
mod tests {
260
263
261
- fn check_sort ( v1 : ~ [ int ] , v2 : ~ [ int ] ) {
264
+ fn check_sort ( v1 : & [ int ] , v2 : & [ int ] ) {
262
265
let len = vec:: len :: < int > ( v1) ;
263
266
pure fn le ( a : & int , b : & int ) -> bool { * a <= * b }
264
267
let f = le;
0 commit comments