一、直接插入排序 原理:从待排序的数中选出一个来,插入到前面的合适位置
[Java]
纯文本查看
复制代码
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
package
com.xtfggef.algo.sort;
public
class
InsertSort {
static
int
data[] = {
9
,
2
,
7
,
19
,
100
,
97
,
63
,
208
,
55
,
78
};
public
static
void
insertSort() {
int
tmp, j =
0
;
for
(
int
k =
0
; k < data.length; k++) {
//-----1-----
tmp = data[k];
j = k -
1
;
while
(j >=
0
&& tmp < data[j]) {
//-----2-----
data[j +
1
] = data[j];
j--;
}
data[j +
1
] = tmp;
//------3-------
}
}
public
static
void
main(String[] args) {
print();
System.out.println();
insertSort();
System.out.println();
print();
}
static
void
print() {
for
(
int
i =
0
; i < data.length; i++) {
System.out.print(data[i] +
" "
);
}
}
}
|
简单的讲解一下过程:思路上从待排序的数据中选出一个,插入到前面合适的位置,耗时点在插入方面,合适的位置意味着我们需要进行比较找出哪是合适的位置,举个例子:对于9,2,7,19,100,97,63,208,55,78这组数,第一个数9前面没有,不做操作,当第一个数完后,剩下的数就是待排序的数,我们将要从除去9开始的书中选出一个插入到前面合适的位置,拿到2后,放在tmp上,进行注释中的2处的代码,2处的代码就是通过循环找出这个合适的位置,发现比tmp大的数,立即将该数向后移动一位(这样做的目的是:前面需要空出一位来进行插入),最后通过注释3处的代码将数插入。
本排序适合:基本有序的数据
二、选择排序 与直接插入排序正好相反,选择排序是从待排序的数中选出最小的放在已经排好的后面,这个算法选数耗时。
[Java]
纯文本查看
复制代码
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
package
com.xtfggef.algo.sort;
public
class
SelectSort {
static
int
data[] = {
9
,
2
,
7
,
19
,
100
,
97
,
63
,
208
,
55
,
78
};
public
static
void
selectSort() {
int
i, j, k, tmp =
0
;
for
(i =
0
; i < data.length -
1
; i++) {
k = i;
for
(j = i +
1
; j < data.length; j++)
if
(data[j] < data[k])
k = j;
if
(k != i) {
tmp = data[i];
data[i] = data[k];
data[k] = tmp;
}
}
}
public
static
void
main(String[] args) {
print();
System.out.println();
selectSort();
System.out.println();
print();
}
static
void
print() {
for
(
int
i =
0
; i < data.length; i++) {
System.out.print(data[i] +
" "
);
}
}
}
|
通过循环,找出最小的数的下标,赋值于k,即k永远保持待排序数据中最小的数的下标,最后和当前位置i互换数据即可。
三、快速排序 快速排序简称快排,是一种比较快的排序,适合基本无序的数据,为什么这么说呢?下面说下快排的思路: 设置两个指针:i和j,分别指向第一个和最后一个,i像后移动,j向前移动,选第一个数为标准(一般这样做,当然快排的关键就是这个“标准”的选取),从后面开始,找到第一个比标准小的数,互换位置,然后再从前面,找到第一个比标准大的数,互换位置,第一趟的结果就是标准左边的都小于标准,右边的都大于标准(但不一定有序),分成两拨后,继续递归的使用上述方法,最终有序!代码如下:
[Java]
纯文本查看
复制代码
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
package
com.xtfggef.algo.sort;
public
class
QuickSortTest {
static
class
QuickSort {
public
int
data[];
private
int
partition(
int
array[],
int
low,
int
high) {
int
key = array[low];
while
(low < high) {
while
(low < high && array[high] >= key)
high--;
array[low] = array[high];
while
(low < high && array[low] <= key)
low++;
array[high] = array[low];
}
array[low] = key;
return
low;
}
public
int
[] sort(
int
low,
int
high) {
if
(low < high) {
int
result = partition(data, low, high);
sort(low, result -
1
);
sort(result +
1
, high);
}
return
data;
}
}
static
void
print(
int
data[]) {
for
(
int
i =
0
; i < data.length; i++) {
System.out.print(data[i] +
" "
);
}
}
public
static
void
main(String[] args) {
int
data[] = {
20
,
3
,
10
,
9
,
186
,
99
,
200
,
96
,
3000
};
print(data);
System.out.println();
QuickSort qs =
new
QuickSort();
qs.data = data;
qs.sort(
0
, data.length -
1
);
print(data);
}
}
|
四、冒泡排序 冒泡排序是一种很简单,不论是理解还是时间起来都比较容易的一种排序算法,思路简单:小的数一点一点向前起泡,最终有序。
[Java]
纯文本查看
复制代码
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
package
com.xtfggef.algo.sort;
public
class
BubbleSort {
static
int
data[] = {
9
,
2
,
7
,
19
,
100
,
97
,
63
,
208
,
55
,
78
};
public
static
void
bubbleSort() {
int
i, j, tmp =
0
;
for
(i =
0
; i < data.length -
1
; i++) {
for
(j = data.length -
1
; j > i; j--) {
if
(data[j] < data[j -
1
]) {
tmp = data[j];
data[j] = data[j -
1
];
data[j -
1
] = tmp;
}
}
}
}
public
static
void
main(String[] args) {
print();
System.out.println();
bubbleSort();
System.out.println();
print();
}
static
void
print() {
for
(
int
i =
0
; i < data.length; i++) {
System.out.print(data[i] +
" "
);
}
}
}
|
|
|