3种顺序排序方法。简单排序是指时间复杂度为O(n^2)的排序方法。
1）选择排序
将某个特定值有序的放置在最终位置上---外层循环控制最终位置的序号，内层循环从外层循环序号处向后遍历，找到最小值。
2）插入排序
插入排序将某个特定值插入到值列的某个子集中，并重复该过程---外层循环控制要插入的数据（从第二个数到最后一个），内层循环控制前面已排好序的的值后移。
3）冒泡排序
重复比较相邻的两个元素，并在必要的时候交换双方位置。---外层循环控制每次冒泡到达的最终位置，内层循环交换元素
4）其他：这里写的是一个通用的排序算法，不光是对数值排序，可以对对象排序。对象实现Comparable接口，对象就可以参与比较进行排序。
在对对象进行排序的方法中，就可以调用对象的public int compareTo(Object other)方法来比较对象的先后顺序。
一个可以比较先后顺寻的Student类（按照score大小顺序）：
class Student implements Comparable{
private String name;
private double score;
public Student(String name, double score)
{
this .name = name;
this .score = score;
}
public int compareTo(Object other) {
int result;
if (score > ((Student) other).score)
return 1 ;
else if (score < ((Student) other).score)
return - 1 ;
return 0 ;
}
public String toString(){
String result = "" ;
result = name + " " + score;
return result;
}
}
三种排序方法：
1 package Sort;
2
3 public class SimpleSort {
4
5
6 public static void main(String[] args) {
7
8 Student[] student = new Student[ 7 ];
9
10 student[ 0 ] = new Student( " aa " , 90.32 );
11 student[ 1 ] = new Student( " bb " , 70.32 );
12 student[ 2 ] = new Student( " cc " , 85.32 );
13 student[ 3 ] = new Student( " dd " , 64.32 );
14 student[ 4 ] = new Student( " ee " , 91.32 );
15 student[ 5 ] = new Student( " ff " , 74.32 );
16 student[ 6 ] = new Student( " gg " , 79.32 );
17
18 // selectionSort(student);
19 insertSort(student);
20 // bubbleSort(student);
21
22 for ( int i = 0 ;i < student.length;i ++ )
23 System.out.println(student[i]);
24 }
25
26
27 // 选择排序
28 public static void selectionSort(Comparable[] data){
29
30 int min; // 用min标识最小元素的下标
31 Comparable temp;
32 for ( int index = 0 ;index < data.length - 1 ;index ++ ){ // 外层循环控制每个位置得到一个最终的值
33 min = index;
34 for ( int scan = index + 1 ;scan < data.length;scan ++ ) // 内层循环从外层循环位置处向后扫描
35 if (data[scan].compareTo(data[min]) < 0 )
36 min = scan; // 只记录位置！！！！
37 // 内层for循环完表明一个位置的元素已经选好，交换
38 temp = data[min];
39 data[min] = data[index];
40 data[index] = temp;
41 }
42 }
43
44
45 // 插入排序
46 public static void insertSort(Comparable[] data){
47
48 for ( int index = 1 ;index <= data.length - 1 ;index ++ ) // 外层循环控制每个待插入元素
49 {
50 Comparable key = data[index]; // 待插入元素
51 int position = index; // 用position记录插入后的应该占领位置（如果不发生改变，初试值是它自己的位置）
52
53 // 只记录应该插入的位置，最后一步赋值。！！！
54 // while(data[position-1].compareTo(key) > 0 && position > 0)
55 while (position > 0 && data[position - 1 ].compareTo(key) > 0 )
56 {
57 data[position] = data[position - 1 ];
58 position -- ;
59 }
60 data[position] = key;
61 }
62 }
63
64
65 // 冒泡排序
66 public static void bubbleSort(Comparable[] data){
67
68 int position,scan;
69 Comparable temp;
70 for (position = data.length - 1 ;position >= 0 ;position -- ) // 外层循环控制每趟冒泡到的最终位置
71 {
72 for (scan = 0 ;scan <= position - 1 ;scan ++ ) // 内层循环不断交换相邻两个元素
73 {
74 if (data[scan].compareTo(data[scan + 1 ]) > 0 )
75 {
76 temp = data[scan];
77 data[scan] = data[scan + 1 ];
78 data[scan + 1 ] = temp;
79 }
80 }
81 }
82 }
83
84 }
注意插入排序的内层循环开始写成了这样while(data[position-1].compareTo(key) > 0 && position > 0)，运行起来会导致数组越界的异常。且表达式的判断要把最先决条件放在前面，这一点容易忽略。
运行结果，将数组重新排列了---
dd 64.32
bb 70.32
ff 74.32
gg 79.32
cc 85.32
aa 90.32
ee 91.32
分类:
算法/数据结构/数学
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
