算法导论-选择排序
选择排序分简单选择排序和堆排序两种。
1.简单选择排序
基本思想：每一次从待排序的记录中选取关键字最小的记录，顺序放在已排好序的记录后面，直到全部记录排序完毕。
特点：时间复杂度为O（n*2），空间复杂度为O（1），不稳定。
简单排序代码：
public
void
selectionSort(
int
[] a ){
for
(
int
i
=
0
; i
<
a.length
-
1
; i
++
) {
int
temp
=
a[i] ;
int
tempIndex
=
0
;
for
(
int
j
=
i
+
1
; j
<
a.length; j
++
) {
if
(a[j]
<
temp) {
temp
=
a[j] ;
tempIndex
=
j ;
}
}
if
(tempIndex
>
0
) {
a[tempIndex]
=
a[i] ;
a[i]
=
temp ;
}
}
}
2.堆排序
基本步骤：a.先把一个无序序列建堆；
b.输出堆顶元素，调整剩余元素成新堆，直至序列有序。
特点：像插入排序算法，它是原地的；像合并排序，时间复杂度是O(nlgn)，即使最坏情况也是如此，这也是它与快速排序相比最大的优点
堆排序代码：
/**
堆排序
*
@author
het
* @date 2010-8-7
*/
public
class
HeapSort {
/**
* 测试
*/
public
static
void
main(String[] args) {
int
[] a
=
{
2
,
1
,
4
,
5
,
6
,
7
,
9
,
10
,
98
,
45
,
80
,
0
,
2
,
3333
};
HeapSort sort
=
new
HeapSort();
sort.MaxHeapSort(a);
for
(
int
i
=
0
; i
<
a.length; i
++
) {
System.out.print(a[i]
+
"
"
);
}
}
/**
* 交换数组中指定的两元素的位置
* PS:Java中的基本元素是不支持传址的，必须是对象或数组才能传址（引用）
*/
public
void
swap(
int
[] data,
int
x,
int
y) {
int
temp
=
data[x];
data[x]
=
data[y];
data[y]
=
temp;
}
/**
* 保持堆的性质（非递归）
*/
private
void
MaxHeapify(
int
[]a ,
int
i ,
int
n){
int
index
=
2
*
i
+
1
;
//
先记录i的左孩子
boolean
isMax
=
false
;
int
temp
=
a[i];
while
(index
<=
n
&&
!
isMax){
if
( index
<
n
&&
a[index]
<
a[index
+
1
] ) {
//
如果右孩子比左孩子更大，用index记录右孩子下标
index
++
;
}
if
(temp
>
a[index]) {
isMax
=
true
;
}
else
{
//
将大者上移
a[i]
=
a[index];
i
=
index ;
index
=
2
*
i
+
1
;
}
}
a[i]
=
temp ;
}
/**
* 保持堆的性质（递归）
*/
private
void
MaxHeapifyRecursion(
int
[] a ,
int
i ,
int
n){
int
lchild
=
2
*
i
+
1
;
//
i的左孩子的下标
int
rchild
=
lchild
+
1
;
//
i的右孩子的下标
int
largest
=
i ;
//
记录 a[i],a[lchild],a[rchild]中的最大者的下标
if
(lchild
<=
n
&&
a[lchild]
>
a[largest]) {
largest
=
lchild ;
}
if
(rchild
<=
n
&&
a[rchild]
>
a[largest]) {
largest
=
rchild ;
}
//
交换
if
(largest
!=
i ) {
swap(a, largest, i);
//
为保持堆的性质，对有孩子的节点继续向下迭代
if
(largest
<=
n
/
2
){
MaxHeapifyRecursion(a, largest , n);
}
}
}
/**
* 建堆,时间复杂度为O(n)
*/
private
void
CreateHeap(
int
[] a){
int
length
=
a.length
-
1
;
//
数组元素的最大下标
//
自a[a.length/2]以后都是叶子节点，故对之前的非叶子节点都调用一次MaxHeapify以建堆
for
(
int
i
=
length
/
2
; i
>=
0
; i
--
) {
MaxHeapify(a, i,length);
//
MaxHeapifyRecursion(a, i, length);
}
}
/**
* 堆排序（最大堆），得到升序序列,时间复杂度为O（nlgn）
*/
public
void
MaxHeapSort(
int
[] a){
CreateHeap(a);
//
输出堆顶元素(交换堆顶元素a[0]与a[a.length-1])，并把剩下的元素调整成一个新堆
for
(
int
i
=
a.length
-
1
; i
>
0
; i
--
) {
swap(a,
0
, i);
MaxHeapify(a,
0
,i
-
1
);
//
MaxHeapifyRecursion(a, 0, i-1);
}
}
}