一、简单选择排序
1. 执行过程:
原始序列:49,38,65,97,76,13,27,49
49 | 38 | 65 | 97 | 76 | 13 | 27 | 49 |
---|
从无序序列中选取一个最小的关键字13,使其与无序序列中的第一个关键字交换,则此时产生了仅含有一个关键字的有序序列,而无序序列中的关键字减少1个,如下:
13 | 38 | 65 | 97 | 76 | 49 | 27 | 49 |
---|
重复上述步骤,直到无序序列中的关键字变为0个为止。
2. 算法思想:
代码:
void selectSort(int R[], int n)
{
int i,j,k;
int temp;
for(i = 0; i < n; ++i)
{
k = i;
for(j = i + 1; j < n; ++j)
{
if(R[k] > R[j])
k = j;
}
temp = R[i];
R[i] = R[k];
R[k] = temp;
}
}
3. 复杂度分析:
(1)时间复杂度分析
外层循环执行n次,内层循环执行n-1次,将最内层循环中的比较操作视为关键操作,其执行次数为(n-1+1)(n-1)/2=n(n-1)/2,即本算法的复杂度为O(n²)。
(2)空间复杂度为O(1)
二、堆排序
1. 概念
堆是一棵顺序存储的完全二叉树。完全二叉树中所有非终端节点的值均不大于(或不小于)其左、右孩子节点的值。
- 其中每个节点的值小于等于其左、右孩子的值,这样的堆称为小根堆;
- 其中每个节点的值大于等于其左、右孩子的值,这样的堆称为大根堆;
2. 基本思想
将待排序的序列构造成一个大顶堆。此时,整个序列的最大值就是堆顶的根节点。将它移走(其实就是将其与堆数组的末尾元素交换,此时末尾元素就是最大值),然后将剩余的 n-1 个序列重新构造成一个堆,这样就会得到 n 个元素中次大的值。如此反复执行,便能得到一个有序序列了。
堆排序的实现需要解决的两个关键问题:
- 将一个无序序列构成一个堆。
- 输出堆顶元素后,调整剩余元素成为一个新堆。
(1) 插入结点
需要在插入结点后保持堆的性质,即完全二叉树形态与父大子小性质,因此需要先将要插入的结点x放在最底层的最右边,插入后满足完全二叉树的特点;然后把x依次向上调整到合适位置以满足父大子小的性质。
当删除堆中的一个结点时,原来的位置就会出现一个孔,填充孔的方法是,把最底层最右边的叶子的值赋给该孔并下调到合适的位置,最后把该叶子删除。
3. 代码
public class heapSort
{
/**
* 构建大顶堆
*/
public static void main(String[] args)
{
int a[] = {49, 38, 65, 97, 76, 13, 27, 49};
System.out.println("排序前:" + Arrays.toString(a));
heapSort(a);
System.out.println("排序后:" + Arrays.toString(a));
}
public static void heapSort(int[] a)
{
for(int i = a.length / 2 - 1; i >= 0; i--)
{
adjustHeap(a, i, a.length - 1);
}
// 将堆顶记录和当前未经排序子序列的最后一个记录交换
for(int i = a.length - 1; i >= 0; i--)
{
int temp = a[0];
a[0] = a[i];
a[i] = temp;
// 将a中前i-1个记录重新调整为大顶堆
adjustHeap(a, 0, i - 1);
}
}
public static void adjustHeap(int[] a, int i, int len)
{
int temp = a[i];
for(int j = 2 * i; j < len; j *= 2)// 沿关键字较大的孩子结点向下筛选
{
if(j < len && a[j] < a[j+1])
++j;
if(temp >= a[j])
break;
a[i] = a[j];
i = j;
}
a[i] = temp;
}
}
4. 复杂度分析:
(1)时间复杂度:O(nlog₂n)
(2) 空间复杂度:O(1)