Java 返回从最小值到最大值的排序数组。
返回从最小值到最大值的排序数组。
实例源码：
源代码：
执行
执行中...
x
1
2
3
//package com.nowjava;4
/*来 自 NowJava.com*/5
6
public class Main {7
8
public static void main(String[] argv) throws Exception {9
10
double[] v = new double[] { 34.45, 35.45, 36.67, 37.78, 37.0000,11
12
37.1234, 67.2344, 68.34534, 69.87700 };13
14
System.out.println(java.util.Arrays.toString(sortMinToMax(v)));15
16
}17
18
19
/**20
21
* Returns a sorted array from the minimum to the maximum value.22
23
*/24
25
public static double[] sortMinToMax(double[] v) {26
27
double[] ans = copy(v);28
29
quickSortMinToMax(ans, 0, ans.length - 1);30
/*31
nowjava.com - 时代Java 提供32
*/33
34
return (ans);35
36
}37
38
39
/**40
41
* Returns a sorted array from the minimum to the maximum value.42
43
*/44
45
public static int[] sortMinToMax(int[] v) {46
47
int[] ans = copy(v);48
49
quickSortMinToMax(ans, 0, ans.length - 1);50
51
return (ans);52
53
}54
55
56
/**57
58
* Returns a comma delimited string representing the value of the array.59
60
*/61
62
public static String toString(double[] array) {63
64
65
StringBuffer buf = new StringBuffer(array.length);66
67
int i;68
69
for (i = 0; i < array.length - 1; i++) {70
71
buf.append(array[i]);72
73
buf.append(',');74
75
}76
77
buf.append(array[i]);78
79
return buf.toString();80
81
}82
83
84
/**85
86
* Returns a comma delimited string representing the value of the array.87
88
*/89
90
public static String toString(double[][] array) {91
92
StringBuffer buf = new StringBuffer();93
94
for (int k = 0; k < array.length; k++) {95
96
buf.append(toString(array[k]));97
98
buf.append(System.getProperty("line.separator"));99
100
}101
102
return buf.toString();103
104
}105
106
107
/**108
109
* Returns a comma delimited string representing the value of the array.110
111
*/112
113
public static String toString(int[] array) {114
115
StringBuffer buf = new StringBuffer(array.length);116
117
int i;118
119
for (i = 0; i < array.length - 1; i++) {120
121
buf.append(array[i]);122
123
buf.append(',');124
125
}126
127
buf.append(array[i]);128
129
return buf.toString();130
131
}132
133
134
/**135
136
* Returns a comma delimited string representing the value of the array.137
138
*/139
140
public static String toString(int[][] array) {141
142
StringBuffer buf = new StringBuffer();143
144
for (int k = 0; k < array.length; k++) {145
146
buf.append(toString(array[k]));147
148
buf.append(System.getProperty("line.separator"));149
150
}151
152
return buf.toString();153
154
}155
156
157
/**158
159
* Returns a copy of the array.160
161
*/162
163
//a call to array.clone() may also work although this is a primitive type. I haven't checked164
165
//it even may be faster166
167
public static int[] copy(int[] array) {168
169
int[] result;170
171
result = new int[array.length];172
173
System.arraycopy(array, 0, result, 0, array.length);174
175
return result;176
177
}178
179
180
/**181
182
* Returns a copy of the array.183
184
*/185
186
//a call to array.clone() may also work although this is a primitive type. I haven't checked187
188
//it even may be faster189
190
public static long[] copy(long[] array) {191
192
long[] result;193
194
result = new long[array.length];195
196
System.arraycopy(array, 0, result, 0, array.length);197
198
return result;199
200
}201
202
203
/**204
205
* Returns a copy of the array.206
207
*/208
209
//a call to array.clone() may also work although this is a primitive type. I haven't checked210
211
//it even may be faster212
213
public static float[] copy(float[] array) {214
215
float[] result;216
217
result = new float[array.length];218
219
System.arraycopy(array, 0, result, 0, array.length);220
221
return result;222
223
}224
225
226
/**227
228
* Returns a copy of the array.229
230
*/231
232
//a call to array.clone() may also work although this is a primitive type. I haven't checked233
234
//it even may be faster235
236
public static double[] copy(double[] array) {237
238
double[] result;239
240
result = new double[array.length];241
242
System.arraycopy(array, 0, result, 0, array.length);243
244
return result;245
246
}247
248
249
/**250
251
* Returns a copy of the array.252
253
*/254
255
public static double[][] copy(double[][] v) {256
257
double[][] ans = new double[v.length][];258
259
for (int k = 0; k < v.length; k++)260
261
ans[k] = copy(v[k]);262
263
return (ans);264
265
}266
267
268
/**269
270
* Returns a copy of the array.271
272
*/273
274
public static int[][] copy(int[][] v) {275
276
int[][] ans = new int[v.length][];277
278
for (int k = 0; k < v.length; k++)279
280
ans[k] = copy(v[k]);281
282
return (ans);283
284
}285
286
287
/**288
289
* This is a generic version of C.A.R Hoare's Quick Sort290
291
* algorithm. This will handle arrays that are already292
293
* sorted, and arrays with duplicate keys.<BR>294
295
* <p/>296
297
* If you think of a one dimensional array as going from298
299
* the lowest index on the left to the highest index on the right300
301
* then the parameters to this function are lowest index or302
303
* left and highest index or right. The first time you call304
305
* this function it will be with the parameters 0, a.length - 1.306
307
* (taken out of a code by James Gosling and Kevin A. Smith provided308
309
* with Sun's JDK 1.1.7)310
311
*312
313
* @param a an integer array314
315
* @param lo0 left boundary of array partition (inclusive).316
317
* @param hi0 right boundary of array partition (inclusive).318
319
* @deprecated320
321
*/322
323
private static void quickSortMinToMax(int a[], int lo0, int hi0) {324
325
int lo = lo0;326
327
int hi = hi0;328
329
int mid;330
331
332
if (hi0 > lo0) {333
334
335
/* Arbitrarily establishing partition element as the midpoint of336
337
* the array.338
339
*/340
341
mid = a[(int) Math.round((lo0 + hi0) / 2.0)];342
343
344
// loop through the array until indices cross345
346
while (lo <= hi) {347
348
/* find the first element that is greater than or equal to349
350
* the partition element starting from the left Index.351
352
*/353
354
while ((lo < hi0) && (a[lo] < mid))355
356
++lo;357
358
359
/* find an element that is smaller than or equal to360
361
* the partition element starting from the right Index.362
363
*/364
365
while ((hi > lo0) && (a[hi] > mid))366
367
--hi;368
369
370
// if the indexes have not crossed, swap371
372
if (lo <= hi) {373
374
swap(a, lo, hi);375
376
++lo;377
378
--hi;379
380
}381
382
}383
384
385
/* If the right index has not reached the left side of array386
387
* must now sort the left partition.388
389
*/390
391
if (lo0 < hi)392
393
quickSortMinToMax(a, lo0, hi);394
395
396
/* If the left index has not reached the right side of array397
398
* must now sort the right partition.399
400
*/401
402
if (lo < hi0)403
404
quickSortMinToMax(a, lo, hi0);405
406
407
}408
409
}410
411
412
/**413
414
* This is a generic version of C.A.R Hoare's Quick Sort415
416
* algorithm. This will handle arrays that are already417
418
* sorted, and arrays with duplicate keys.<BR>419
420
* <p/>421
422
* If you think of a one dimensional array as going from423
424
* the lowest index on the left to the highest index on the right425
426
* then the parameters to this function are lowest index or427
428
* left and highest index or right. The first time you call429
430
* this function it will be with the parameters 0, a.length - 1.431
432
* (taken out of a code by James Gosling and Kevin A. Smith provided433
434
* with Sun's JDK 1.1.7)435
436
*437
438
* @param a a double array439
440
* @param lo0 left boundary of array partition (inclusive).441
442
* @param hi0 right boundary of array partition (inclusive).443
444
* @deprecated445
446
*/447
448
private static void quickSortMinToMax(double a[], int lo0, int hi0) {449
450
int lo = lo0;451
452
int hi = hi0;453
454
double mid;455
456
457
if (hi0 > lo0) {458
459
460
/* Arbitrarily establishing partition element as the midpoint of461
462
* the array.463
464
*/465
466
mid = a[(int) Math.round((lo0 + hi0) / 2.0)];467
468
469
// loop through the array until indices cross470
471
while (lo <= hi) {472
473
/* find the first element that is greater than or equal to474
475
* the partition element starting from the left Index.476
/**代码未完, 请加载全部代码(NowJava.com).**/执行结果：
本文系作者在时代Java发表，未经许可，不得转载。如有侵权，请联系nowjava@qq.com删除。
编辑于
关注时代Java